?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove building with NOCRYPTO option
[minix3.git] / minix / commands / fdisk / fdisk.c
blobc75d2b3585e8be862c4f5bfa935897f37dfcb3b2
1 /* fdisk - partition a hard disk Author: Jakob Schripsema */
2
3 /* Run this with:
4 *
5 * fdisk [-hheads] [-ssectors] [device]
6 *
7 * e.g.,
8 *
9 * fdisk (to get the default)
10 * fdisk -h4 -s17 /dev/hd0 (MINIX default)
11 * fdisk -h4 -s17 c: (DOS default)
12 * fdisk -h6 -s25 /dev/hd5 (second drive, probably RLL)
13 * fdisk junkfile (to experiment safely)
14 *
15 * The device is opened in read-only mode if the file permissions do not
16 * permit read-write mode, so it is convenient to use a login account with
17 * only read permission to look at the partition table safely.
18 *
19 * Compile with:
20 *
21 * cc -i -o fdisk fdisk.c (MINIX)
22 * cl -DDOS fdisk.c (DOS with MS C compiler)
23 *
24 * This was modified extensively by Bruce Evans 28 Dec 89.
25 * The new version has not been tried with DOS. The open modes are suspect
26 * (everyone should convert to use fcntl.h).
27 *
28 * Changed 18 Dec 92 by Kees J. Bot: Bootstrap code and geometry from device.
29 *
30 * modified 01 March 95 by asw: updated list of known partition types. Also
31 * changed display format slightly to allow for partition type names of
32 * up to 9 chars (previous format allowed for 7, but there were already
33 * some 8 char names in the list).
34 */
35
36 #include <sys/types.h>
37 #include <machine/partition.h>
38 #include <minix/partition.h>
39 #include <sys/ioctl.h>
40 #include <sys/stat.h>
41 #include <fcntl.h>
42 #include <string.h>
43 #include <stdlib.h>
44 #include <unistd.h>
45 #include <stdio.h>
46 #include <errno.h>
47
48 #ifdef DOS
49 #include <dos.h>
50 #define DEFAULT_DEV "c:"
51 #define LOAD_OPEN_MODE 0x8000
52 #define SAVE_CREAT_MODE 0644
53 #else
54 #define DEFAULT_DEV "/dev/hd0"
55 #define LOAD_OPEN_MODE 0
56 #define SAVE_CREAT_MODE 0644
57 #define UNIX /* for MINIX */
58 #endif
59
60 /* Constants */
61
62 #define DEFAULT_NHEAD 4 /* # heads */
63 #define DEFAULT_NSEC 17 /* sectors / track */
64 #define SECSIZE 512 /* sector size */
65 #define OK 0
66 #define ERR 1
67
68 #define CYL_MASK 0xc0 /* mask to extract cyl bits from sec field */
69 #define CYL_SHIFT 2 /* shift to extract cyl bits from sec field */
70 #define SEC_MASK 0x3f /* mask to extract sec bits from sec field */
71
72 /* Globals */
73 char rawsecbuf[SECSIZE + sizeof(long)];
74 char *secbuf;
75 int badbases;
76 int badsizes;
77 int badorders;
78 char *dev_name;
79 int nhead;
80 int nsec;
81 int ncyl = 1024;
82 int readonly;
83 int override= 0;
84
85 int main(int argc, char *argv []);
86 void getgeom(void);
87 void getboot(char *buffer);
88 void putboot(char *buffer);
89 void load_from_file(void);
90 void save_to_file(void);
91 void dpl_partitions(int rawflag);
92 int chk_table(void);
93 void sec_to_hst(long logsec, unsigned char *hd, unsigned char *sec,
94 unsigned char *cyl);
95 void mark_partition(struct part_entry *pe);
96 void change_partition(struct part_entry *entry);
97 char get_a_char(void);
98 void print_menu(void);
99 void adj_base(struct part_entry *pe);
100 void adj_size(struct part_entry *pe);
101 struct part_entry *ask_partition(void);
102 void footnotes(void);
103 int get_an_int(char *prompt, int *intptr);
104 void list_part_types(void);
105 void mark_npartition(struct part_entry *pe);
106 int mygets(char *buf, int length);
107 char *systype(int type);
108 void toggle_active(struct part_entry *pe);
109 void usage(void);
110
111 /* One featureful master bootstrap. */
112 char bootstrap[] = {
113 0353,0001,0000,0061,0300,0216,0330,0216,0300,0372,0216,0320,0274,0000,0174,0373,
114 0275,0276,0007,0211,0346,0126,0277,0000,0006,0271,0000,0001,0374,0363,0245,0352,
115 0044,0006,0000,0000,0264,0002,0315,0026,0250,0010,0164,0033,0350,0071,0001,0174,
116 0007,0060,0344,0315,0026,0242,0205,0007,0054,0060,0074,0012,0163,0363,0120,0350,
117 0046,0001,0205,0007,0130,0353,0012,0240,0002,0006,0204,0300,0165,0003,0351,0147,
118 0000,0230,0262,0005,0366,0362,0262,0200,0000,0302,0210,0340,0120,0350,0234,0000,
119 0163,0003,0351,0147,0000,0130,0054,0001,0175,0003,0351,0141,0000,0276,0276,0175,
120 0211,0357,0271,0040,0000,0363,0245,0200,0301,0004,0211,0356,0215,0174,0020,0070,
121 0154,0004,0164,0016,0213,0135,0010,0053,0134,0010,0213,0135,0012,0033,0134,0012,
122 0163,0014,0212,0044,0206,0144,0020,0210,0044,0106,0071,0376,0162,0364,0211,0376,
123 0201,0376,0356,0007,0162,0326,0342,0322,0211,0356,0264,0020,0366,0344,0001,0306,
124 0200,0174,0004,0001,0162,0026,0353,0021,0204,0322,0175,0041,0211,0356,0200,0174,
125 0004,0000,0164,0013,0366,0004,0200,0164,0006,0350,0070,0000,0162,0053,0303,0203,
126 0306,0020,0201,0376,0376,0007,0162,0346,0350,0215,0000,0211,0007,0376,0302,0204,
127 0322,0174,0023,0315,0021,0321,0340,0321,0340,0200,0344,0003,0070,0342,0167,0355,
128 0350,0011,0000,0162,0350,0303,0350,0003,0000,0162,0146,0303,0211,0356,0214,0134,
129 0010,0214,0134,0012,0277,0003,0000,0122,0006,0127,0264,0010,0315,0023,0137,0007,
130 0200,0341,0077,0376,0306,0210,0310,0366,0346,0211,0303,0213,0104,0010,0213,0124,
131 0012,0367,0363,0222,0210,0325,0366,0361,0060,0322,0321,0352,0321,0352,0010,0342,
132 0210,0321,0376,0301,0132,0210,0306,0273,0000,0174,0270,0001,0002,0315,0023,0163,
133 0020,0200,0374,0200,0164,0011,0117,0174,0006,0060,0344,0315,0023,0163,0270,0371,
134 0303,0201,0076,0376,0175,0125,0252,0165,0001,0303,0350,0013,0000,0243,0007,0353,
135 0005,0350,0004,0000,0227,0007,0353,0376,0136,0255,0126,0211,0306,0254,0204,0300,
136 0164,0011,0264,0016,0273,0001,0000,0315,0020,0353,0362,0303,0057,0144,0145,0166,
137 0057,0150,0144,0077,0010,0000,0015,0012,0000,0116,0157,0156,0145,0040,0141,0143,
138 0164,0151,0166,0145,0015,0012,0000,0122,0145,0141,0144,0040,0145,0162,0162,0157,
139 0162,0040,0000,0116,0157,0164,0040,0142,0157,0157,0164,0141,0142,0154,0145,0040,
140 0000,0000,
141 };
142
143 int main(int argc, char *argv[])
144 {
145 int argn;
146 char *argp;
147 int ch;
148
149 /* Init */
150
151 nhead = DEFAULT_NHEAD;
152 nsec = DEFAULT_NSEC;
153 for (argn = 1; argn < argc && (argp = argv[argn])[0] == '-'; ++argn) {
154 if (argp[1] == 'h')
155 nhead = atoi(argp + 2);
156 else
157 if (argp[1] == 's') nsec = atoi(argp + 2);
158 else
159 usage();
160 override= 1;
161 }
162
163 if (argn == argc)
164 dev_name = DEFAULT_DEV;
165 else if (argn == argc - 1)
166 dev_name = argv[argn];
167 else
168 usage();
169
170 /* Align the sector buffer in such a way that the partition table is at
171 * a mod 4 offset in memory. Some weird people add alignment checks to
172 * their Minix!
173 */
174 secbuf = rawsecbuf;
175 while ((long)(secbuf + PART_TABLE_OFF) % sizeof(long) != 0) secbuf++;
176
177 getgeom();
178 getboot(secbuf);
179 chk_table();
180
181 do {
182 putchar('\n');
183 dpl_partitions(0);
184 printf(
185 "\n(Enter 'h' for help. A null line will abort any operation) ");
186 ch = get_a_char();
187 putchar('\n');
188 switch (ch) {
189 case '+': footnotes(); break;
190 case 'a': toggle_active(ask_partition()); break;
191 case 'B': adj_base(ask_partition()); break;
192 case 'c': change_partition(ask_partition()); break;
193 case 'h': print_menu(); break;
194 case 'l': load_from_file(); break;
195 case 'm': mark_partition(ask_partition()); break;
196 case 'n': mark_npartition(ask_partition()); break;
197 case 'p': dpl_partitions(1); break;
198 case 0:
199 case 'q': exit(0);
200 case 'S': adj_size(ask_partition()); break;
201 case 's': save_to_file(); break;
202 case 't': list_part_types(); break;
203 case 'v':
204 printf("Partition table is %svalid\n",
205 chk_table() == OK ? "" : "in");
206 break;
207 case 'w':
208 if (readonly)
209 printf("Write disabled\n");
210 else if(chk_table() == OK) {
211 putboot(secbuf);
212 printf(
213 "Partition table has been updated and the file system synced.\n");
214 printf("Please reboot now.\n");
215 exit(0);
216 } else
217 printf("Not written\n");
218 break;
219 default: printf(" %c ????\n", ch); break;
220 }
221 }
222 while (1);
223 }
224
225
226 #ifdef UNIX
227
228 void getgeom(void)
229 {
230 struct part_geom geom;
231 int fd, r;
232
233 if (override) return;
234
235 if ((fd= open(dev_name, O_RDONLY)) < 0) return;
236
237 r = ioctl(fd, DIOCGETP, &geom);
238 close(fd);
239 if (r < 0) return;
240
241 nhead = geom.heads;
242 nsec = geom.sectors;
243 ncyl = geom.cylinders;
244
245 printf("Geometry of %s: %dx%dx%d\n", dev_name, ncyl, nhead, nsec);
246 }
247
248 static int devfd;
249
250 void getboot(char *buffer)
251 {
252 devfd = open(dev_name, 2);
253 if (devfd < 0) {
254 printf("No write permission on %s\n", dev_name);
255 readonly = 1;
256 devfd = open(dev_name, 0);
257 }
258 if (devfd < 0) {
259 printf("Cannot open device %s\n", dev_name);
260 exit(1);
261 }
262 if (read(devfd, buffer, SECSIZE) != SECSIZE) {
263 printf("Cannot read boot sector\n");
264 exit(1);
265 }
266 if (* (unsigned short *) &buffer[510] != 0xAA55) {
267 printf("Invalid boot sector on %s.\n", dev_name);
268 printf("Partition table reset and boot code installed.\n");
269 memset(buffer, 0, 512);
270 memcpy(buffer, bootstrap, sizeof(bootstrap));
271 * (unsigned short *) &buffer[510] = 0xAA55;
272 }
273 }
274
275 void putboot(char *buffer)
276 {
277 if (lseek(devfd, 0L, 0) < 0) {
278 printf("Seek error during write\n");
279 exit(1);
280 }
281 if (write(devfd, buffer, SECSIZE) != SECSIZE) {
282 printf("Write error\n");
283 exit(1);
284 }
285 sync();
286 }
287
288 #endif
289
290
291 void load_from_file(void)
292 {
293 /* Load buffer from file */
294
295 char file[80];
296 int fd;
297
298 printf("Enter name of file to load from: ");
299 if (!mygets(file, (int) sizeof file)) return;
300 fd = open(file, LOAD_OPEN_MODE);
301 if (fd < 0) {
302 printf("Cannot open %s\n", file);
303 return;
304 }
305 if (read(fd, secbuf, SECSIZE) != SECSIZE || close(fd) != 0) {
306 printf("Read error\n");
307 exit(1);
308 }
309 printf("Loaded from %s OK\n", file);
310 chk_table();
311 }
312
313
314 void save_to_file(void)
315 {
316 /* Save to file */
317
318 char file[80];
319 int fd;
320
321 printf("Enter name of file to save to: ");
322 if (!mygets(file, (int) sizeof file)) return;
323 if(chk_table() != OK) printf("Saving anyway\n");
324 fd = creat(file, SAVE_CREAT_MODE);
325 #ifdef DOS
326 if (fd < 0) {
327 printf("Cannot creat %s\n", file);
328 return;
329 }
330 close(fd);
331 fd = open(file, 0x8001);
332 #endif
333 if (fd < 0)
334 printf("Cannot open %s\n", file);
335 else if (write(fd, secbuf, SECSIZE) != SECSIZE || close(fd) != 0)
336 printf("Write error\n");
337 else
338 printf("Saved to %s OK\n", file);
339 }
340
341
342 void dpl_partitions(int rawflag)
343 {
344 /* Display partition table */
345
346 char active[5];
347 char basefootnote;
348 int cyl_mask;
349 int devnum;
350 char *format;
351 int i;
352 int i1;
353 char orderfootnote;
354 struct part_entry *pe;
355 struct part_entry *pe1;
356 int sec_mask;
357 char sizefootnote;
358 char type[10];
359
360 badbases = 0;
361 badsizes = 0;
362 badorders = 0;
363 if (rawflag) {
364 cyl_mask = 0; /* no contribution of cyl to sec */
365 sec_mask = 0xff;
366 format =
367 "%2d %3d%c %4s %-9s x%02x %3d x%02x x%02x %3d x%02x %7ld%c%7ld %7ld%c\n";
368 } else {
369 cyl_mask = CYL_MASK;
370 sec_mask = SEC_MASK;
371 format =
372 "%2d %3d%c %4s %-9s %4d %3d %3d %4d %3d %3d %7ld%c%7ld %7ld%c\n";
373 }
374 printf(
375 " ----first---- -----last---- --------sectors-------\n"
376 );
377 printf(
378 "Num Sorted Act Type Cyl Head Sec Cyl Head Sec Base Last Size\n"
379 );
380 pe = (struct part_entry *) &secbuf[PART_TABLE_OFF];
381 for (i = 1; i <= NR_PARTITIONS; i++, pe++) {
382 if (rawflag) {
383 sprintf(active, "0x%02x", pe->bootind);
384 sprintf(type, "0x%02x", pe->sysind);
385 } else {
386 sprintf(active, "%s", pe->bootind == ACTIVE_FLAG ? "A " : "");
387 sprintf(type, "%s", systype(pe->sysind));
388 }
389
390 /* Prepare warnings about confusing setups from old versions. */
391 basefootnote = orderfootnote = sizefootnote = ' ';
392 if (pe->sysind == MINIX_PART && pe->lowsec & 1) {
393 basefootnote = '+';
394 ++badbases;
395 }
396 if (pe->size & 1) {
397 sizefootnote = '-';
398 ++badsizes;
399 }
400
401 /* Calculate the "device numbers" resulting from the misguided sorting
402 * in the wini drivers. The drivers use this conditional for
403 * swapping wn[j] > wn[j+1]:
404 *
405 * if ((wn[j].wn_low == 0 && wn[j+1].wn_low != 0) ||
406 * (wn[j].wn_low > wn[j+1].wn_low && wn[j+1].wn_low != 0)) {
407 *
408 * which simplifies to:
409 *
410 * if (wn[j+1].wn_low != 0 &&
411 * (wn[j].wn_low == 0 || wn[j].wn_low > wn[j+1].wn_low)) {
412 */
413 devnum = 1;
414 for (i1 = 1, pe1 = (struct part_entry *) &secbuf[PART_TABLE_OFF];
415 i1 <= NR_PARTITIONS; ++i1, ++pe1)
416 if ((pe1->lowsec == 0 && pe->lowsec == 0 && pe1 < pe) ||
417 (pe1->lowsec != 0 &&
418 (pe->lowsec == 0 || pe->lowsec > pe1->lowsec)))
419 ++devnum; /* pe1 contents < pe contents */
420 if (devnum != i) {
421 orderfootnote = '#';
422 ++badorders;
423 }
424
425 printf(format,
426 i,
427 devnum,
428 orderfootnote,
429 active,
430 type,
431 pe->start_cyl + ((pe->start_sec & cyl_mask) << CYL_SHIFT),
432 pe->start_head,
433 pe->start_sec & sec_mask,
434 pe->last_cyl + ((pe->last_sec & cyl_mask) << CYL_SHIFT),
435 pe->last_head,
436 pe->last_sec & sec_mask,
437 pe->lowsec,
438 basefootnote,
439 pe->lowsec + (pe->size == 0 ? 0 : pe->size - 1),
440 pe->size,
441 sizefootnote);
442 }
443 }
444
445
446 int chk_table(void)
447 {
448 /* Check partition table */
449
450 int active;
451 unsigned char cylinder;
452 unsigned char head;
453 int i;
454 int i1;
455 int maxhead;
456 int maxsec;
457 struct part_entry *pe;
458 struct part_entry *pe1;
459 unsigned char sector;
460 int seenpart;
461 int status;
462
463 active = 0;
464 maxhead = 0;
465 maxsec = 0;
466 pe = (struct part_entry *) &secbuf[PART_TABLE_OFF];
467 seenpart = 0;
468 status = OK;
469 for (i = 1; i <= NR_PARTITIONS; i++, ++pe) {
470 if (pe->bootind == ACTIVE_FLAG) active++;
471 sec_to_hst(pe->lowsec, &head, &sector, &cylinder);
472 if (pe->size == 0 && pe->lowsec == 0) sector = 0;
473 if (head != pe->start_head || sector != pe->start_sec ||
474 cylinder != pe->start_cyl) {
475 printf("Inconsistent base in partition %d.\n", i);
476 printf("Suspect head and sector parameters.\n");
477 status = ERR;
478 }
479 if (pe->size != 0 || pe->lowsec != 0)
480 sec_to_hst(pe->lowsec + pe->size - 1, &head, &sector, &cylinder);
481 if (head != pe->last_head || sector != pe->last_sec ||
482 cylinder != pe->last_cyl) {
483 printf("Inconsistent size in partition %d.\n", i);
484 printf("Suspect head and sector parameters.\n");
485 status = ERR;
486 }
487 if (pe->size == 0) continue;
488 seenpart = 1;
489 for (i1 = i + 1, pe1 = pe + 1; i1 <= NR_PARTITIONS; ++i1, ++pe1) {
490 if ((pe->lowsec >= pe1->lowsec &&
491 pe->lowsec < pe1->lowsec + pe1->size) ||
492 (pe->lowsec + pe->size - 1 >= pe1->lowsec &&
493 pe->lowsec + pe->size - 1 < pe1->lowsec + pe1->size))
494 {
495 printf("Overlap between partitions %d and %d\n",
496 i, i1);
497 status = ERR;
498 }
499 }
500 if (pe->lowsec + pe->size < pe->lowsec) {
501 printf("Overflow from preposterous size in partition %d.\n",
502 i);
503 status = ERR;
504 }
505 if (maxhead < pe->start_head) maxhead = pe->start_head;
506 if (maxhead < pe->last_head) maxhead = pe->last_head;
507 if (maxsec < (pe->start_sec & SEC_MASK))
508 maxsec = (pe->start_sec & SEC_MASK);
509 if (maxsec < (pe->last_sec & SEC_MASK))
510 maxsec = (pe->last_sec & SEC_MASK);
511 }
512 if (seenpart) {
513 if (maxhead + 1 != nhead || maxsec != nsec) {
514 printf(
515 "Disk appears to have mis-specified number of heads or sectors.\n");
516 printf("Try fdisk -h%d -s%d %s instead of\n",
517 maxhead + 1, maxsec, dev_name);
518 printf(" fdisk -h%d -s%d %s\n", nhead, nsec, dev_name);
519 seenpart = 0;
520 }
521 } else {
522 printf(
523 "Empty table - skipping test on number of heads and sectors.\n");
524 printf("Assuming %d heads and %d sectors.\n", nhead, nsec);
525 }
526 if (!seenpart) printf("Do not write the table if you are not sure!.\n");
527 if (active > 1) {
528 printf("%d active partitions\n", active);
529 status = ERR;
530 }
531 return(status);
532 }
533
534 void sec_to_hst(long logsec, unsigned char *hd, unsigned char *sec,
535 unsigned char *cyl)
536 {
537 /* Convert a logical sector number to head / sector / cylinder */
538
539 int bigcyl;
540
541 bigcyl = logsec / (nhead * nsec);
542 *sec = (logsec % nsec) + 1 + ((bigcyl >> CYL_SHIFT) & CYL_MASK);
543 *cyl = bigcyl;
544 *hd = (logsec % (nhead * nsec)) / nsec;
545 }
546
547 void mark_partition(struct part_entry *pe)
548 {
549 /* Mark a partition as being of type MINIX. */
550
551 if (pe != NULL) {
552 pe->sysind = MINIX_PART;
553 printf("Partition type is now MINIX\n");
554 }
555 }
556
557 void change_partition(struct part_entry *entry)
558 {
559 /* Get partition info : first & last cylinder */
560
561 int first, last;
562 long low, high;
563 int ch;
564
565 if (entry == NULL) return;
566 while (1) {
567 if (!get_an_int("\tEnter first cylinder (an integer >= 0): ", &first))
568 return;
569 if (first >= 0) break;
570 printf("\t\tThat looks like %d which is negative\n", first);
571 }
572 while (1) {
573 if (!get_an_int(
574 "\tEnter last cylinder (an integer >= the first cylinder): ", &last))
575 return;
576 if (last >= first) break;
577 printf("\t\tThat looks like %d which is too small\n", last);
578 }
579 if (first == 0 && last == 0) {
580 entry->bootind = 0;
581 entry->start_head = 0;
582 entry->start_sec = 0;
583 entry->start_cyl = 0;
584 entry->sysind = NO_PART;
585 entry->last_head = 0;
586 entry->last_sec = 0;
587 entry->last_cyl = 0;
588 entry->lowsec = 0;
589 entry->size = 0;
590 printf("Partition deleted\n");
591 return;
592 }
593 low = first & 0xffff;
594 low = low * nsec * nhead;
595 if (low == 0) low = 1; /* sec0 is master boot record */
596 high = last & 0xffff;
597 high = (high + 1) * nsec * nhead - 1;
598 entry->lowsec = low;
599 entry->size = high - low + 1;
600 if (entry->size & 1) {
601 /* Adjust size to even since Minix works with blocks of 2 sectors. */
602 --high;
603 --entry->size;
604 printf("Size reduced by 1 to make it even\n");
605 }
606 sec_to_hst(low, &entry->start_head, &entry->start_sec, &entry->start_cyl);
607 sec_to_hst(high, &entry->last_head, &entry->last_sec, &entry->last_cyl);
608 printf("Base of partition changed to %u, size changed to %u\n",
609 entry->lowsec, entry->size);
610
611 /* Accept the MINIX partition type. Usually ignore foreign types, so this
612 * fdisk can be used on foreign partitions. Don't allow NO_PART, because
613 * many DOS fdisks crash on it.
614 */
615 if (entry->sysind == NO_PART) {
616 entry->sysind = MINIX_PART;
617 printf("Partition type changed from None to MINIX\n");
618 } else if (entry->sysind == MINIX_PART)
619 printf("Leaving partition type as MINIX\n");
620 else while (1) {
621 printf("\tChange partition type from %s to MINIX? (y/n) ",
622 systype(entry->sysind));
623 ch = get_a_char();
624 if (ch == 0 || ch == 'n') {
625 printf("Leaving partition type as %s\n",
626 systype(entry->sysind));
627 break;
628 } else if (ch == 'y') {
629 entry->sysind = MINIX_PART;
630 printf("Partition type changed from %s to MINIX\n",
631 systype(entry->sysind));
632 break;
633 }
634 }
635
636 if (entry->bootind == ACTIVE_FLAG)
637 printf("Leaving partition active\n");
638 else while (1) {
639 printf("\tChange partition to active? (y/n) ");
640 ch = get_a_char();
641 if (ch == 0 || ch == 'n') {
642 printf("Leaving partition inactive\n");
643 break;
644 } else if (ch == 'y') {
645 toggle_active(entry);
646 break;
647 }
648 }
649 }
650
651 char get_a_char(void)
652 {
653 /* Read 1 character and discard rest of line */
654
655 char buf[80];
656
657 if (!mygets(buf, (int) sizeof buf)) return(0);
658 return(*buf);
659 }
660
661 void print_menu(void)
662 {
663 printf("Type a command letter, then a carriage return:\n");
664 printf(" + - explain any footnotes (+, -, #)\n");
665 printf(" a - toggle an active flag\n");
666 printf(" B - adjust a base sector\n");
667 printf(" c - change a partition\n");
668 printf(" l - load boot block (including partition table) from a file\n");
669 printf(" m - mark a partition as a MINIX partition\n");
670 printf(" n - mark a partition as a non-MINIX partition\n");
671 printf(" p - print raw partition table\n");
672 printf(" q - quit without making any changes\n");
673 printf(" S - adjust a size (by changing the last sector)\n");
674 printf(" s - save boot block (including partition table) on a file\n");
675 printf(" t - print known partition types\n");
676 printf(" v - verify partition table\n");
677 if (readonly)
678 printf(" w - write (disabled)\n");
679 else
680 printf(" w - write changed partition table back to disk and exit\n");
681 }
682
683
684 /* Here are the DOS routines for reading and writing the boot sector. */
685
686 #ifdef DOS
687
688 union REGS regs;
689 struct SREGS sregs;
690 int drivenum;
691
692 void getboot(char *buffer)
693 {
694 /* Read boot sector */
695
696 segread(&sregs); /* get ds */
697
698 if (dev_name[1] != ':') {
699 printf("Invalid drive %s\n", dev_name);
700 exit(1);
701 }
702 if (*dev_name >= 'a') *dev_name += 'A' - 'a';
703 drivenum = (*dev_name - 'C') & 0xff;
704 if (drivenum < 0 || drivenum > 7) {
705 printf("Funny drive number %d\n", drivenum);
706 exit(1);
707 }
708 regs.x.ax = 0x201; /* read 1 sectors */
709 regs.h.ch = 0; /* cylinder */
710 regs.h.cl = 1; /* first sector = 1 */
711 regs.h.dh = 0; /* head = 0 */
712 regs.h.dl = 0x80 + drivenum; /* drive = 0 */
713 sregs.es = sregs.ds; /* buffer address */
714 regs.x.bx = (int) buffer;
715
716 int86x(0x13, &regs, &regs, &sregs);
717 if (regs.x.cflag) {
718 printf("Cannot read boot sector\n");
719 exit(1);
720 }
721 }
722
723
724 void putboot(char *buffer)
725 {
726 /* Write boot sector */
727
728 regs.x.ax = 0x301; /* read 1 sectors */
729 regs.h.ch = 0; /* cylinder */
730 regs.h.cl = 1; /* first sector = 1 */
731 regs.h.dh = 0; /* head = 0 */
732 regs.h.dl = 0x80 + drivenum; /* drive = 0 */
733 sregs.es = sregs.ds; /* buffer address */
734 regs.x.bx = (int) buffer;
735
736 int86x(0x13, &regs, &regs, &sregs);
737 if (regs.x.cflag) {
738 printf("Cannot write boot sector\n");
739 exit(1);
740 }
741 }
742
743 #endif
744
745 void adj_base(struct part_entry *pe)
746 {
747 /* Adjust base sector of partition, usually to make it even. */
748
749 int adj;
750
751 if (pe == NULL) return;
752 while (1) {
753
754 if (!get_an_int("\tEnter adjustment to base (an integer): ", &adj))
755 return;
756 if (pe->lowsec + adj < 1)
757 printf(
758 "\t\tThat would make the base %u and too small\n", pe->lowsec + adj);
759 else if (pe->size - adj < 1)
760 printf(
761 "\t\tThat would make the size %u and too small\n", pe->size - adj);
762 else
763 break;
764 }
765 pe->lowsec += adj;
766 pe->size -= adj;
767 sec_to_hst(pe->lowsec, &pe->start_head, &pe->start_sec, &pe->start_cyl);
768 printf("Base of partition adjusted to %u, size adjusted to %u\n",
769 pe->lowsec, pe->size);
770 }
771
772 void adj_size(struct part_entry *pe)
773 {
774 /* Adjust size of partition by reducing high sector. */
775
776 int adj;
777
778 if (pe == NULL) return;
779 while (1) {
780 if (!get_an_int("\tEnter adjustment to size (an integer): ", &adj))
781 return;
782 if (pe->size + adj >= 1) break;
783 printf("\t\tThat would make the size %u and too small \n",
784 pe->size + adj);
785 }
786 pe->size += adj;
787 sec_to_hst(pe->lowsec + pe->size - 1,
788 &pe->last_head, &pe->last_sec, &pe->last_cyl);
789 printf("Size of partition adjusted to %u\n", pe->size);
790 }
791
792 struct part_entry *ask_partition()
793 {
794 /* Ask for a valid partition number and return its entry. */
795
796 int num;
797
798 while (1) {
799
800 if (!get_an_int("Enter partition number (1 to 4): ", &num))
801 return(NULL);
802 if (num >= 1 && num <= NR_PARTITIONS) break;
803 printf("\tThat does not look like 1 to 4\n");
804 }
805 printf("Partition %d\n", num);
806 return((struct part_entry *) &secbuf[PART_TABLE_OFF] + (num - 1));
807 }
808
809 void footnotes(void)
810 {
811 /* Explain the footnotes. */
812
813 if (badbases != 0) {
814 printf(
815 "+ The old Minix wini drivers (before V1.5) discarded odd base sectors.\n");
816 printf(
817 " This causes some old (Minix) file systems to be offset by 1 sector.\n");
818 printf(
819 " To use these with the new drivers, increase the base by 1 using 'B'.\n");
820 }
821
822 if (badsizes != 0) {
823 if (badbases != 0) putchar('\n');
824 printf(
825 "- Minix cannot access the last sector on an odd-sized partition. This\n");
826 printf(
827 " causes trouble for programs like dosread. This program will by default\n");
828 printf(
829 " only create partitions with even sizes. If possible, the current odd\n");
830 printf(
831 " sizes should be decreased by 1 using 'S'. This is safe for all Minix\n");
832 printf(
833 " partitions, and may be safe for other partitions which are about to be\n");
834 printf(
835 " reformatted.\n");
836 }
837
838 if (badorders!= 0 ) {
839 if (badbases != 0 || badsizes != 0) putchar('\n');
840 printf(
841 "# The partitions are in a funny order. This is normal if they were created\n");
842 printf(
843 " by DOS fdisks prior to DOS 3.3. The Minix wini drivers further confuse\n");
844 printf(
845 " the order by sorting the partitions on their base. Be careful if the\n");
846 printf(
847 " device numbers of unchanged partitions have changed.\n");
848 }
849 }
850
851 int get_an_int(char *prompt, int *intptr)
852 {
853 /* Read an int from the start of line of stdin, discard rest of line. */
854
855 char buf[80];
856
857 while (1) {
858 printf("%s", prompt);
859 if (!mygets(buf, (int) sizeof buf)) return(0);
860 if ((sscanf(buf, "%d", intptr)) == 1) return(1);
861 printf("\t\tThat does not look like an integer\n");
862 }
863 }
864
865 void list_part_types(void)
866 {
867 /* Print all known partition types. */
868
869 int column;
870 int type;
871
872 for (column = 0, type = 0; type < 0x100; ++type)
873 if (strcmp(systype(type), "Unknown") != 0) {
874 printf("0x%02x: %-9s", type, systype(type));
875 column += 16;
876 if (column < 80)
877 putchar(' ');
878 else {
879 putchar('\n');
880 column = 0;
881 }
882 }
883 if (column != 0) putchar('\n');
884 }
885
886 void mark_npartition(struct part_entry *pe)
887 {
888 /* Mark a partition with arbitrary type. */
889
890 char buf[80];
891 unsigned type;
892
893 if (pe == NULL) return;
894 printf("\nKnown partition types are:\n\n");
895 list_part_types();
896 while (1) {
897 printf("\nEnter partition type (in 2-digit hex): ");
898 if (!mygets(buf, (int) sizeof buf)) return;
899 if (sscanf(buf, "%x", &type) != 1)
900 printf("Invalid hex number\n");
901 else if (type >= 0x100)
902 printf("Hex number too large\n");
903 else
904 break;
905 }
906 pe->sysind = type;
907 printf("Partition type changed to 0x%02x (%s)\n", type, systype(type));
908 }
909
910 int mygets(char *buf, int length)
911 {
912 /* Get a non-empty line of maximum length 'length'. */
913
914 while (1) {
915 fflush(stdout);
916 if (fgets(buf, length, stdin) == NULL) {
917 putchar('\n');
918 return(0);
919 }
920 if (strrchr(buf, '\n') != NULL) *strrchr(buf, '\n') = 0;
921 if (*buf != 0) return(1);
922 printf("Use the EOF character to create a null line.\n");
923 printf("Otherwise, please type something before the newline: ");
924 }
925 }
926
927 char *systype(int type)
928 {
929 /* Convert system indicator into system name. */
930 /* asw 01.03.95: added types based on info in kjb's part.c and output
931 * from Linux (1.0.8) fdisk. Note comments here, there are disagreements.
932 */
933 switch(type) {
934 case NO_PART:
935 return("None");
936 case 1: return("DOS-12");
937 case 2: return("XENIX");
938 case 3: return("XENIX usr");
939 case 4: return("DOS-16");
940 case 5: return("DOS-EXT");
941 case 6: return("DOS-BIG");
942 case 7: return("HPFS");
943 case 8: return("AIX");
944 case 9: return("COHERENT"); /* LINUX says AIX bootable */
945 case 0x0a: return("OS/2"); /* LINUX says OPUS */
946 case 0x10: return("OPUS");
947 case 0x40: return("VENIX286");
948 case 0x51: return("NOVELL?");
949 case 0x52: return("MICROPORT");
950 case 0x63: return("386/IX"); /*LINUX calls this GNU HURD */
951 case 0x64: return("NOVELL286");
952 case 0x65: return("NOVELL386");
953 case 0x75: return("PC/IX");
954 case 0x80: return("MINIX old");
955 case 0x81: return("MINIX");
956 case 0x82: return("LINUXswap");
957 case 0x83: return("LINUX");
958 case 0x93: return("AMOEBA");
959 case 0x94: return("AMOEBAbad");
960 case 0xa5: return("386BSD");
961 case 0xb7: return("BSDI");
962 case 0xb8: return("BSDIswap");
963 case 0xc7: return("Syrinx");
964 case 0xDB: return("CP/M");
965 case 0xe1: return("DOS acc");
966 case 0xe3: return("DOS r/o");
967 case 0xf2: return("DOS 2ary");
968 case 0xFF: return("Badblocks");
969 default: return("Unknown");
970 }
971 }
972
973 void toggle_active(struct part_entry *pe)
974 {
975 /* Toggle active flag of a partition. */
976
977 if (pe == NULL) return;
978 pe->bootind = (pe->bootind == ACTIVE_FLAG) ? 0 : ACTIVE_FLAG;
979 printf("Partition changed to %sactive\n", pe->bootind ? "" : "in");
980 }
981
982 void usage(void)
983 {
984 /* Print usage message and exit. */
985
986 printf("Usage: fdisk [-hheads] [-ssectors] [device]\n");
987 exit(1);
988 }
989
MINIX 3 (repo.or.cz mirror)