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