![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fdisk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / etc / build|
Return to fdisk.c CVS log | Up to [MW Coherent from dump] / coherent / d / etc / build |
1.1 root 1: /*
2: * fdisk.c
3: * 6/10/91
4: * cc -o fdisk fdisk.c -f
5: * Change partitioning IBM-AT (or other type) hard disk.
6: * Usage: /etc/fdisk [ -crvxB ] [ -b bootb ] [ device ... ]
7: * Options:
8: * -B Invoked during installation
9: * -b Add master boot block code from "bootb"
10: * -c Configure hard disk geometry
11: * -r Read only
12: * -v Print c:h:s start and end values
13: * -x Use devices /dev/xt[01]x instead of /dev/at[01]x
14: * If no device argument is given, fdisk supplies "/dev/[ax]t[01]x"
15: * as appropriate.
16: */
17:
18: #include <stdio.h>
19: #include <l.out.h>
20: #include <setjmp.h>
21: #include <sys/devices.h>
22: #include <sys/fdisk.h>
23: #include <sys/hdioctl.h>
24: #include <sys/stat.h>
25: #include "fdisk0.h"
26:
27: /* Globals. */
28: int Bflag; /* special patching during installation */
29: char *argv0; /* Command name, for error messages. */
30: int badflag; /* Partition table is bad. */
31: char buf[NBUF]; /* Input buffer. */
32: int cfd; /* Current file descriptor. */
33: int cflag; /* Configure disk geometry. */
34: int cylflag; /* Specify base and size in cylinders. */
35: unsigned int cylsize; /* Cylinder size in sectors. */
36: unsigned char *defargs[3] = { "/dev/at0x", "/dev/at1x", NULL };
37: unsigned char *device; /* Partition table device name. */
38: unsigned char *drivename; /* Disk drive name. */
39: int drivenum; /* Drive number. */
40: int freepart; /* Free partition. */
41: unsigned long freesize; /* Free size. */
42: unsigned long freestart; /* First free sector. */
43: HDISK_S hd; /* Structure to house boot block. */
44: hdparm_t hdparms; /* Hard disk parameter block. */
45: int isatflag; /* Device is an AT-type disk. */
46: jmp_buf loop; /* Interactive input loop entry point. */
47: char *mboot; /* Name of new master boot file. */
48: int megflag; /* Specify sizes in megabytes. */
49: unsigned int nspt; /* Number of sectors per track. */
50: unsigned int ncyls; /* Number of cylinders. */
51: HDISK_S newhd; /* Structure to house new boot block. */
52: unsigned int nheads; /* Number of heads per track. */
53: int nmods; /* Modifications to the table. */
54: unsigned long nsectors; /* Total sectors. */
55: int openmode = 2; /* Default open mode: read/write. */
56: int partbase; /* Partition number base (0 or 4). */
57: int qflag; /* Quit. */
58: int rflag; /* Readonly. */
59: int vflag; /* Print c:h:s start and end values. */
60:
61: main(argc, argv) int argc; char *argv[];
62: {
63: register char *s;
64: int fd0, fd1, i;
65: struct stat sb;
66:
67: /* Sanity check. */
68: argv0 = argv[0];
69: if (sizeof hd != SSIZE)
70: fatal("invalid HDISK_S size %u != %u", sizeof hd, SSIZE);
71: while (argc > 1 && **++argv == '-') {
72: --argc;
73: for (s = &argv[0][1]; *s; ++s) {
74: switch(*s) {
75: case 'B':
76: ++Bflag;
77: break;
78: case 'b':
79: if (argc-- < 2)
80: usage();
81: mboot = *++argv;
82: break;
83: case 'c':
84: ++cflag;
85: break;
86: case 'r':
87: ++rflag;
88: openmode = 0;
89: break;
90: case 'v':
91: ++vflag;
92: break;
93: case 'V':
94: fprintf(stderr, "%s: V%s\n", argv0, VERSION);
95: break;
96: case 'x':
97: defargs[0][5] = defargs[1][5] = 'x';
98: break;
99: default:
100: usage();
101: break;
102: }
103: }
104: }
105: if (openmode == 0 && mboot != NULL)
106: fatal("cannot specify both 'b' and 'r' options");
107: if (--argc == 0) {
108: /* No arguments specified, take defaults. */
109: argv = defargs;
110: fd0 = open(argv[0], 0);
111: fd1 = open(argv[1], 0);
112: if (fd1 >= 0) {
113: ++argc;
114: close(fd1);
115: } else
116: argv[1] = NULL;
117: if (fd0 >= 0) {
118: ++argc;
119: close(fd0);
120: } else
121: ++argv;
122: if (argc == 0)
123: fatal("cannot open default devices");
124: }
125: cls(0);
126: printf(
127: "This program will let you change partition information for each disk drive.\n"
128: "A disk drive can be divided into one to four logical partitions.\n"
129: "You can change the active partition (the partition which your\n"
130: "system boots by default) or change the layout of logical partitions.\n"
131: "Other programs which change hard disk partition information\n"
132: "may list logical partitions in a different order.\n"
133: "Hit <Esc><Enter> to return to the main menu at any time.\n"
134: );
135: get_line("Now hit <Enter>.");
136: for (i = 0; (device = *argv++) != NULL; ++i) {
137: /*
138: * Set the drive number, drive name, partition base.
139: * /etc/build calls /etc/fdisk with an ordered list of args
140: * which correspond to the drive number, so this usually works.
141: * But there is no obvious way to find the correct drive number
142: * when the user invokes /etc/fdisk directly; hence the
143: * kludge below for AT disks.
144: */
145: drivenum = i;
146: partbase = i * NPARTN;
147: drivename = "Drive x";
148: drivename[6] = drivenum + '0';
149:
150: /*
151: * Check if device is an AT device.
152: * The fix_chs() kludge only works for AT-type disks.
153: */
154: if (stat(device, &sb) < 0)
155: fatal("cannot stat \"%s\"", device);
156: isatflag = (major(sb.st_rdev) == AT_MAJOR);
157: if (isatflag) {
158: /* Kludge, see comment above... */
159: if (minor(sb.st_rdev) == AT0X_MINOR) {
160: drivenum = partbase = 0;
161: drivename = "Drive 0";
162: } else if (minor(sb.st_rdev) == AT1X_MINOR) {
163: drivenum = 1;
164: partbase = 4;
165: drivename = "Drive 1";
166: } /* else huh? */
167: }
168:
169: /* Do it. */
170: fdisk(*argv == NULL);
171: if (qflag)
172: break;
173: }
174: exit(0);
175: }
176:
177: /*
178: * Copy /coherent to /tmp/coherent and
179: * patch /tmp/coherent disk parameters "atparms" with hdparms.
180: * [Primary/secondary patch stuff disappears with COH 3.2.1.]
181: */
182: void
183: atpatch()
184: {
185: register int i;
186: int dbase;
187: unsigned char *hdp;
188: FILE *fp;
189:
190: if (!Bflag)
191: return;
192: if (drivenum == 0)
193: dbase = 0;
194: else if (drivenum == 1)
195: dbase = sizeof hdparms;
196: else
197: fatal("unrecognized drive number");
198:
199: /*
200: * Write commands to patchfile - they run after kernel is linked.
201: */
202: fp = fopen(PATCHFILE, "a");
203: fprintf(fp, "/conf/patch /mnt/drv/at \\\n");
204: for (i = 0, hdp = (char *)&hdparms; i < sizeof hdparms; i++, hdp++) {
205: fprintf(fp, " atparm_+%d=%u:c \\\n", dbase + i, *hdp);
206: }
207: fprintf(fp, "\n");
208: fprintf(fp, "/conf/patch /mnt/coherent >/dev/null \\\n");
209: for (i = 0, hdp = (char *)&hdparms; i < sizeof hdparms; i++, hdp++) {
210: fprintf(fp, " atparm_+%d=%u:c \\\n", dbase + i, *hdp);
211: }
212: fprintf(fp, "\n");
213: fclose(fp);
214: }
215:
216: /*
217: * Change the active partition.
218: */
219: void
220: change_active()
221: {
222: int active, oactive, i;
223:
224: active = oactive = -1;
225: for (i=0; i < NPARTN; i++)
226: if (hd.hd_partn[i].p_boot == 0x80) {
227: hd.hd_partn[i].p_boot = 0; /* make inactive */
228: active = oactive = i; /* remember old */
229: }
230: if (!yes_no("Do you want to make a partition active")) {
231: active = -1;
232: if (active != oactive)
233: ++nmods;
234: return;
235: }
236: if (active == -1)
237: active = 0; /* default */
238: active = get_int("Active partition", active + partbase, partbase, partbase + NPARTN-1);
239: active -= partbase;
240: hd.hd_partn[active].p_boot = 0x80; /* make active */
241: if (active != oactive)
242: ++nmods;
243: }
244:
245: /*
246: * Interactively change the table entry for logical partition n.
247: * Grunge city.
248: */
249: void
250: change_part(n) int n;
251: {
252: register FDISK_S *p;
253: int sys, old;
254: unsigned int c, h, s;
255: unsigned long size, osize, base, obase, end;
256: static int optflag;
257:
258: /* Get options first time through. */
259: if (optflag == 0) {
260: cls(0);
261: printf(
262: "Existing data on a partition will be lost if you change the\n"
263: "base or the size of the partition. Be sure you have backed up\n"
264: "all data from any partition which you are going to change.\n"
265: "\n"
266: "You may specify partition bases in cylinders or in tracks.\n"
267: );
268: cylflag = yes_no("Do you want to specify bases in cylinders");
269: printf("You may specify partition sizes in %s or in megabytes.\n",
270: cylflag ? "cylinders" : "tracks");
271: megflag = !yes_no("Do you want to specify partition sizes in %s",
272: cylflag ? "cylinders" : "tracks");
273: ++optflag;
274: print_part(0);
275: }
276: p = &hd.hd_partn[n];
277: printf("\nPartition %d:\n", n + partbase);
278: size = p->p_size;
279:
280: /* Get new system type. */
281: old = p->p_sys;
282: again:
283: if (old != SYS_EMPTY)
284: printf("The current operating system type is %s.\n", sys_type(old));
285: if (yes_no("Do you want this to be a COHERENT partition"))
286: sys = SYS_COH;
287: #if 0
288: /* any partition they modify better be left as COH or empty! */
289: else if (old != SYS_COH && yes_no("Do you want the partition type left unchanged"))
290: sys = old;
291: else if (old != SYS_EMPTY && yes_no("Do you want the partition marked as unused"))
292: sys = SYS_EMPTY;
293: #endif
294: else if (yes_no("Do you want the partition marked as unused"))
295: sys = SYS_EMPTY;
296: else {
297: printf(
298: #if 0
299: "This program can mark a partition as a COHERENT partition,\n"
300: "leave its type unchanged, or mark it as unused. It cannot\n"
301: "initialize a partition for use by any other operating system;\n"
302: "to do so, you must mark it as unused now and subsequently use\n"
303: "the disk partitioning program provided by the other system\n"
304: "to initialize it correctly.\n"
305: #else
306: "\nThis program can mark a partition as a COHERENT partition\n"
307: "or mark it as unused. It CANNOT initialize a partition for\n"
308: "use by any other operating system. To do so, you must mark\n"
309: "it as unused now and subsequently use the disk partitioning\n"
310: "program provided by the other system to initialize it correctly.\n\n"
311: #endif
312: );
313: if (yes_no("Do you still want to modify this partition"))
314: goto again;
315: return;
316: }
317: if (sys != old) {
318: p->p_sys = sys;
319: ++nmods;
320: }
321: if (sys == SYS_EMPTY) {
322: printf(
323: "For you convenience in partitioning your hard disk, this program\n"
324: "lets you create unused partitions with nonzero base and size.\n"
325: "However, other disk partitioning software may not work correctly\n"
326: "unless unused partitions have base and size zero.\n"
327: );
328: if (yes_no("Do you want to zero the partition base and size")) {
329: memset(p, 0, sizeof(FDISK_S));
330: nmods++;
331: printf("\n");
332: return;
333: }
334: }
335: getbase:
336: /* Specify the base. */
337: /* Default: old or first free or track 1. */
338: obase = p->p_base;
339: base = (size != 0L) ? obase : (freesize != 0) ? freestart : nspt;
340: if (cylflag) { /* in cylinders */
341: base = sec_to_c(base);
342: base = get_long("Base cylinder", base, 0L, (long) ncyls - 1);
343: if (base == 0)
344: base = nspt; /* skip first track for cyl 0 */
345: else
346: base *= nspt * nheads; /* cylinders to sectors */
347: } else { /* in tracks */
348: base = sec_upto_t(base);
349: base = get_long("Base track", base, 1L, (long)ncyls * nheads - 1);
350: base *= nspt; /* tracks to sectors */
351: }
352:
353: /* Check that base falls at a track boundary. */
354: /* It might not if the disk was previously partitioned. */
355: c = sec_to_c(base);
356: h = sec_to_h(base);
357: s = sec_to_s(base);
358: if (s != 1) {
359: printf("Partitions should begin at a track boundary.\n");
360: printf("The partition does not begin at a track boundary with the selected base.\n");
361: printf("The next track boundary is at track %u\n", sec_upto_t(base));
362: if (yes_no("Do you want to change the partition base"))
363: goto getbase;
364: }
365:
366: /* Update the partition table base and start information. */
367: if (base != obase) {
368: ++nmods;
369: p->p_base = base;
370: p->p_bcyl = c & 0xFF;
371: p->p_bhd = h;
372: p->p_bsec = ((c >> 2) & CYLMASK ) | s;
373: }
374:
375: /* Specify the partition size. */
376: /* Default size: free block size, old size, largest possible. */
377: osize = size;
378: size = (base == freestart) ? freesize : (osize != 0L) ? osize : nsectors - base;
379: if (megflag) { /* in megabytes */
380: size = meg(size);
381: if ((long)meg(nsectors - base) == 0) {
382: printf("Less than a megabyte of space remains.\n");
383: size = nsectors - base;
384: } else {
385: size = get_long("Partition size in megabytes", size, 0L,
386: (long) meg(nsectors - base));
387: size *= 1000000L; /* megabytes to bytes */
388: size /= SSIZE; /* to sectors */
389: size = sec_upto_c(size); /* round up to cylinders */
390: size *= nspt * nheads; /* cylinders to sectors */
391: }
392: } else if (cylflag) { /* in cylinders */
393: /* Tricky stuff again. */
394: end = base + size - 1;
395: size = sec_to_c(end) - sec_to_c(base) + 1;
396: size = get_long("Partition size in cylinders", size, 0L,
397: (long) ncyls - sec_to_c(base));
398: size *= nspt * nheads; /* cylinders to sectors */
399: } else { /* in tracks */
400: size = sec_upto_t(size);
401: size = get_long("Partition size in tracks", size, 0L,
402: (long) sec_upto_t(nsectors - base));
403: size *= nspt; /* tracks to sectors */
404: }
405: /*
406: * Adjust size to end at cylinder boundary
407: * if it did not start at cylinder boundary.
408: */
409: if ((megflag || cylflag) && size != 0 && base % cylsize != 0 && size > base % cylsize)
410: size -= base % cylsize;
411:
412: /* Check the size. */
413: if (base + size > nsectors)
414: size = nsectors - base; /* roundup too big */
415: end = base + size - 1;
416: c = sec_to_c(end);
417: h = sec_to_h(end);
418: s = sec_to_s(end);
419: if (s != nspt) {
420: printf("Partitions should end at a track boundary.\n");
421: printf("A partition with %u more sectors would end at a track boundary.\n", nspt - s);
422: if (yes_no("Do you want to add %u sectors to the partition size",
423: nspt - s)) {
424: size += nspt - s;
425: s = nspt;
426: }
427: }
428:
429: /* Update the partition table size and end. */
430: if (base != obase || size != osize) {
431: ++nmods;
432: p->p_size = size;
433: p->p_ecyl = c & 0xFF;
434: p->p_ehd = h;
435: p->p_esec = ((c >> 2) & CYLMASK ) | s;
436: }
437: printf("\n");
438: }
439:
440: /*
441: * Check a c:h:s entry in the partition table for consistency.
442: * Try correcting any inconsistency found, with warning to the user.
443: * The flag is 1 for beginning, 0 for end.
444: */
445: void
446: check_chs(p, flag) FDISK_S *p; int flag;
447: {
448: unsigned int c, h, s, nc, nh, ns;
449: unsigned long n;
450:
451: again:
452: if (flag) {
453: c = bcyl(p);
454: h = bhd(p);
455: s = bsec(p);
456: n = p->p_base;
457: } else {
458: c = ecyl(p);
459: h = ehd(p);
460: s = esec(p);
461: n = p->p_base + p->p_size - 1;
462: }
463: if (c >= ncyls
464: || h >= nheads
465: || (s == 0 || s > nspt)
466: || n != chs_to_sec(c, h, s)) {
467: nc = sec_to_c(n);
468: nh = sec_to_h(n);
469: ns = sec_to_s(n);
470: cls(1);
471: printf("According to your computer system, the disk contains\n");
472: printf("%u cylinders (0 to %u), %u heads (0 to %u), and %u sectors\n",
473: ncyls, ncyls - 1, nheads, nheads -1, nspt);
474: printf("per track (1 to %u). According to the partition table, a partition\n",
475: nspt);
476: printf("%s at sector %lu, which corresponds to a c:h:s of %u:%u:%u.\n",
477: (flag) ? "begins" : "ends" , n, nc, nh, ns);
478: printf("But the partition table entry gives a c:h:s of %u:%u:%u.\n",
479: c, h, s);
480:
481: if (flag) {
482: printf(
483: "\n"
484: "An inconsistency in a partition table entry usually occurs because\n"
485: "the system CMOS RAM area specifies the hard disk geometry incorrectly;\n"
486: "that is, your disk does not contain %u cylinders, %u heads, and %u sectors.\n",
487: ncyls, nheads, nspt);
488: if (!cflag) {
489: printf(
490: "If you think the disk geometry values above are wrong, invoke this program\n"
491: "again using the \"-c\" option to correct them. Because changing these\n"
492: "values is dangerous and you have not specified the \"-c\" option, this\n"
493: "program will now terminate.\n"
494: );
495: exit(1);
496: }
497: if (isatflag) {
498: printf(
499: "This program lets you to resolve the inconsistency by specifying correct\n"
500: "values for the disk geometry (number of cylinders, heads and sectors) or by\n"
501: "making the partition table entry consistent with the given values.\n"
502: );
503: if (yes_no("Do you think the above disk geometry values are wrong")) {
504: fix_chs();
505: goto again;
506: }
507: }
508: }
509:
510: printf("This program will now change the c:h:s of the entry to %u:%u:%u\n",
511: nc, nh, ns);
512: printf(
513: "to resolve this inconsistency. Changing a partition table entry can\n"
514: "make data on existing filesystems inaccessible. If you feel this change is\n"
515: "incorrect, exit from this program now without updating the partition table.\n"
516: );
517: if (yes_no("Do you want to exit from this program"))
518: exit(1);
519: ++nmods;
520: if (flag) {
521: p->p_bcyl = nc & 0xFF;
522: p->p_bhd = nh;
523: p->p_bsec = ((nc >> 2) & CYLMASK ) | ns;
524: } else {
525: p->p_ecyl = nc & 0xFF;
526: p->p_ehd = nh;
527: p->p_esec = ((nc >> 2) & CYLMASK ) | ns;
528: }
529: }
530: }
531:
532: /*
533: * Clear the IBM-AT console screen.
534: * Prompt for <Enter> if the flag is true or if rflag.
535: */
536: void
537: cls(flag) register int flag;
538: {
539: if (flag || rflag) {
540: printf("\nHit <Enter> to continue...");
541: fflush(stdout);
542: fgets(buf, sizeof buf, stdin);
543: }
544: putchar(0x1B);
545: putchar('[');
546: putchar('2');
547: putchar('J');
548: fflush(stdout);
549: }
550:
551: #if DOSSHRINK
552: /*
553: * Shrink an MS-DOS partition.
554: * PFM.
555: */
556: void
557: dos_shrink(n) int n;
558: {
559: cls(0);
560: printf(
561: "You can sometimes shrink an existing MS-DOS partition to make room for\n"
562: "a COHERENT partition if your disk is entirely allocated to MS-DOS.\n"
563: "This program will attempt to shrink the MS-DOS partition without destroying\n"
564: "the data on it. However, you should BACK UP ALL DATA from the MS-DOS\n"
565: "partition to diskettes before you try to shrink it.\n"
566: );
567: if (freepart == -1) {
568: printf("%s", drivename);
569: printf(
570: " does not contain an unused partition. Shrinking an MS-DOS\n"
571: "partition will create additional free space on the disk, but there\n"
572: "is currently no partition table entry available for the freed space.\n"
573: );
574: if (!yes_no("Do you want to shrink the MS-DOS partition anyway"))
575: return;
576: }
577:
578: /* Go for smoke. */
579: sprintf(buf, "/etc/dosshrink %s %d %s\n", device, n, device);
580: buf[strlen(buf) - 2] = 'a' + n;
581: if (system(buf) != 0) {
582: printf("Shrinking of MS-DOS partition failed.\n");
583: return;
584: }
585:
586: /* Read the partition table again to get the changed entry. */
587: if (lseek(cfd, 0L, 0) != 0L)
588: fatal("%s: seek failed", device);
589: else if (read(cfd, &newhd, sizeof hd) != sizeof hd) {
590: close(cfd);
591: fatal("%s: read error", device);
592: } else
593: memcpy(&hd.hd_partn[n], &newhd.hd_partn[n], sizeof(FDISK_S));
594: }
595: #endif
596:
597: /*
598: * Print drive information.
599: */
600: void
601: drive_info()
602: {
603: printf("%s has %u cylinders, %u heads, and %u sectors per track.\n",
604: drivename, ncyls, nheads, nspt);
605: printf("It contains:\n");
606: printf("\t%u cylinders of %lu bytes each,\n",
607: ncyls, (long)cylsize * SSIZE);
608: printf("\t%u tracks of %lu bytes each,\n",
609: ncyls * nheads, (long)nspt * SSIZE);
610: printf("\t%lu sectors of %d bytes each,\n",
611: nsectors, SSIZE);
612: printf("or a total of %ld bytes (%.2f megabytes).\n",
613: nsectors * SSIZE, meg(nsectors));
614: }
615:
616: /*
617: * Print a fatal error message and die.
618: */
619: void
620: fatal(args) char *args;
621: {
622: fprintf(stderr, "%s: %r\n", argv0, &args);
623: exit(1);
624: }
625:
626: /*
627: * Print/change configuration for given device.
628: * The 'lastflag' is true if the current device is the last one.
629: */
630: void
631: fdisk(lastflag) int lastflag;
632: {
633: int nfd, p, flag;
634: unsigned action;
635: static int firstflag = 1;
636:
637: nmods = 0;
638: if ((cfd = open(device, openmode)) < 0)
639: fatal("cannot open \"%s\"", device);
640:
641: /* Obtain drive characteristics. */
642: if (ioctl(cfd, HDGETA, (char *)&hdparms) == -1)
643: fatal("cannot get \"%s\" drive characteristics", device);
644: ncyls = (hdparms.ncyl[1] << 8) | hdparms.ncyl[0];
645: if (ncyls > 1024) {
646: printf(
647: "\n"
648: "The disk controller says your disk has %d cylinders.\n"
649: "COHERENT requires cylinder numbers in the range 0 to 1023.\n"
650: "Accordingly, this program will use 1024 as the effective\n"
651: "number of cylinders on your disk.\n"
652: , ncyls);
653: ncyls = 1024;
654: }
655: nheads = hdparms.nhead;
656: nspt = hdparms.nspt;
657: cylsize = nheads * nspt;
658: nsectors = (long)ncyls * cylsize;
659:
660: /* Print drive characteristics and allow user to patch. */
661: if (cflag && isatflag) {
662: cls(1);
663: printf("According to your computer system:\n");
664: drive_info();
665: if (!yes_no("Do you think the above values are correct"))
666: fix_chs();
667: }
668: close(cfd);
669:
670: /* Read the current boot block. */
671: cfd = get_boot(device, openmode, &hd); /* read boot */
672: if (cflag)
673: saveboot();
674:
675: /* Check for Ontrack Disk Manager. */
676: if (*(unsigned short *)(&hd.hd_boot[0xFC]) == HDSIG) {
677: printf(
678: "\n"
679: "Your hard disk appears to include Disk Manager software. Disk Manager can\n"
680: "partition your disk into more than four partitions, but COHERENT only\n"
681: "understands the first four partitions. If you have more than four\n"
682: "partitions on your disk, you will not see information about the additional\n"
683: "partitions, so proceed with extreme caution.\n"
684: "To install COHERENT while leaving Disk Manager intact, you must\n"
685: "remove all data from one of the first four disk partitions.\n"
686: );
687: if (firstflag && mboot != NULL)
688: printf(
689: "\n"
690: "If you use the COHERENT master bootstrap and you have more than four\n"
691: "Disk Manager partitions, ALL data in any Disk Manager partition\n"
692: "other than the first four partitions WILL BE LOST!\n"
693: );
694: if (!yes_no("Do you want to continue partitioning your disk"))
695: exit(1);
696: }
697:
698: /* Read master boot if desired. */
699: if (firstflag && mboot != NULL) {
700: nfd = get_boot(mboot, 0, &newhd); /* read new boot */
701: close(nfd);
702: if (newhd.hd_sig != HDSIG)
703: fatal("invalid signature in \"%s\"", mboot);
704: memcpy(hd.hd_boot, newhd.hd_boot, sizeof hd.hd_boot);
705: nmods++;
706: }
707: firstflag = 0; /* replace mboot only on first device */
708:
709: /* If no signature, zap the partition entries. */
710: if (hd.hd_sig != HDSIG) {
711: printf(
712: "The boot block on this disk drive does not contain a valid partition table.\n"
713: "This program will now create a valid partition table with zeroed entries.\n"
714: "Exit from this program immediately if you do not want to zero the entries.\n"
715: );
716: if (yes_no("Do you want to exit instead of zeroing the partition table"))
717: exit(1);
718: memset(hd.hd_partn, 0, NPARTN * sizeof(FDISK_S));
719: hd.hd_sig = HDSIG;
720: nmods++;
721: }
722:
723: /* If readonly, print information and return. */
724: if (openmode == 0) {
725: print_part(0);
726: close(cfd);
727: return;
728: }
729:
730: /* Interactive input loop. */
731: for (flag = 1; ; ) {
732: setjmp(loop);
733: print_part(flag);
734: flag = 0;
735: printf(
736: "Possible actions:\n"
737: "\t0 = Quit\n"
738: "\t1 = Change active partition (or make no partition active)\n"
739: "\t2 = Change one logical partition\n"
740: "\t3 = Change all logical partitions\n"
741: "\t4 = Delete one logical partition\n"
742: "\t5 = Change drive characteristics\n"
743: "\t6 = Display drive information\n"
744: );
745: if (lastflag)
746: action = get_int("Action", 0, 0, 6);
747: else {
748: printf("\t7 = Proceed with next drive\n");
749: action = get_int("Action", 7, 0, 7);
750: }
751:
752: switch(action) {
753: case 0:
754: if (quit(device, cfd) == 1) {
755: qflag = 1;
756: return;
757: }
758: continue;
759: case 1:
760: printf("Change active partition:\n");
761: change_active();
762: continue;
763: case 2:
764: p = (freepart != -1) ? freepart : 0;
765: p = get_int("Which partition", p + partbase, partbase, partbase + NPARTN - 1);
766: p -= partbase;
767: if (action == 2)
768: change_part(p);
769: continue;
770: case 3:
771: for (p=0; p < NPARTN; ) {
772: change_part(p++);
773: if (p < NPARTN)
774: print_part(0);
775: }
776: continue;
777: case 4:
778: p = get_int("Which partition", partbase, partbase, partbase + NPARTN - 1);
779: p -= partbase;
780: memset(&hd.hd_partn[p], 0, sizeof(FDISK_S));
781: nmods++;
782: continue;
783: case 5:
784: cls(0);
785: printf("According to your computer system:\n");
786: drive_info();
787: if (!yes_no("Do you think the above values are correct"))
788: fix_chs();
789: continue;
790: case 6:
791: cls(0);
792: drive_info();
793: flag = 1;
794: continue;
795: case 7:
796: if (quit(device, cfd) == 1)
797: return;
798: continue;
799: default:
800: continue;
801: }
802: }
803: }
804:
805: /*
806: * Interactively obtain new disk geometry values.
807: * Update running /coherent with correct values using HDSETA.
808: * Call atpatch to create patched /tmp/coherent and /tmp/boot.[01].
809: */
810: void
811: fix_chs()
812: {
813: register int i;
814:
815: printf(
816: "Warning: if you specify incorrect disk parameter values, data on\n"
817: "existing partitions may be lost or your disk may not operate correctly.\n"
818: "Consult your disk controller manual or call your disk vendor\n"
819: "if you do not know the correct values.\n"
820: );
821: if (!yes_no("Are you sure you want to change the disk parameter values"))
822: return;
823:
824: /*
825: * Modify current values before displaying them as defaults.
826: */
827: i = (hdparms.wpcc[1] << 8) | (hdparms.wpcc[0]);
828: if (i < -1 || i >= ncyls)
829: i = -1;
830: hdparms.ctrl &= 0x0f;
831:
832: ncyls = get_int("Number of cylinders", ncyls, 1, 1024);
833: nheads = get_int("Number of heads", nheads, 1, 255);
834: nspt = get_int("Number of sectors per track", nspt, 1, 255);
835: hdparms.ctrl = get_int("Control byte", hdparms.ctrl, 0, 255);
836: i = get_int("Write pre-compensation cylinder", i, -1, ncyls+1);
837: hdparms.wpcc[1] = i >> 8;
838: hdparms.wpcc[0] = i & 0xFF;
839: cylsize = nheads * nspt;
840: nsectors = (long)ncyls * cylsize;
841: hdparms.ncyl[1] = ncyls >> 8;
842: hdparms.ncyl[0] = ncyls & 0xFF;
843: hdparms.nhead = nheads;
844: hdparms.nspt = nspt;
845: if (ioctl(cfd, HDSETA, (char *)&hdparms) == -1)
846: fatal("cannot set \"%s\" drive characteristics", device);
847: if (isatflag)
848: atpatch();
849: }
850:
851: /*
852: * Read boot block from a file into the given structure.
853: * Return a file descriptor to the open file.
854: */
855: int
856: get_boot(name, mode, hdp) char *name; HDISK_S *hdp;
857: {
858: int fd;
859:
860: /* Open the file. */
861: if ((fd = open(name, mode)) < 0)
862: fatal("cannot open \"%s\"", name);
863: /* Read the current boot block into the hd structure. */
864: if (read(fd, hdp, sizeof hd) != sizeof hd) {
865: close(fd);
866: fatal("read error on \"%s\"", name);
867: }
868: return fd;
869: }
870:
871: /*
872: * Prompt for integer input from the user.
873: * Accept data in range min to max.
874: * Return a valid result.
875: */
876: int
877: get_int(prompt, defval, min, max) char *prompt; register int defval, min, max;
878: {
879: int val;
880: char *s;
881:
882: for (;;) {
883: s = get_line("%s [%u]?", prompt, defval);
884: if (*s == '\0')
885: return defval; /* take default */
886: val = atoi(s);
887: if (val >= min && val <= max)
888: return val;
889: printf("Please enter a value between %u and %u.\n", min, max);
890: }
891: }
892:
893: /*
894: * Print the args and get a line from the user to buf[].
895: * Strip the trailing newline and return a pointer to the first non-space.
896: */
897: char *
898: get_line(args) char *args;
899: {
900: register char *s;
901:
902: printf("%r ", &args);
903: fflush(stdout);
904: fgets(buf, sizeof buf, stdin);
905: buf[strlen(buf) - 1] = '\0';
906: for (s = buf; ; ++s) {
907: if (*s == 0x1B) /* <Esc> returns to loop */
908: longjmp(loop, 1);
909: else if (*s != ' ' && *s != '\t')
910: return s;
911: }
912: }
913:
914: /*
915: * Prompt for long input from the user.
916: * Accept data in range min to max.
917: * Return the result.
918: */
919: long
920: get_long(prompt, defval, min, max) char *prompt; register long defval, min, max;
921: {
922: long val;
923: char *s;
924:
925: for (;;) {
926: s = get_line("%s [%lu]?", prompt, defval);
927: if (*s == '\0')
928: return defval; /* take default */
929: val = atol(s);
930: if (val >= min && val <= max)
931: return val;
932: printf("Please enter a value between %lu and %lu.\n", min, max);
933: }
934: }
935:
936: /*
937: * Compare two partition table entries.
938: * Called by qsort.
939: * The result is sorted by base, with empty entries at the end.
940: */
941: int
942: pcompare(pp1, pp2) FDISK_S **pp1, **pp2;
943: {
944: register FDISK_S *p1, *p2;
945:
946: p1 = *pp1;
947: p2 = *pp2;
948: if (p1->p_size == 0)
949: return (p2->p_size == 0) ? 0 : 1;
950: else if (p2->p_size == 0)
951: return -1;
952: else if (p1->p_base < p2->p_base)
953: return -1;
954: else if (p1->p_base == p2->p_base)
955: return 0;
956: else
957: return 1;
958: }
959:
960: /*
961: * Output partition information.
962: */
963: void
964: print_part(flag) int flag;
965: {
966: register FDISK_S *p;
967: register char c, *s, *dname;
968: int i;
969: unsigned long end;
970:
971: cls(flag);
972: printf("%s currently has the following logical partitions:\n", drivename);
973: printf(" [ In Cylinders ] [ In Tracks ]\n");
974: printf("Number Type Start End Size Start End Size Mbytes Blocks Name\n");
975: for (i = 0; i < NPARTN; ++i) {
976: p = &hd.hd_partn[i];
977: if (p->p_size == 0L)
978: end = p->p_base = 0L;
979: else
980: end = p->p_base + p->p_size - 1;
981: printf("%d", partbase + i);
982: printf("%s\t", (p->p_boot == 0x80) ? " Boot" : "");
983: printf("%8s ", sys_type(p->p_sys));
984: printf("%5u ", sec_to_c(p->p_base));
985: printf("%5u ", sec_to_c(end));
986: printf("%5u ", sec_upto_c(p->p_size));
987: printf("%6lu ", p->p_base / nspt);
988: printf("%6lu ", end / nspt);
989: printf("%6u ", sec_upto_t(p->p_size));
990: printf("%6.2f ", meg(p->p_size));
991: printf("%6lu ", p->p_size);
992: dname = device;
993: if (strncmp(dname, "/tmp", 4) == 0)
994: dname += 4;
995: s = &dname[strlen(dname) - 1];
996: c = *s;
997: *s = 'a' + i;
998: printf("%s", dname);
999: *s = c;
1000: if (vflag) {
1001: printf("\n\t%3u:%u:%u ", bcyl(p), bhd(p), bsec(p));
1002: printf("%3u:%u:%u ", ecyl(p), ehd(p), esec(p));
1003: }
1004: printf("\n");
1005: }
1006: sanity();
1007: printf("\n");
1008: }
1009:
1010: /*
1011: * Done.
1012: * If changes, prompt for confirmation and save.
1013: * Return 1 to quit, 0 to not quit.
1014: */
1015: int
1016: quit(fname) char *fname;
1017: {
1018: if (badflag) {
1019: printf("Because the partition table defines overlapping disk\n");
1020: printf("partitions, it will not be saved to the disk if you quit.\n");
1021: if (!yes_no("Do you wish to quit without saving the changes"))
1022: return 0;
1023: } else if (nmods != 0) {
1024: if (yes_no("\nAre you sure you want to write the updated partition table")) {
1025: if (lseek(cfd, 0L, 0) != 0L)
1026: fatal("seek failed on \"%s\"", fname);
1027: else if (write(cfd, &hd, sizeof hd) != sizeof hd)
1028: fatal("write error on \"%s\"", fname);
1029: /*
1030: * This HDGETA is for the benefit of the SCSI driver,
1031: * which needs to reset the parameters if they changed.
1032: */
1033: if (ioctl(cfd, HDGETA, (char *)&hdparms) == -1)
1034: fprintf(stderr, "HDGETA failed on \"%s\"\n", fname);
1035: sync();
1036: } else if (!yes_no("Changes will not be saved. Quit anyway"))
1037: longjmp(loop, 2);
1038: else
1039: printf("Changes not saved.\n");
1040: } else
1041: printf("The partition table is unchanged.\n");
1042: close(cfd);
1043: return 1;
1044: }
1045:
1046: /*
1047: * Check a partition table for sanity.
1048: * Sort the partitions, look for gaps and overlaps.
1049: */
1050: void
1051: sanity()
1052: {
1053: register int i;
1054: FDISK_S *p[NPARTN];
1055: unsigned long base, next, size, safe;
1056:
1057: badflag = 0;
1058: freepart = -1;
1059: freesize = freestart = 0;
1060: for (i = 0; i < NPARTN; i++) {
1061: p[i] = &hd.hd_partn[i];
1062: if (p[i]->p_size != 0) {
1063: check_chs(p[i], 1); /* check start c:h:s */
1064: check_chs(p[i], 0); /* check end c:h:s */
1065: } else if (freepart == -1)
1066: freepart = i; /* first free partition */
1067: }
1068: qsort(p, NPARTN, sizeof(FDISK_S *), pcompare);
1069: next = 1; /* next block available after boot sector */
1070: for (i = 0; i < NPARTN; i++) {
1071: base = p[i]->p_base;
1072: size = p[i]->p_size;
1073: if (size == 0)
1074: break; /* done when empty reached */
1075: if (base < next) {
1076: if (next == 1)
1077: printf("Partition overlaps boot sector.\n");
1078: else if (cylflag)
1079: printf("Partitions overlap starting at cylinder %lu.\n", base / cylsize);
1080: else
1081: printf("Partitions overlap starting at track %lu.\n", base / nspt);
1082: ++badflag;
1083: } else if (base != next) {
1084: if (i == 0 && (base == nspt || base == cylsize))
1085: ; /* first partition at 0:1:1 or 1:0:1 */
1086: else
1087: unused(base, next);
1088: }
1089: if (base + size > next)
1090: next = base + size;
1091: }
1092: safe = nsectors - nspt * nheads; /* safely usable sectors */
1093: if (next < safe)
1094: unused(safe, next);
1095: else if (next > safe)
1096: printf(
1097: "\n"
1098: "Warning: the last cylinder of a hard disk is usually reserved for use by\n"
1099: "disk diagnostic programs. The current disk partitioning uses part of the\n"
1100: "the last cylinder in a disk partition. Mark Williams strongly recommends\n"
1101: "that you change the partitioning to avoid using the last cylinder.\n"
1102: );
1103: }
1104:
1105: struct nlist nl[2] = {
1106: { "rootdev_", 0, 0 },
1107: { "", 0, 0 }
1108: };
1109:
1110: /*
1111: * Save/restore a copy of boot block to/from floppy.
1112: * Some fuss required to find the name of the root device.
1113: */
1114: void
1115: saveboot()
1116: {
1117: register int fd;
1118: dev_t dev;
1119: char *floppy;
1120:
1121: /* Open kernel memory and read value of rootdev_. */
1122: if ((fd = open(KMEM, 0)) < 0)
1123: return;
1124: nlist(COH, nl);
1125: if (lseek(fd, (long)nl[0].n_value, 0) == -1L)
1126: return;
1127: if (read(fd, &dev, sizeof(dev_t)) != sizeof(dev_t))
1128: return;
1129: close(fd);
1130:
1131: /*
1132: * Bail out if not running floppy-based COHERENT
1133: * or if floppy open fails.
1134: */
1135: if (dev == makedev(FL_MAJOR, 14))
1136: floppy = "/dev/rfha0";
1137: else if (dev == makedev(FL_MAJOR, 15))
1138: floppy = "/dev/rfva0";
1139: else
1140: return; /* not running from floppy */
1141: if ((fd = open(floppy, 2)) == -1)
1142: return; /* open failed, bag out */
1143:
1144: cls(0);
1145: sync();
1146: printf(
1147: "If you are installing COHERENT on your hard disk for the first time and you\n"
1148: "want to use your drive with other operating systems, we recommend that you\n"
1149: "save a copy of the current boot block (which includes the partition table)\n"
1150: "to a diskette. You can restore the original boot block from the diskette\n"
1151: "if your COHERENT installation fails or if you are subsequently unable to run\n"
1152: "another operating system on the drive.\n"
1153: "\n"
1154: "You will be asked about saving and restoring the boot block once for each\n"
1155: "hard drive you are using. Use a separate diskette for each hard drive.\n"
1156: );
1157: if (yes_no("Do you want to save the original boot block")) {
1158: printf(
1159: "\n"
1160: "Remove the COHERENT boot diskette, insert a formatted blank diskette,\n"
1161: );
1162: get_line("then hit <Enter>.");
1163: if (write(fd, &hd, sizeof hd) != sizeof hd)
1164: fprintf(stderr, "fdisk: write error on \"%s\"\n", floppy);
1165: else
1166: printf(
1167: "\n"
1168: "Remove the diskette containing the original boot block.\n"
1169: "Label it and file it with your COHERENT installation disks.\n"
1170: );
1171: } else if (yes_no("Do you want to restore a previously saved boot block")) {
1172: printf(
1173: "\n"
1174: "WARNING: This step will overwrite your hard disk partition table\n"
1175: "with the previously saved copy from the diskette in drive A:.\n"
1176: "Type <Ctrl-C> if you do not want to overwrite the existing partition table.\n"
1177: "\n"
1178: "Remove the COHERENT boot diskette,\n"
1179: "insert the diskette containing the saved boot block,\n"
1180: );
1181: get_line("then hit <Enter>.");
1182: if (read(fd, &hd, sizeof hd) != sizeof hd)
1183: fprintf(stderr, "fdisk: read error on \"%s\"\n", floppy);
1184: else if (lseek(cfd, 0L, 0) != 0L)
1185: fatal("seek failed on \"%s\"", device);
1186: else if (write(cfd, &hd, sizeof hd) != sizeof hd)
1187: fatal("write error on \"%s\"", device);
1188: } else {
1189: close(fd);
1190: return;
1191: }
1192: close(fd);
1193: sync();
1194: get_line("\nReplace the COHERENT boot diskette, then hit <Enter>.");
1195: }
1196:
1197: /*
1198: * Execute a command.
1199: */
1200: void
1201: sys(cmd) char *cmd;
1202: {
1203: if (system(cmd) != 0)
1204: fatal("command \"%s\" failed", cmd);
1205: }
1206:
1207: /*
1208: * Convert system type code i to a string describing the system type.
1209: * Return a pointer to statically allocated buffer.
1210: */
1211: char *
1212: sys_type(i) register int i;
1213: {
1214: static char buf[8+1]; /* longest name is "COHERENT" or "<Unused>"XS */
1215: register char *s;
1216:
1217: switch (i) {
1218: case SYS_EMPTY: s = "<Unused>"; break;
1219: case SYS_DOS_12:
1220: case SYS_DOS_16:
1221: case SYS_DOS_LARGE:
1222: s = "MS-DOS"; break;
1223: case SYS_DOS_XP:
1224: s = "Ext.DOS"; break;
1225: case SYS_XENIX: s = "Xenix"; break;
1226: case SYS_COH: s = "Coherent"; break;
1227: case SYS_SWAP: s = "Swap"; break;
1228: default: s = NULL; break;
1229: }
1230:
1231: if (s == NULL)
1232: sprintf(buf, "%8u ", i);
1233: else
1234: strcpy(buf, s);
1235: return buf;
1236: }
1237:
1238: /*
1239: * Report unused portion of disk.
1240: */
1241: void
1242: unused(base, next) unsigned long base, next;
1243: {
1244: register unsigned long n, x, y;
1245: register char *s;
1246:
1247: n = base - next;
1248: if (cylflag && n >= cylsize) {
1249: s = "cylinder";
1250: x = sec_to_c(n);
1251: y = sec_upto_c(next);
1252: } else if (n >= nspt) {
1253: s = "track";
1254: x = n / nspt;
1255: y = sec_upto_t(next);
1256: } else {
1257: s = "sector";
1258: x = n;
1259: y = next;
1260: }
1261: if (x == 1)
1262: printf("%lu %s (%.2f megabytes) is unused starting at %s %lu.\n",
1263: x, s, meg(n), s, y);
1264: else
1265: printf("%lu %ss (%.2f megabytes) are unused starting at %s %lu.\n",
1266: x, s, meg(n), s, y);
1267: if (freesize < n) {
1268: freesize = n;
1269: freestart = next;
1270: }
1271: }
1272:
1273: /*
1274: * Print a usage message and die.
1275: */
1276: void
1277: usage()
1278: {
1279: fprintf(stderr, USAGE);
1280: exit(1);
1281: }
1282:
1283: /*
1284: * Get the answer to a yes/no question.
1285: * Return 1 for yes, 0 for no.
1286: */
1287: int
1288: yes_no(args) char *args;
1289: {
1290: register char *s;
1291:
1292: for (;;) {
1293: printf("%r", &args);
1294: s = get_line(" [y or n]?");
1295: if (*s == 'y')
1296: return 1;
1297: else if (*s == 'n')
1298: return 0;
1299: }
1300: }
1301:
1302: /* end of fdisk.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.