1 /* vi: set sw=4 ts=4: */
2 /* fdisk.c -- Partition table manipulator for Linux.
4 * Copyright (C) 1992 A. V. Le Blanc (LeBlanc@mcc.ac.uk)
5 * Copyright (C) 2001,2002 Vladimir Oleynik <dzo@simtreas.ru> (initial bb port)
7 * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
10 #ifndef _LARGEFILE64_SOURCE
12 #define _LARGEFILE64_SOURCE
14 #include <assert.h> /* assert */
17 /* Looks like someone forgot to add this to config system */
18 #ifndef ENABLE_FEATURE_FDISK_BLKSIZE
19 # define ENABLE_FEATURE_FDISK_BLKSIZE 0
20 # define USE_FEATURE_FDISK_BLKSIZE(a)
23 #define DEFAULT_SECTOR_SIZE 512
24 #define MAX_SECTOR_SIZE 2048
25 #define SECTOR_SIZE 512 /* still used in osf/sgi/sun code */
26 #define MAXIMUM_PARTS 60
28 #define ACTIVE_FLAG 0x80
31 #define WIN98_EXTENDED 0x0f
32 #define LINUX_PARTITION 0x81
33 #define LINUX_SWAP 0x82
34 #define LINUX_NATIVE 0x83
35 #define LINUX_EXTENDED 0x85
36 #define LINUX_LVM 0x8e
37 #define LINUX_RAID 0xfd
39 /* Used for sector numbers. Today's disk sizes make it necessary */
40 typedef unsigned long long ullong;
44 unsigned char sectors;
45 unsigned short cylinders;
49 #define HDIO_GETGEO 0x0301 /* get device geometry */
51 static const char msg_building_new_label[] ALIGN1 =
52 "Building a new %s. Changes will remain in memory only,\n"
53 "until you decide to write them. After that the previous content\n"
54 "won't be recoverable.\n\n";
56 static const char msg_part_already_defined[] ALIGN1 =
57 "Partition %d is already defined, delete it before re-adding\n";
61 unsigned char boot_ind; /* 0x80 - active */
62 unsigned char head; /* starting head */
63 unsigned char sector; /* starting sector */
64 unsigned char cyl; /* starting cylinder */
65 unsigned char sys_ind; /* What partition type */
66 unsigned char end_head; /* end head */
67 unsigned char end_sector; /* end sector */
68 unsigned char end_cyl; /* end cylinder */
69 unsigned char start4[4]; /* starting sector counting from 0 */
70 unsigned char size4[4]; /* nr of sectors in partition */
73 static const char unable_to_open[] ALIGN1 = "cannot open %s";
74 static const char unable_to_read[] ALIGN1 = "cannot read from %s";
75 static const char unable_to_seek[] ALIGN1 = "cannot seek on %s";
76 static const char unable_to_write[] ALIGN1 = "cannot write to %s";
77 static const char ioctl_error[] ALIGN1 = "BLKGETSIZE ioctl failed on %s";
78 static void fdisk_fatal(const char *why) ATTRIBUTE_NORETURN;
81 label_dos, label_sun, label_sgi, label_aix, label_osf
84 #define LABEL_IS_DOS (label_dos == current_label_type)
86 #if ENABLE_FEATURE_SUN_LABEL
87 #define LABEL_IS_SUN (label_sun == current_label_type)
88 #define STATIC_SUN static
90 #define LABEL_IS_SUN 0
91 #define STATIC_SUN extern
94 #if ENABLE_FEATURE_SGI_LABEL
95 #define LABEL_IS_SGI (label_sgi == current_label_type)
96 #define STATIC_SGI static
98 #define LABEL_IS_SGI 0
99 #define STATIC_SGI extern
102 #if ENABLE_FEATURE_AIX_LABEL
103 #define LABEL_IS_AIX (label_aix == current_label_type)
104 #define STATIC_AIX static
106 #define LABEL_IS_AIX 0
107 #define STATIC_AIX extern
110 #if ENABLE_FEATURE_OSF_LABEL
111 #define LABEL_IS_OSF (label_osf == current_label_type)
112 #define STATIC_OSF static
114 #define LABEL_IS_OSF 0
115 #define STATIC_OSF extern
118 enum action { fdisk, require, try_only, create_empty_dos, create_empty_sun };
120 static void update_units(void);
121 #if ENABLE_FEATURE_FDISK_WRITABLE
122 static void change_units(void);
123 static void reread_partition_table(int leave);
124 static void delete_partition(int i);
125 static int get_partition(int warn, int max);
126 static void list_types(const char *const *sys);
127 static unsigned read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg);
129 static const char *partition_type(unsigned char type);
130 static void get_geometry(void);
131 static int get_boot(enum action what);
136 static unsigned get_start_sect(const struct partition *p);
137 static unsigned get_nr_sects(const struct partition *p);
140 * per partition table entry data
142 * The four primary partitions have the same sectorbuffer (MBRbuffer)
143 * and have NULL ext_pointer.
144 * Each logical partition table entry has two pointers, one for the
145 * partition and one link to the next one.
148 struct partition *part_table; /* points into sectorbuffer */
149 struct partition *ext_pointer; /* points into sectorbuffer */
150 ullong offset; /* disk sector number */
151 char *sectorbuffer; /* disk sector contents */
152 #if ENABLE_FEATURE_FDISK_WRITABLE
153 char changed; /* boolean */
157 /* DOS partition types */
159 static const char *const i386_sys_types[] = {
163 "\x05" "Extended", /* DOS 3.3+ extended partition */
164 "\x06" "FAT16", /* DOS 16-bit >=32M */
165 "\x07" "HPFS/NTFS", /* OS/2 IFS, eg, HPFS or NTFS or QNX */
166 "\x0a" "OS/2 Boot Manager",/* OS/2 Boot Manager */
167 "\x0b" "Win95 FAT32",
168 "\x0c" "Win95 FAT32 (LBA)",/* LBA really is 'Extended Int 13h' */
169 "\x0e" "Win95 FAT16 (LBA)",
170 "\x0f" "Win95 Ext'd (LBA)",
171 "\x11" "Hidden FAT12",
172 "\x12" "Compaq diagnostics",
173 "\x14" "Hidden FAT16 <32M",
174 "\x16" "Hidden FAT16",
175 "\x17" "Hidden HPFS/NTFS",
176 "\x1b" "Hidden Win95 FAT32",
177 "\x1c" "Hidden W95 FAT32 (LBA)",
178 "\x1e" "Hidden W95 FAT16 (LBA)",
179 "\x3c" "Part.Magic recovery",
180 "\x41" "PPC PReP Boot",
182 "\x63" "GNU HURD or SysV", /* GNU HURD or Mach or Sys V/386 (such as ISC UNIX) */
183 "\x80" "Old Minix", /* Minix 1.4a and earlier */
184 "\x81" "Minix / old Linux",/* Minix 1.4b and later */
185 "\x82" "Linux swap", /* also Solaris */
187 "\x84" "OS/2 hidden C: drive",
188 "\x85" "Linux extended",
189 "\x86" "NTFS volume set",
190 "\x87" "NTFS volume set",
192 "\x9f" "BSD/OS", /* BSDI */
193 "\xa0" "Thinkpad hibernation",
194 "\xa5" "FreeBSD", /* various BSD flavours */
198 "\xab" "Darwin boot",
201 "\xbe" "Solaris boot",
203 "\xee" "EFI GPT", /* Intel EFI GUID Partition Table */
204 "\xef" "EFI (FAT-12/16/32)", /* Intel EFI System Partition */
205 "\xf0" "Linux/PA-RISC boot", /* Linux/PA-RISC boot loader */
206 "\xf2" "DOS secondary", /* DOS 3.3+ secondary */
207 "\xfd" "Linux raid autodetect", /* New (2.2.x) raid partition with
208 autodetect using persistent
210 #if 0 /* ENABLE_WEIRD_PARTITION_TYPES */
213 "\x08" "AIX", /* AIX boot (AIX -- PS/2 port) or SplitDrive */
214 "\x09" "AIX bootable", /* AIX data or Coherent */
216 "\x18" "AST SmartSleep",
219 "\x40" "Venix 80286",
221 "\x4e" "QNX4.x 2nd part",
222 "\x4f" "QNX4.x 3rd part",
224 "\x51" "OnTrack DM6 Aux1", /* (or Novell) */
225 "\x52" "CP/M", /* CP/M or Microport SysV/AT */
226 "\x53" "OnTrack DM6 Aux3",
230 "\x5c" "Priam Edisk",
232 "\x64" "Novell Netware 286",
233 "\x65" "Novell Netware 386",
234 "\x70" "DiskSecure Multi-Boot",
237 "\x94" "Amoeba BBT", /* (bad block table) */
239 "\xbb" "Boot Wizard hidden",
240 "\xc1" "DRDOS/sec (FAT-12)",
241 "\xc4" "DRDOS/sec (FAT-16 < 32M)",
242 "\xc6" "DRDOS/sec (FAT-16)",
244 "\xda" "Non-FS data",
245 "\xdb" "CP/M / CTOS / ...",/* CP/M or Concurrent CP/M or
246 Concurrent DOS or CTOS */
247 "\xde" "Dell Utility", /* Dell PowerEdge Server utilities */
248 "\xdf" "BootIt", /* BootIt EMBRM */
249 "\xe1" "DOS access", /* DOS access or SpeedStor 12-bit FAT
250 extended partition */
251 "\xe3" "DOS R/O", /* DOS R/O or SpeedStor */
252 "\xe4" "SpeedStor", /* SpeedStor 16-bit FAT extended
253 partition < 1024 cyl. */
255 "\xf4" "SpeedStor", /* SpeedStor large partition */
256 "\xfe" "LANstep", /* SpeedStor >1024 cyl. or LANstep */
257 "\xff" "BBT", /* Xenix Bad Block Table */
268 const char *disk_device;
269 int fd; /* the disk */
270 int g_partitions; // = 4; /* maximum partition + 1 */
271 unsigned units_per_sector; // = 1;
272 unsigned sector_size; // = DEFAULT_SECTOR_SIZE;
273 unsigned user_set_sector_size;
274 unsigned sector_offset; // = 1;
275 unsigned g_heads, g_sectors, g_cylinders;
276 enum label_type current_label_type;
277 smallint display_in_cyl_units; // = 1;
278 #if ENABLE_FEATURE_OSF_LABEL
279 smallint possibly_osf_label;
283 char line_buffer[80];
284 char partname_buffer[80];
285 /* Raw disk label. For DOS-type partition tables the MBR,
286 * with descriptions of the primary partitions. */
287 char MBRbuffer[MAX_SECTOR_SIZE];
288 /* Partition tables */
289 struct pte ptes[MAXIMUM_PARTS];
291 #define G (*ptr_to_globals)
292 #define line_ptr (G.line_ptr)
293 #define disk_device (G.disk_device )
295 #define g_partitions (G.g_partitions )
296 #define units_per_sector (G.units_per_sector )
297 #define sector_size (G.sector_size )
298 #define user_set_sector_size (G.user_set_sector_size)
299 #define sector_offset (G.sector_offset )
300 #define g_heads (G.g_heads )
301 #define g_sectors (G.g_sectors )
302 #define g_cylinders (G.g_cylinders )
303 #define current_label_type (G.current_label_type )
304 #define display_in_cyl_units (G.display_in_cyl_units)
305 #define possibly_osf_label (G.possibly_osf_label )
306 #define listingbuf (G.listingbuf)
307 #define line_buffer (G.line_buffer)
308 #define partname_buffer (G.partname_buffer)
309 #define MBRbuffer (G.MBRbuffer)
310 #define ptes (G.ptes)
311 #define INIT_G() do { \
312 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
313 sector_size = DEFAULT_SECTOR_SIZE; \
316 display_in_cyl_units = 1; \
317 units_per_sector = 1; \
321 #define IS_EXTENDED(i) \
322 ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
324 #define cround(n) (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
326 #define scround(x) (((x)+units_per_sector-1)/units_per_sector)
328 #define pt_offset(b, n) \
329 ((struct partition *)((b) + 0x1be + (n) * sizeof(struct partition)))
331 #define sector(s) ((s) & 0x3f)
333 #define cylinder(s, c) ((c) | (((s) & 0xc0) << 2))
335 #define hsc2sector(h,s,c) \
336 (sector(s) - 1 + sectors * ((h) + heads * cylinder(s,c)))
338 #define set_hsc(h,s,c,sector) \
340 s = sector % g_sectors + 1; \
341 sector /= g_sectors; \
342 h = sector % g_heads; \
345 s |= (sector >> 2) & 0xc0; \
348 #if ENABLE_FEATURE_FDISK_WRITABLE
349 /* read line; return 0 or first printable char */
351 read_line(const char *prompt)
355 sz = read_line_input(prompt, line_buffer, sizeof(line_buffer), NULL);
357 exit(0); /* Ctrl-D or Ctrl-C */
359 if (line_buffer[sz-1] == '\n')
360 line_buffer[--sz] = '\0';
362 line_ptr = line_buffer;
363 while (*line_ptr && !isgraph(*line_ptr))
370 * return partition name - uses static storage
373 partname(const char *dev, int pno, int lth)
380 bufp = partname_buffer;
381 bufsiz = sizeof(partname_buffer);
386 if (isdigit(dev[w-1]))
389 /* devfs kludge - note: fdisk partition names are not supposed
390 to equal kernel names, so there is no reason to do this */
391 if (strcmp(dev + w - 4, "disc") == 0) {
399 snprintf(bufp, bufsiz, "%*.*s%s%-2u",
400 lth-wp-2, w, dev, p, pno);
402 snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
407 #if ENABLE_FEATURE_FDISK_WRITABLE
409 set_all_unchanged(void)
413 for (i = 0; i < MAXIMUM_PARTS; i++)
417 static ALWAYS_INLINE void
422 #endif /* FEATURE_FDISK_WRITABLE */
424 static ALWAYS_INLINE struct partition *
425 get_part_table(int i)
427 return ptes[i].part_table;
432 { /* n==1: use singular */
434 return display_in_cyl_units ? "cylinder" : "sector";
435 return display_in_cyl_units ? "cylinders" : "sectors";
439 valid_part_table_flag(const char *mbuffer)
441 return (mbuffer[510] == 0x55 && (uint8_t)mbuffer[511] == 0xaa);
444 #if ENABLE_FEATURE_FDISK_WRITABLE
445 static ALWAYS_INLINE void
446 write_part_table_flag(char *b)
453 read_nonempty(const char *mesg)
455 while (!read_line(mesg)) /* repeat */;
460 read_maybe_empty(const char *mesg)
462 if (!read_line(mesg)) {
463 line_ptr = line_buffer;
471 read_hex(const char *const *sys)
475 read_nonempty("Hex code (type L to list codes): ");
476 if (*line_ptr == 'l' || *line_ptr == 'L') {
480 v = bb_strtoul(line_ptr, NULL, 16);
482 /* Bad input also triggers this */
487 #endif /* FEATURE_FDISK_WRITABLE */
489 #include "fdisk_aix.c"
492 unsigned char info[128]; /* Informative text string */
493 unsigned char spare0[14];
495 unsigned char spare1;
497 unsigned char spare2;
500 unsigned char spare1[246]; /* Boot information etc. */
501 unsigned short rspeed; /* Disk rotational speed */
502 unsigned short pcylcount; /* Physical cylinder count */
503 unsigned short sparecyl; /* extra sects per cylinder */
504 unsigned char spare2[4]; /* More magic... */
505 unsigned short ilfact; /* Interleave factor */
506 unsigned short ncyl; /* Data cylinder count */
507 unsigned short nacyl; /* Alt. cylinder count */
508 unsigned short ntrks; /* Tracks per cylinder */
509 unsigned short nsect; /* Sectors per track */
510 unsigned char spare3[4]; /* Even more magic... */
511 struct sun_partinfo {
512 uint32_t start_cylinder;
513 uint32_t num_sectors;
515 unsigned short magic; /* Magic number */
516 unsigned short csum; /* Label xor'd checksum */
518 #define sunlabel ((sun_partition *)MBRbuffer)
519 STATIC_OSF void bsd_select(void);
520 STATIC_OSF void xbsd_print_disklabel(int);
521 #include "fdisk_osf.c"
523 #if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL
525 fdisk_swap16(uint16_t x)
527 return (x << 8) | (x >> 8);
531 fdisk_swap32(uint32_t x)
534 ((x & 0xFF00) << 8) |
535 ((x & 0xFF0000) >> 8) |
540 STATIC_SGI const char *const sgi_sys_types[];
541 STATIC_SGI unsigned sgi_get_num_sectors(int i);
542 STATIC_SGI int sgi_get_sysid(int i);
543 STATIC_SGI void sgi_delete_partition(int i);
544 STATIC_SGI void sgi_change_sysid(int i, int sys);
545 STATIC_SGI void sgi_list_table(int xtra);
546 #if ENABLE_FEATURE_FDISK_ADVANCED
547 STATIC_SGI void sgi_set_xcyl(void);
549 STATIC_SGI int verify_sgi(int verbose);
550 STATIC_SGI void sgi_add_partition(int n, int sys);
551 STATIC_SGI void sgi_set_swappartition(int i);
552 STATIC_SGI const char *sgi_get_bootfile(void);
553 STATIC_SGI void sgi_set_bootfile(const char* aFile);
554 STATIC_SGI void create_sgiinfo(void);
555 STATIC_SGI void sgi_write_table(void);
556 STATIC_SGI void sgi_set_bootpartition(int i);
557 #include "fdisk_sgi.c"
559 STATIC_SUN const char *const sun_sys_types[];
560 STATIC_SUN void sun_delete_partition(int i);
561 STATIC_SUN void sun_change_sysid(int i, int sys);
562 STATIC_SUN void sun_list_table(int xtra);
563 STATIC_SUN void add_sun_partition(int n, int sys);
564 #if ENABLE_FEATURE_FDISK_ADVANCED
565 STATIC_SUN void sun_set_alt_cyl(void);
566 STATIC_SUN void sun_set_ncyl(int cyl);
567 STATIC_SUN void sun_set_xcyl(void);
568 STATIC_SUN void sun_set_ilfact(void);
569 STATIC_SUN void sun_set_rspeed(void);
570 STATIC_SUN void sun_set_pcylcount(void);
572 STATIC_SUN void toggle_sunflags(int i, unsigned char mask);
573 STATIC_SUN void verify_sun(void);
574 STATIC_SUN void sun_write_table(void);
575 #include "fdisk_sun.c"
577 #if ENABLE_FEATURE_FDISK_WRITABLE
578 /* start_sect and nr_sects are stored little endian on all machines */
579 /* moreover, they are not aligned correctly */
581 store4_little_endian(unsigned char *cp, unsigned val)
588 #endif /* FEATURE_FDISK_WRITABLE */
591 read4_little_endian(const unsigned char *cp)
593 return cp[0] + (cp[1] << 8) + (cp[2] << 16) + (cp[3] << 24);
596 #if ENABLE_FEATURE_FDISK_WRITABLE
598 set_start_sect(struct partition *p, unsigned start_sect)
600 store4_little_endian(p->start4, start_sect);
605 get_start_sect(const struct partition *p)
607 return read4_little_endian(p->start4);
610 #if ENABLE_FEATURE_FDISK_WRITABLE
612 set_nr_sects(struct partition *p, unsigned nr_sects)
614 store4_little_endian(p->size4, nr_sects);
619 get_nr_sects(const struct partition *p)
621 return read4_little_endian(p->size4);
624 /* normally O_RDWR, -l option gives O_RDONLY */
625 static int type_open = O_RDWR;
627 static int ext_index; /* the prime extended partition */
628 static smallint listing; /* no aborts for fdisk -l */
629 static int dos_compatible_flag = ~0;
630 #if ENABLE_FEATURE_FDISK_WRITABLE
631 //static int dos_changed;
632 static smallint nowarn; /* no warnings for fdisk -l/-s */
635 static unsigned user_cylinders, user_heads, user_sectors;
636 static unsigned pt_heads, pt_sectors;
637 static unsigned kern_heads, kern_sectors;
639 static ullong extended_offset; /* offset of link pointers */
640 static ullong total_number_of_sectors;
642 static void fdisk_fatal(const char *why)
646 longjmp(listingbuf, 1);
648 bb_error_msg_and_die(why, disk_device);
652 seek_sector(ullong secno)
654 secno *= sector_size;
655 #if ENABLE_FDISK_SUPPORT_LARGE_DISKS
656 if (lseek64(fd, (off64_t)secno, SEEK_SET) == (off64_t) -1)
657 fdisk_fatal(unable_to_seek);
659 if (secno > MAXINT(off_t)
660 || lseek(fd, (off_t)secno, SEEK_SET) == (off_t) -1
662 fdisk_fatal(unable_to_seek);
667 #if ENABLE_FEATURE_FDISK_WRITABLE
669 write_sector(ullong secno, char *buf)
672 if (write(fd, buf, sector_size) != sector_size)
673 fdisk_fatal(unable_to_write);
677 /* Allocate a buffer and read a partition table sector */
679 read_pte(struct pte *pe, ullong offset)
682 pe->sectorbuffer = xmalloc(sector_size);
684 if (read(fd, pe->sectorbuffer, sector_size) != sector_size)
685 fdisk_fatal(unable_to_read);
686 #if ENABLE_FEATURE_FDISK_WRITABLE
689 pe->part_table = pe->ext_pointer = NULL;
693 get_partition_start(const struct pte *pe)
695 return pe->offset + get_start_sect(pe->part_table);
698 #if ENABLE_FEATURE_FDISK_WRITABLE
700 * Avoid warning about DOS partitions when no DOS partition was changed.
701 * Here a heuristic "is probably dos partition".
702 * We might also do the opposite and warn in all cases except
703 * for "is probably nondos partition".
707 is_dos_partition(int t)
709 return (t == 1 || t == 4 || t == 6 ||
710 t == 0x0b || t == 0x0c || t == 0x0e ||
711 t == 0x11 || t == 0x12 || t == 0x14 || t == 0x16 ||
712 t == 0x1b || t == 0x1c || t == 0x1e || t == 0x24 ||
713 t == 0xc1 || t == 0xc4 || t == 0xc6);
720 puts("Command Action");
722 puts("a\ttoggle a read only flag"); /* sun */
723 puts("b\tedit bsd disklabel");
724 puts("c\ttoggle the mountable flag"); /* sun */
725 puts("d\tdelete a partition");
726 puts("l\tlist known partition types");
727 puts("n\tadd a new partition");
728 puts("o\tcreate a new empty DOS partition table");
729 puts("p\tprint the partition table");
730 puts("q\tquit without saving changes");
731 puts("s\tcreate a new empty Sun disklabel"); /* sun */
732 puts("t\tchange a partition's system id");
733 puts("u\tchange display/entry units");
734 puts("v\tverify the partition table");
735 puts("w\twrite table to disk and exit");
736 #if ENABLE_FEATURE_FDISK_ADVANCED
737 puts("x\textra functionality (experts only)");
739 } else if (LABEL_IS_SGI) {
740 puts("a\tselect bootable partition"); /* sgi flavour */
741 puts("b\tedit bootfile entry"); /* sgi */
742 puts("c\tselect sgi swap partition"); /* sgi flavour */
743 puts("d\tdelete a partition");
744 puts("l\tlist known partition types");
745 puts("n\tadd a new partition");
746 puts("o\tcreate a new empty DOS partition table");
747 puts("p\tprint the partition table");
748 puts("q\tquit without saving changes");
749 puts("s\tcreate a new empty Sun disklabel"); /* sun */
750 puts("t\tchange a partition's system id");
751 puts("u\tchange display/entry units");
752 puts("v\tverify the partition table");
753 puts("w\twrite table to disk and exit");
754 } else if (LABEL_IS_AIX) {
755 puts("o\tcreate a new empty DOS partition table");
756 puts("q\tquit without saving changes");
757 puts("s\tcreate a new empty Sun disklabel"); /* sun */
759 puts("a\ttoggle a bootable flag");
760 puts("b\tedit bsd disklabel");
761 puts("c\ttoggle the dos compatibility flag");
762 puts("d\tdelete a partition");
763 puts("l\tlist known partition types");
764 puts("n\tadd a new partition");
765 puts("o\tcreate a new empty DOS partition table");
766 puts("p\tprint the partition table");
767 puts("q\tquit without saving changes");
768 puts("s\tcreate a new empty Sun disklabel"); /* sun */
769 puts("t\tchange a partition's system id");
770 puts("u\tchange display/entry units");
771 puts("v\tverify the partition table");
772 puts("w\twrite table to disk and exit");
773 #if ENABLE_FEATURE_FDISK_ADVANCED
774 puts("x\textra functionality (experts only)");
778 #endif /* FEATURE_FDISK_WRITABLE */
781 #if ENABLE_FEATURE_FDISK_ADVANCED
785 puts("Command Action");
787 puts("a\tchange number of alternate cylinders"); /*sun*/
788 puts("c\tchange number of cylinders");
789 puts("d\tprint the raw data in the partition table");
790 puts("e\tchange number of extra sectors per cylinder");/*sun*/
791 puts("h\tchange number of heads");
792 puts("i\tchange interleave factor"); /*sun*/
793 puts("o\tchange rotation speed (rpm)"); /*sun*/
794 puts("p\tprint the partition table");
795 puts("q\tquit without saving changes");
796 puts("r\treturn to main menu");
797 puts("s\tchange number of sectors/track");
798 puts("v\tverify the partition table");
799 puts("w\twrite table to disk and exit");
800 puts("y\tchange number of physical cylinders"); /*sun*/
801 } else if (LABEL_IS_SGI) {
802 puts("b\tmove beginning of data in a partition"); /* !sun */
803 puts("c\tchange number of cylinders");
804 puts("d\tprint the raw data in the partition table");
805 puts("e\tlist extended partitions"); /* !sun */
806 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
807 puts("h\tchange number of heads");
808 puts("p\tprint the partition table");
809 puts("q\tquit without saving changes");
810 puts("r\treturn to main menu");
811 puts("s\tchange number of sectors/track");
812 puts("v\tverify the partition table");
813 puts("w\twrite table to disk and exit");
814 } else if (LABEL_IS_AIX) {
815 puts("b\tmove beginning of data in a partition"); /* !sun */
816 puts("c\tchange number of cylinders");
817 puts("d\tprint the raw data in the partition table");
818 puts("e\tlist extended partitions"); /* !sun */
819 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
820 puts("h\tchange number of heads");
821 puts("p\tprint the partition table");
822 puts("q\tquit without saving changes");
823 puts("r\treturn to main menu");
824 puts("s\tchange number of sectors/track");
825 puts("v\tverify the partition table");
826 puts("w\twrite table to disk and exit");
828 puts("b\tmove beginning of data in a partition"); /* !sun */
829 puts("c\tchange number of cylinders");
830 puts("d\tprint the raw data in the partition table");
831 puts("e\tlist extended partitions"); /* !sun */
832 puts("f\tfix partition order"); /* !sun, !aix, !sgi */
833 #if ENABLE_FEATURE_SGI_LABEL
834 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
836 puts("h\tchange number of heads");
837 puts("p\tprint the partition table");
838 puts("q\tquit without saving changes");
839 puts("r\treturn to main menu");
840 puts("s\tchange number of sectors/track");
841 puts("v\tverify the partition table");
842 puts("w\twrite table to disk and exit");
845 #endif /* ADVANCED mode */
847 #if ENABLE_FEATURE_FDISK_WRITABLE
848 static const char *const *
852 LABEL_IS_SUN ? sun_sys_types :
853 LABEL_IS_SGI ? sgi_sys_types :
857 #define get_sys_types() i386_sys_types
858 #endif /* FEATURE_FDISK_WRITABLE */
861 partition_type(unsigned char type)
864 const char *const *types = get_sys_types();
866 for (i = 0; types[i]; i++)
867 if ((unsigned char)types[i][0] == type)
874 #if ENABLE_FEATURE_FDISK_WRITABLE
878 return LABEL_IS_SUN ? sunlabel->infos[i].id :
879 (LABEL_IS_SGI ? sgi_get_sysid(i) :
880 ptes[i].part_table->sys_ind);
884 list_types(const char *const *sys)
889 unsigned done, next, size;
892 for (size = 0; sys[size]; size++) /* */;
895 for (i = COLS-1; i >= 0; i--) {
896 done += (size + i - done) / (i + 1);
897 last[COLS-1 - i] = done;
902 printf("%c%2x %-22.22s", i ? ' ' : '\n',
903 (unsigned char)sys[next][0],
905 next = last[i++] + done;
906 if (i >= COLS || next >= last[i]) {
910 } while (done < last[0]);
913 #endif /* FEATURE_FDISK_WRITABLE */
916 is_cleared_partition(const struct partition *p)
918 return !(!p || p->boot_ind || p->head || p->sector || p->cyl ||
919 p->sys_ind || p->end_head || p->end_sector || p->end_cyl ||
920 get_start_sect(p) || get_nr_sects(p));
924 clear_partition(struct partition *p)
928 memset(p, 0, sizeof(struct partition));
931 #if ENABLE_FEATURE_FDISK_WRITABLE
933 set_partition(int i, int doext, ullong start, ullong stop, int sysid)
939 p = ptes[i].ext_pointer;
940 offset = extended_offset;
942 p = ptes[i].part_table;
943 offset = ptes[i].offset;
947 set_start_sect(p, start - offset);
948 set_nr_sects(p, stop - start + 1);
949 if (dos_compatible_flag && (start / (g_sectors * g_heads) > 1023))
950 start = g_heads * g_sectors * 1024 - 1;
951 set_hsc(p->head, p->sector, p->cyl, start);
952 if (dos_compatible_flag && (stop / (g_sectors * g_heads) > 1023))
953 stop = g_heads * g_sectors * 1024 - 1;
954 set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
962 if (g_heads && g_sectors && g_cylinders)
965 printf("Unknown value(s) for:");
971 printf(" cylinders");
973 #if ENABLE_FEATURE_FDISK_WRITABLE
974 " (settable in the extra functions menu)"
983 int cyl_units = g_heads * g_sectors;
985 if (display_in_cyl_units && cyl_units)
986 units_per_sector = cyl_units;
988 units_per_sector = 1; /* in sectors */
991 #if ENABLE_FEATURE_FDISK_WRITABLE
995 if (LABEL_IS_DOS && g_cylinders > 1024 && !nowarn)
997 "The number of cylinders for this disk is set to %d.\n"
998 "There is nothing wrong with that, but this is larger than 1024,\n"
999 "and could in certain setups cause problems with:\n"
1000 "1) software that runs at boot time (e.g., old versions of LILO)\n"
1001 "2) booting and partitioning software from other OSs\n"
1002 " (e.g., DOS FDISK, OS/2 FDISK)\n",
1008 read_extended(int ext)
1012 struct partition *p, *q;
1016 pex->ext_pointer = pex->part_table;
1018 p = pex->part_table;
1019 if (!get_start_sect(p)) {
1020 printf("Bad offset in primary extended partition\n");
1024 while (IS_EXTENDED(p->sys_ind)) {
1025 struct pte *pe = &ptes[g_partitions];
1027 if (g_partitions >= MAXIMUM_PARTS) {
1028 /* This is not a Linux restriction, but
1029 this program uses arrays of size MAXIMUM_PARTS.
1030 Do not try to 'improve' this test. */
1031 struct pte *pre = &ptes[g_partitions - 1];
1032 #if ENABLE_FEATURE_FDISK_WRITABLE
1033 printf("Warning: deleting partitions after %d\n",
1037 clear_partition(pre->ext_pointer);
1041 read_pte(pe, extended_offset + get_start_sect(p));
1043 if (!extended_offset)
1044 extended_offset = get_start_sect(p);
1046 q = p = pt_offset(pe->sectorbuffer, 0);
1047 for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) {
1048 if (IS_EXTENDED(p->sys_ind)) {
1049 if (pe->ext_pointer)
1050 printf("Warning: extra link "
1051 "pointer in partition table"
1052 " %d\n", g_partitions + 1);
1054 pe->ext_pointer = p;
1055 } else if (p->sys_ind) {
1057 printf("Warning: ignoring extra "
1058 "data in partition table"
1059 " %d\n", g_partitions + 1);
1065 /* very strange code here... */
1066 if (!pe->part_table) {
1067 if (q != pe->ext_pointer)
1070 pe->part_table = q + 1;
1072 if (!pe->ext_pointer) {
1073 if (q != pe->part_table)
1074 pe->ext_pointer = q;
1076 pe->ext_pointer = q + 1;
1079 p = pe->ext_pointer;
1083 #if ENABLE_FEATURE_FDISK_WRITABLE
1084 /* remove empty links */
1086 for (i = 4; i < g_partitions; i++) {
1087 struct pte *pe = &ptes[i];
1089 if (!get_nr_sects(pe->part_table)
1090 && (g_partitions > 5 || ptes[4].part_table->sys_ind)
1092 printf("Omitting empty partition (%d)\n", i+1);
1093 delete_partition(i);
1094 goto remove; /* numbering changed */
1100 #if ENABLE_FEATURE_FDISK_WRITABLE
1102 create_doslabel(void)
1106 printf(msg_building_new_label, "DOS disklabel");
1108 current_label_type = label_dos;
1110 #if ENABLE_FEATURE_OSF_LABEL
1111 possibly_osf_label = 0;
1115 for (i = 510-64; i < 510; i++)
1117 write_part_table_flag(MBRbuffer);
1118 extended_offset = 0;
1119 set_all_unchanged();
1121 get_boot(create_empty_dos);
1123 #endif /* FEATURE_FDISK_WRITABLE */
1126 get_sectorsize(void)
1128 if (!user_set_sector_size) {
1130 if (ioctl(fd, BLKSSZGET, &arg) == 0)
1132 if (sector_size != DEFAULT_SECTOR_SIZE)
1133 printf("Note: sector size is %d (not %d)\n",
1134 sector_size, DEFAULT_SECTOR_SIZE);
1139 get_kernel_geometry(void)
1141 struct hd_geometry geometry;
1143 if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
1144 kern_heads = geometry.heads;
1145 kern_sectors = geometry.sectors;
1146 /* never use geometry.cylinders - it is truncated */
1151 get_partition_table_geometry(void)
1153 const unsigned char *bufp = (const unsigned char *)MBRbuffer;
1154 struct partition *p;
1155 int i, h, s, hh, ss;
1159 if (!(valid_part_table_flag((char*)bufp)))
1163 for (i = 0; i < 4; i++) {
1164 p = pt_offset(bufp, i);
1165 if (p->sys_ind != 0) {
1166 h = p->end_head + 1;
1167 s = (p->end_sector & 077);
1172 } else if (hh != h || ss != s)
1177 if (!first && !bad) {
1190 sec_fac = sector_size / 512;
1191 #if ENABLE_FEATURE_SUN_LABEL
1192 guess_device_type();
1194 g_heads = g_cylinders = g_sectors = 0;
1195 kern_heads = kern_sectors = 0;
1196 pt_heads = pt_sectors = 0;
1198 get_kernel_geometry();
1199 get_partition_table_geometry();
1201 g_heads = user_heads ? user_heads :
1202 pt_heads ? pt_heads :
1203 kern_heads ? kern_heads : 255;
1204 g_sectors = user_sectors ? user_sectors :
1205 pt_sectors ? pt_sectors :
1206 kern_sectors ? kern_sectors : 63;
1207 if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
1208 /* got bytes, convert to 512 byte sectors */
1209 total_number_of_sectors = (v64 >> 9);
1211 unsigned long longsectors; /* need temp of type long */
1212 if (ioctl(fd, BLKGETSIZE, &longsectors))
1214 total_number_of_sectors = longsectors;
1218 if (dos_compatible_flag)
1219 sector_offset = g_sectors;
1221 g_cylinders = total_number_of_sectors / (g_heads * g_sectors * sec_fac);
1223 g_cylinders = user_cylinders;
1227 * Read MBR. Returns:
1228 * -1: no 0xaa55 flag present (possibly entire disk BSD)
1229 * 0: found or created label
1233 get_boot(enum action what)
1239 for (i = 0; i < 4; i++) {
1240 struct pte *pe = &ptes[i];
1242 pe->part_table = pt_offset(MBRbuffer, i);
1243 pe->ext_pointer = NULL;
1245 pe->sectorbuffer = MBRbuffer;
1246 #if ENABLE_FEATURE_FDISK_WRITABLE
1247 pe->changed = (what == create_empty_dos);
1251 #if ENABLE_FEATURE_SUN_LABEL
1252 if (what == create_empty_sun && check_sun_label())
1256 memset(MBRbuffer, 0, 512);
1258 #if ENABLE_FEATURE_FDISK_WRITABLE
1259 if (what == create_empty_dos)
1260 goto got_dos_table; /* skip reading disk */
1262 fd = open(disk_device, type_open);
1264 fd = open(disk_device, O_RDONLY);
1266 if (what == try_only)
1268 fdisk_fatal(unable_to_open);
1270 printf("You will not be able to write "
1271 "the partition table\n");
1274 if (512 != read(fd, MBRbuffer, 512)) {
1275 if (what == try_only)
1277 fdisk_fatal(unable_to_read);
1280 fd = open(disk_device, O_RDONLY);
1283 if (512 != read(fd, MBRbuffer, 512))
1291 #if ENABLE_FEATURE_SUN_LABEL
1292 if (check_sun_label())
1296 #if ENABLE_FEATURE_SGI_LABEL
1297 if (check_sgi_label())
1301 #if ENABLE_FEATURE_AIX_LABEL
1302 if (check_aix_label())
1306 #if ENABLE_FEATURE_OSF_LABEL
1307 if (check_osf_label()) {
1308 possibly_osf_label = 1;
1309 if (!valid_part_table_flag(MBRbuffer)) {
1310 current_label_type = label_osf;
1313 printf("This disk has both DOS and BSD magic.\n"
1314 "Give the 'b' command to go to BSD mode.\n");
1318 #if ENABLE_FEATURE_FDISK_WRITABLE
1322 if (!valid_part_table_flag(MBRbuffer)) {
1323 #if !ENABLE_FEATURE_FDISK_WRITABLE
1328 printf("Device contains neither a valid DOS "
1329 "partition table, nor Sun, SGI or OSF "
1332 #if ENABLE_FEATURE_SUN_LABEL
1341 case create_empty_dos:
1342 #if ENABLE_FEATURE_SUN_LABEL
1343 case create_empty_sun:
1347 bb_error_msg_and_die("internal error");
1349 #endif /* FEATURE_FDISK_WRITABLE */
1352 #if ENABLE_FEATURE_FDISK_WRITABLE
1357 for (i = 0; i < 4; i++) {
1358 struct pte *pe = &ptes[i];
1360 if (IS_EXTENDED(pe->part_table->sys_ind)) {
1361 if (g_partitions != 4)
1362 printf("Ignoring extra extended "
1363 "partition %d\n", i + 1);
1369 for (i = 3; i < g_partitions; i++) {
1370 struct pte *pe = &ptes[i];
1372 if (!valid_part_table_flag(pe->sectorbuffer)) {
1373 printf("Warning: invalid flag 0x%02x,0x%02x of partition "
1374 "table %d will be corrected by w(rite)\n",
1375 pe->sectorbuffer[510],
1376 pe->sectorbuffer[511],
1378 #if ENABLE_FEATURE_FDISK_WRITABLE
1387 #if ENABLE_FEATURE_FDISK_WRITABLE
1389 * Print the message MESG, then read an integer between LOW and HIGH (inclusive).
1390 * If the user hits Enter, DFLT is returned.
1391 * Answers like +10 are interpreted as offsets from BASE.
1393 * There is no default if DFLT is not between LOW and HIGH.
1396 read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg)
1400 const char *fmt = "%s (%u-%u, default %u): ";
1402 if (dflt < low || dflt > high) {
1403 fmt = "%s (%u-%u): ";
1408 int use_default = default_ok;
1410 /* ask question and read answer */
1412 printf(fmt, mesg, low, high, dflt);
1413 read_maybe_empty("");
1414 } while (*line_ptr != '\n' && !isdigit(*line_ptr)
1415 && *line_ptr != '-' && *line_ptr != '+');
1417 if (*line_ptr == '+' || *line_ptr == '-') {
1418 int minus = (*line_ptr == '-');
1421 i = atoi(line_ptr + 1);
1423 while (isdigit(*++line_ptr))
1426 switch (*line_ptr) {
1429 if (!display_in_cyl_units)
1430 i *= g_heads * g_sectors;
1444 absolute = 1000000000;
1453 bytes = (ullong) i * absolute;
1454 unit = sector_size * units_per_sector;
1455 bytes += unit/2; /* round */
1464 while (isdigit(*line_ptr)) {
1471 printf("Using default value %u\n", i);
1473 if (i >= low && i <= high)
1475 printf("Value is out of range\n");
1481 get_partition(int warn, int max)
1486 i = read_int(1, 0, max, 0, "Partition number") - 1;
1490 if ((!LABEL_IS_SUN && !LABEL_IS_SGI && !pe->part_table->sys_ind)
1491 || (LABEL_IS_SUN && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id))
1492 || (LABEL_IS_SGI && !sgi_get_num_sectors(i))
1494 printf("Warning: partition %d has empty type\n", i+1);
1501 get_existing_partition(int warn, int max)
1506 for (i = 0; i < max; i++) {
1507 struct pte *pe = &ptes[i];
1508 struct partition *p = pe->part_table;
1510 if (p && !is_cleared_partition(p)) {
1517 printf("Selected partition %d\n", pno+1);
1520 printf("No partition is defined yet!\n");
1524 return get_partition(warn, max);
1528 get_nonexisting_partition(int warn, int max)
1533 for (i = 0; i < max; i++) {
1534 struct pte *pe = &ptes[i];
1535 struct partition *p = pe->part_table;
1537 if (p && is_cleared_partition(p)) {
1544 printf("Selected partition %d\n", pno+1);
1547 printf("All primary partitions have been defined already!\n");
1551 return get_partition(warn, max);
1558 display_in_cyl_units = !display_in_cyl_units;
1560 printf("Changing display/entry units to %s\n",
1565 toggle_active(int i)
1567 struct pte *pe = &ptes[i];
1568 struct partition *p = pe->part_table;
1570 if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
1571 printf("WARNING: Partition %d is an extended partition\n", i + 1);
1572 p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
1577 toggle_dos_compatibility_flag(void)
1579 dos_compatible_flag = ~dos_compatible_flag;
1580 if (dos_compatible_flag) {
1581 sector_offset = g_sectors;
1582 printf("DOS Compatibility flag is set\n");
1585 printf("DOS Compatibility flag is not set\n");
1590 delete_partition(int i)
1592 struct pte *pe = &ptes[i];
1593 struct partition *p = pe->part_table;
1594 struct partition *q = pe->ext_pointer;
1596 /* Note that for the fifth partition (i == 4) we don't actually
1597 * decrement partitions.
1600 if (warn_geometry())
1601 return; /* C/H/S not set */
1605 sun_delete_partition(i);
1609 sgi_delete_partition(i);
1614 if (IS_EXTENDED(p->sys_ind) && i == ext_index) {
1616 ptes[ext_index].ext_pointer = NULL;
1617 extended_offset = 0;
1623 if (!q->sys_ind && i > 4) {
1624 /* the last one in the chain - just delete */
1627 clear_partition(ptes[i].ext_pointer);
1628 ptes[i].changed = 1;
1630 /* not the last one - further ones will be moved down */
1632 /* delete this link in the chain */
1633 p = ptes[i-1].ext_pointer;
1635 set_start_sect(p, get_start_sect(q));
1636 set_nr_sects(p, get_nr_sects(q));
1637 ptes[i-1].changed = 1;
1638 } else if (g_partitions > 5) { /* 5 will be moved to 4 */
1639 /* the first logical in a longer chain */
1642 if (pe->part_table) /* prevent SEGFAULT */
1643 set_start_sect(pe->part_table,
1644 get_partition_start(pe) -
1646 pe->offset = extended_offset;
1650 if (g_partitions > 5) {
1652 while (i < g_partitions) {
1653 ptes[i] = ptes[i+1];
1657 /* the only logical: clear only */
1658 clear_partition(ptes[i].part_table);
1665 int i, sys, origsys;
1666 struct partition *p;
1668 /* If sgi_label then don't use get_existing_partition,
1669 let the user select a partition, since get_existing_partition()
1670 only works for Linux like partition tables. */
1671 if (!LABEL_IS_SGI) {
1672 i = get_existing_partition(0, g_partitions);
1674 i = get_partition(0, g_partitions);
1678 p = ptes[i].part_table;
1679 origsys = sys = get_sysid(i);
1681 /* if changing types T to 0 is allowed, then
1682 the reverse change must be allowed, too */
1683 if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) {
1684 printf("Partition %d does not exist yet!\n", i + 1);
1688 sys = read_hex(get_sys_types());
1690 if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) {
1691 printf("Type 0 means free space to many systems\n"
1692 "(but not to Linux). Having partitions of\n"
1693 "type 0 is probably unwise.\n");
1697 if (!LABEL_IS_SUN && !LABEL_IS_SGI) {
1698 if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {
1699 printf("You cannot change a partition into"
1700 " an extended one or vice versa\n");
1706 #if ENABLE_FEATURE_SUN_LABEL
1707 if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK)
1708 printf("Consider leaving partition 3 "
1709 "as Whole disk (5),\n"
1710 "as SunOS/Solaris expects it and "
1711 "even Linux likes it\n\n");
1713 #if ENABLE_FEATURE_SGI_LABEL
1716 (i == 10 && sys != SGI_ENTIRE_DISK) ||
1717 (i == 8 && sys != 0)
1720 printf("Consider leaving partition 9 "
1721 "as volume header (0),\nand "
1722 "partition 11 as entire volume (6)"
1723 "as IRIX expects it\n\n");
1729 sun_change_sysid(i, sys);
1730 } else if (LABEL_IS_SGI) {
1731 sgi_change_sysid(i, sys);
1735 printf("Changed system type of partition %d "
1736 "to %x (%s)\n", i + 1, sys,
1737 partition_type(sys));
1738 ptes[i].changed = 1;
1739 //if (is_dos_partition(origsys) || is_dos_partition(sys))
1745 #endif /* FEATURE_FDISK_WRITABLE */
1748 /* check_consistency() and linear2chs() added Sat Mar 6 12:28:16 1993,
1749 * faith@cs.unc.edu, based on code fragments from pfdisk by Gordon W. Ross,
1750 * Jan. 1990 (version 1.2.1 by Gordon W. Ross Aug. 1990; Modified by S.
1751 * Lubkin Oct. 1991). */
1754 linear2chs(unsigned ls, unsigned *c, unsigned *h, unsigned *s)
1756 int spc = g_heads * g_sectors;
1760 *h = ls / g_sectors;
1761 *s = ls % g_sectors + 1; /* sectors count from 1 */
1765 check_consistency(const struct partition *p, int partition)
1767 unsigned pbc, pbh, pbs; /* physical beginning c, h, s */
1768 unsigned pec, peh, pes; /* physical ending c, h, s */
1769 unsigned lbc, lbh, lbs; /* logical beginning c, h, s */
1770 unsigned lec, leh, les; /* logical ending c, h, s */
1772 if (!g_heads || !g_sectors || (partition >= 4))
1773 return; /* do not check extended partitions */
1775 /* physical beginning c, h, s */
1776 pbc = (p->cyl & 0xff) | ((p->sector << 2) & 0x300);
1778 pbs = p->sector & 0x3f;
1780 /* physical ending c, h, s */
1781 pec = (p->end_cyl & 0xff) | ((p->end_sector << 2) & 0x300);
1783 pes = p->end_sector & 0x3f;
1785 /* compute logical beginning (c, h, s) */
1786 linear2chs(get_start_sect(p), &lbc, &lbh, &lbs);
1788 /* compute logical ending (c, h, s) */
1789 linear2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
1791 /* Same physical / logical beginning? */
1792 if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
1793 printf("Partition %d has different physical/logical "
1794 "beginnings (non-Linux?):\n", partition + 1);
1795 printf(" phys=(%d, %d, %d) ", pbc, pbh, pbs);
1796 printf("logical=(%d, %d, %d)\n",lbc, lbh, lbs);
1799 /* Same physical / logical ending? */
1800 if (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
1801 printf("Partition %d has different physical/logical "
1802 "endings:\n", partition + 1);
1803 printf(" phys=(%d, %d, %d) ", pec, peh, pes);
1804 printf("logical=(%d, %d, %d)\n", lec, leh, les);
1807 /* Ending on cylinder boundary? */
1808 if (peh != (g_heads - 1) || pes != g_sectors) {
1809 printf("Partition %i does not end on cylinder boundary\n",
1815 list_disk_geometry(void)
1817 long long bytes = (total_number_of_sectors << 9);
1818 long megabytes = bytes/1000000;
1820 if (megabytes < 10000)
1821 printf("\nDisk %s: %ld MB, %lld bytes\n",
1822 disk_device, megabytes, bytes);
1824 printf("\nDisk %s: %ld.%ld GB, %lld bytes\n",
1825 disk_device, megabytes/1000, (megabytes/100)%10, bytes);
1826 printf("%d heads, %d sectors/track, %d cylinders",
1827 g_heads, g_sectors, g_cylinders);
1828 if (units_per_sector == 1)
1829 printf(", total %llu sectors",
1830 total_number_of_sectors / (sector_size/512));
1831 printf("\nUnits = %s of %d * %d = %d bytes\n\n",
1833 units_per_sector, sector_size, units_per_sector * sector_size);
1837 * Check whether partition entries are ordered by their starting positions.
1838 * Return 0 if OK. Return i if partition i should have been earlier.
1839 * Two separate checks: primary and logical partitions.
1842 wrong_p_order(int *prev)
1844 const struct pte *pe;
1845 const struct partition *p;
1846 ullong last_p_start_pos = 0, p_start_pos;
1849 for (i = 0; i < g_partitions; i++) {
1852 last_p_start_pos = 0;
1857 p_start_pos = get_partition_start(pe);
1859 if (last_p_start_pos > p_start_pos) {
1865 last_p_start_pos = p_start_pos;
1872 #if ENABLE_FEATURE_FDISK_ADVANCED
1874 * Fix the chain of logicals.
1875 * extended_offset is unchanged, the set of sectors used is unchanged
1876 * The chain is sorted so that sectors increase, and so that
1877 * starting sectors increase.
1879 * After this it may still be that cfdisk doesnt like the table.
1880 * (This is because cfdisk considers expanded parts, from link to
1881 * end of partition, and these may still overlap.)
1883 * sfdisk /dev/hda > ohda; sfdisk /dev/hda < ohda
1887 fix_chain_of_logicals(void)
1889 int j, oj, ojj, sj, sjj;
1890 struct partition *pj,*pjj,tmp;
1892 /* Stage 1: sort sectors but leave sector of part 4 */
1893 /* (Its sector is the global extended_offset.) */
1895 for (j = 5; j < g_partitions - 1; j++) {
1896 oj = ptes[j].offset;
1897 ojj = ptes[j+1].offset;
1899 ptes[j].offset = ojj;
1900 ptes[j+1].offset = oj;
1901 pj = ptes[j].part_table;
1902 set_start_sect(pj, get_start_sect(pj)+oj-ojj);
1903 pjj = ptes[j+1].part_table;
1904 set_start_sect(pjj, get_start_sect(pjj)+ojj-oj);
1905 set_start_sect(ptes[j-1].ext_pointer,
1906 ojj-extended_offset);
1907 set_start_sect(ptes[j].ext_pointer,
1908 oj-extended_offset);
1913 /* Stage 2: sort starting sectors */
1915 for (j = 4; j < g_partitions - 1; j++) {
1916 pj = ptes[j].part_table;
1917 pjj = ptes[j+1].part_table;
1918 sj = get_start_sect(pj);
1919 sjj = get_start_sect(pjj);
1920 oj = ptes[j].offset;
1921 ojj = ptes[j+1].offset;
1922 if (oj+sj > ojj+sjj) {
1926 set_start_sect(pj, ojj+sjj-oj);
1927 set_start_sect(pjj, oj+sj-ojj);
1932 /* Probably something was changed */
1933 for (j = 4; j < g_partitions; j++)
1934 ptes[j].changed = 1;
1939 fix_partition_table_order(void)
1941 struct pte *pei, *pek;
1944 if (!wrong_p_order(NULL)) {
1945 printf("Ordering is already correct\n\n");
1949 while ((i = wrong_p_order(&k)) != 0 && i < 4) {
1950 /* partition i should have come earlier, move it */
1951 /* We have to move data in the MBR */
1952 struct partition *pi, *pk, *pe, pbuf;
1956 pe = pei->ext_pointer;
1957 pei->ext_pointer = pek->ext_pointer;
1958 pek->ext_pointer = pe;
1960 pi = pei->part_table;
1961 pk = pek->part_table;
1963 memmove(&pbuf, pi, sizeof(struct partition));
1964 memmove(pi, pk, sizeof(struct partition));
1965 memmove(pk, &pbuf, sizeof(struct partition));
1967 pei->changed = pek->changed = 1;
1971 fix_chain_of_logicals();
1979 list_table(int xtra)
1981 const struct partition *p;
1985 sun_list_table(xtra);
1989 sgi_list_table(xtra);
1993 list_disk_geometry();
1996 xbsd_print_disklabel(xtra);
2000 /* Heuristic: we list partition 3 of /dev/foo as /dev/foo3,
2001 but if the device name ends in a digit, say /dev/foo1,
2002 then the partition is called /dev/foo1p3. */
2003 w = strlen(disk_device);
2004 if (w && isdigit(disk_device[w-1]))
2009 // 1 12345678901 12345678901 12345678901 12
2010 printf("%*s Boot Start End Blocks Id System\n",
2013 for (i = 0; i < g_partitions; i++) {
2014 const struct pte *pe = &ptes[i];
2020 if (!p || is_cleared_partition(p))
2023 psects = get_nr_sects(p);
2027 if (sector_size < 1024) {
2028 pblocks /= (1024 / sector_size);
2029 podd = psects % (1024 / sector_size);
2031 if (sector_size > 1024)
2032 pblocks *= (sector_size / 1024);
2034 printf("%s %c %11llu %11llu %11llu%c %2x %s\n",
2035 partname(disk_device, i+1, w+2),
2036 !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */
2038 (ullong) cround(get_partition_start(pe)), /* start */
2039 (ullong) cround(get_partition_start(pe) + psects /* end */
2040 - (psects ? 1 : 0)),
2041 (ullong) pblocks, podd ? '+' : ' ', /* odd flag on end */
2042 p->sys_ind, /* type id */
2043 partition_type(p->sys_ind)); /* type name */
2045 check_consistency(p, i);
2048 /* Is partition table in disk order? It need not be, but... */
2049 /* partition table entries are not checked for correct order if this
2050 is a sgi, sun or aix labeled disk... */
2051 if (LABEL_IS_DOS && wrong_p_order(NULL)) {
2053 printf("\nPartition table entries are not in disk order\n");
2057 #if ENABLE_FEATURE_FDISK_ADVANCED
2059 x_list_table(int extend)
2061 const struct pte *pe;
2062 const struct partition *p;
2065 printf("\nDisk %s: %d heads, %d sectors, %d cylinders\n\n",
2066 disk_device, g_heads, g_sectors, g_cylinders);
2067 printf("Nr AF Hd Sec Cyl Hd Sec Cyl Start Size ID\n");
2068 for (i = 0; i < g_partitions; i++) {
2070 p = (extend ? pe->ext_pointer : pe->part_table);
2072 printf("%2d %02x%4d%4d%5d%4d%4d%5d%11u%11u %02x\n",
2073 i + 1, p->boot_ind, p->head,
2075 cylinder(p->sector, p->cyl), p->end_head,
2076 sector(p->end_sector),
2077 cylinder(p->end_sector, p->end_cyl),
2078 get_start_sect(p), get_nr_sects(p), p->sys_ind);
2080 check_consistency(p, i);
2086 #if ENABLE_FEATURE_FDISK_WRITABLE
2088 fill_bounds(ullong *first, ullong *last)
2091 const struct pte *pe = &ptes[0];
2092 const struct partition *p;
2094 for (i = 0; i < g_partitions; pe++,i++) {
2096 if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) {
2097 first[i] = 0xffffffff;
2100 first[i] = get_partition_start(pe);
2101 last[i] = first[i] + get_nr_sects(p) - 1;
2107 check(int n, unsigned h, unsigned s, unsigned c, ullong start)
2109 ullong total, real_s, real_c;
2111 real_s = sector(s) - 1;
2112 real_c = cylinder(s, c);
2113 total = (real_c * g_sectors + real_s) * g_heads + h;
2115 printf("Partition %d contains sector 0\n", n);
2117 printf("Partition %d: head %d greater than maximum %d\n",
2119 if (real_s >= g_sectors)
2120 printf("Partition %d: sector %d greater than "
2121 "maximum %d\n", n, s, g_sectors);
2122 if (real_c >= g_cylinders)
2123 printf("Partition %d: cylinder %llu greater than "
2124 "maximum %d\n", n, real_c + 1, g_cylinders);
2125 if (g_cylinders <= 1024 && start != total)
2126 printf("Partition %d: previous sectors %llu disagrees with "
2127 "total %llu\n", n, start, total);
2135 ullong first[g_partitions], last[g_partitions];
2136 struct partition *p;
2138 if (warn_geometry())
2150 fill_bounds(first, last);
2151 for (i = 0; i < g_partitions; i++) {
2152 struct pte *pe = &ptes[i];
2155 if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
2156 check_consistency(p, i);
2157 if (get_partition_start(pe) < first[i])
2158 printf("Warning: bad start-of-data in "
2159 "partition %d\n", i + 1);
2160 check(i + 1, p->end_head, p->end_sector, p->end_cyl,
2162 total += last[i] + 1 - first[i];
2163 for (j = 0; j < i; j++) {
2164 if ((first[i] >= first[j] && first[i] <= last[j])
2165 || ((last[i] <= last[j] && last[i] >= first[j]))) {
2166 printf("Warning: partition %d overlaps "
2167 "partition %d\n", j + 1, i + 1);
2168 total += first[i] >= first[j] ?
2169 first[i] : first[j];
2170 total -= last[i] <= last[j] ?
2177 if (extended_offset) {
2178 struct pte *pex = &ptes[ext_index];
2179 ullong e_last = get_start_sect(pex->part_table) +
2180 get_nr_sects(pex->part_table) - 1;
2182 for (i = 4; i < g_partitions; i++) {
2184 p = ptes[i].part_table;
2186 if (i != 4 || i + 1 < g_partitions)
2187 printf("Warning: partition %d "
2188 "is empty\n", i + 1);
2189 } else if (first[i] < extended_offset || last[i] > e_last) {
2190 printf("Logical partition %d not entirely in "
2191 "partition %d\n", i + 1, ext_index + 1);
2196 if (total > g_heads * g_sectors * g_cylinders)
2197 printf("Total allocated sectors %d greater than the maximum "
2198 "%d\n", total, g_heads * g_sectors * g_cylinders);
2200 total = g_heads * g_sectors * g_cylinders - total;
2202 printf("%d unallocated sectors\n", total);
2207 add_partition(int n, int sys)
2209 char mesg[256]; /* 48 does not suffice in Japanese */
2210 int i, num_read = 0;
2211 struct partition *p = ptes[n].part_table;
2212 struct partition *q = ptes[ext_index].part_table;
2214 ullong start, stop = 0;
2215 ullong first[g_partitions], last[g_partitions];
2217 if (p && p->sys_ind) {
2218 printf(msg_part_already_defined, n + 1);
2221 fill_bounds(first, last);
2223 start = sector_offset;
2224 if (display_in_cyl_units || !total_number_of_sectors)
2225 limit = (ullong) g_heads * g_sectors * g_cylinders - 1;
2227 limit = total_number_of_sectors - 1;
2228 if (extended_offset) {
2229 first[ext_index] = extended_offset;
2230 last[ext_index] = get_start_sect(q) +
2231 get_nr_sects(q) - 1;
2234 start = extended_offset + sector_offset;
2235 limit = get_start_sect(q) + get_nr_sects(q) - 1;
2237 if (display_in_cyl_units)
2238 for (i = 0; i < g_partitions; i++)
2239 first[i] = (cround(first[i]) - 1) * units_per_sector;
2241 snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));
2244 for (i = 0; i < g_partitions; i++) {
2247 if (start == ptes[i].offset)
2248 start += sector_offset;
2249 lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
2250 if (start >= first[i] && start <= lastplusoff)
2251 start = lastplusoff + 1;
2255 if (start >= temp+units_per_sector && num_read) {
2256 printf("Sector %lld is already allocated\n", temp);
2260 if (!num_read && start == temp) {
2263 saved_start = start;
2264 start = read_int(cround(saved_start), cround(saved_start), cround(limit),
2266 if (display_in_cyl_units) {
2267 start = (start - 1) * units_per_sector;
2268 if (start < saved_start) start = saved_start;
2272 } while (start != temp || !num_read);
2273 if (n > 4) { /* NOT for fifth partition */
2274 struct pte *pe = &ptes[n];
2276 pe->offset = start - sector_offset;
2277 if (pe->offset == extended_offset) { /* must be corrected */
2279 if (sector_offset == 1)
2284 for (i = 0; i < g_partitions; i++) {
2285 struct pte *pe = &ptes[i];
2287 if (start < pe->offset && limit >= pe->offset)
2288 limit = pe->offset - 1;
2289 if (start < first[i] && limit >= first[i])
2290 limit = first[i] - 1;
2292 if (start > limit) {
2293 printf("No free sectors available\n");
2298 if (cround(start) == cround(limit)) {
2301 snprintf(mesg, sizeof(mesg),
2302 "Last %s or +size or +sizeM or +sizeK",
2303 str_units(SINGULAR));
2304 stop = read_int(cround(start), cround(limit), cround(limit),
2305 cround(start), mesg);
2306 if (display_in_cyl_units) {
2307 stop = stop * units_per_sector - 1;
2313 set_partition(n, 0, start, stop, sys);
2315 set_partition(n - 1, 1, ptes[n].offset, stop, EXTENDED);
2317 if (IS_EXTENDED(sys)) {
2318 struct pte *pe4 = &ptes[4];
2319 struct pte *pen = &ptes[n];
2322 pen->ext_pointer = p;
2323 pe4->offset = extended_offset = start;
2324 pe4->sectorbuffer = xzalloc(sector_size);
2325 pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
2326 pe4->ext_pointer = pe4->part_table + 1;
2335 if (g_partitions > 5 || ptes[4].part_table->sys_ind) {
2336 struct pte *pe = &ptes[g_partitions];
2338 pe->sectorbuffer = xzalloc(sector_size);
2339 pe->part_table = pt_offset(pe->sectorbuffer, 0);
2340 pe->ext_pointer = pe->part_table + 1;
2345 add_partition(g_partitions - 1, LINUX_NATIVE);
2351 int i, free_primary = 0;
2353 if (warn_geometry())
2357 add_sun_partition(get_partition(0, g_partitions), LINUX_NATIVE);
2361 sgi_add_partition(get_partition(0, g_partitions), LINUX_NATIVE);
2365 printf("Sorry - this fdisk cannot handle AIX disk labels.\n"
2366 "If you want to add DOS-type partitions, create a new empty DOS partition\n"
2367 "table first (use 'o'). This will destroy the present disk contents.\n");
2371 for (i = 0; i < 4; i++)
2372 free_primary += !ptes[i].part_table->sys_ind;
2374 if (!free_primary && g_partitions >= MAXIMUM_PARTS) {
2375 printf("The maximum number of partitions has been created\n");
2379 if (!free_primary) {
2380 if (extended_offset)
2383 printf("You must delete some partition and add "
2384 "an extended partition first\n");
2387 snprintf(line, sizeof(line),
2390 " p primary partition (1-4)\n",
2392 "l logical (5 or over)" : "e extended"));
2394 c = read_nonempty(line);
2395 if (c == 'p' || c == 'P') {
2396 i = get_nonexisting_partition(0, 4);
2398 add_partition(i, LINUX_NATIVE);
2401 if (c == 'l' && extended_offset) {
2405 if (c == 'e' && !extended_offset) {
2406 i = get_nonexisting_partition(0, 4);
2408 add_partition(i, EXTENDED);
2411 printf("Invalid partition number "
2412 "for type '%c'\n", c);
2423 for (i = 0; i < 3; i++)
2424 if (ptes[i].changed)
2425 ptes[3].changed = 1;
2426 for (i = 3; i < g_partitions; i++) {
2427 struct pte *pe = &ptes[i];
2430 write_part_table_flag(pe->sectorbuffer);
2431 write_sector(pe->offset, pe->sectorbuffer);
2435 else if (LABEL_IS_SGI) {
2436 /* no test on change? the printf below might be mistaken */
2439 else if (LABEL_IS_SUN) {
2442 for (i = 0; i < 8; i++)
2443 if (ptes[i].changed)
2449 printf("The partition table has been altered!\n\n");
2450 reread_partition_table(1);
2454 reread_partition_table(int leave)
2458 printf("Calling ioctl() to re-read partition table\n");
2460 /* sleep(2); Huh? */
2461 i = ioctl_or_perror(fd, BLKRRPART, NULL,
2462 "WARNING: rereading partition table "
2463 "failed, kernel still uses old table");
2467 "\nWARNING: If you have created or modified any DOS 6.x\n"
2468 "partitions, please see the fdisk manual page for additional\n"
2473 if (ENABLE_FEATURE_CLEAN_UP)
2478 #endif /* FEATURE_FDISK_WRITABLE */
2480 #if ENABLE_FEATURE_FDISK_ADVANCED
2481 #define MAX_PER_LINE 16
2483 print_buffer(char *pbuffer)
2487 for (i = 0, l = 0; i < sector_size; i++, l++) {
2489 printf("0x%03X:", i);
2490 printf(" %02X", (unsigned char) pbuffer[i]);
2491 if (l == MAX_PER_LINE - 1) {
2506 printf("Device: %s\n", disk_device);
2507 if (LABEL_IS_SGI || LABEL_IS_SUN)
2508 print_buffer(MBRbuffer);
2510 for (i = 3; i < g_partitions; i++)
2511 print_buffer(ptes[i].sectorbuffer);
2518 struct pte *pe = &ptes[i];
2519 struct partition *p = pe->part_table;
2522 if (warn_geometry())
2524 if (!p->sys_ind || !get_nr_sects(p) || IS_EXTENDED(p->sys_ind)) {
2525 printf("Partition %d has no data area\n", i + 1);
2528 first = get_partition_start(pe);
2529 new = read_int(first, first, first + get_nr_sects(p) - 1, first,
2530 "New beginning of data") - pe->offset;
2532 if (new != get_nr_sects(p)) {
2533 first = get_nr_sects(p) + get_start_sect(p) - new;
2534 set_nr_sects(p, first);
2535 set_start_sect(p, new);
2547 c = tolower(read_nonempty("Expert command (m for help): "));
2555 move_begin(get_partition(0, g_partitions));
2558 user_cylinders = g_cylinders =
2559 read_int(1, g_cylinders, 1048576, 0,
2560 "Number of cylinders");
2562 sun_set_ncyl(g_cylinders);
2572 else if (LABEL_IS_SUN)
2574 else if (LABEL_IS_DOS)
2579 fix_partition_table_order();
2582 #if ENABLE_FEATURE_SGI_LABEL
2587 user_heads = g_heads = read_int(1, g_heads, 256, 0,
2612 user_sectors = g_sectors = read_int(1, g_sectors, 63, 0,
2613 "Number of sectors");
2614 if (dos_compatible_flag) {
2615 sector_offset = g_sectors;
2616 printf("Warning: setting sector offset for DOS "
2625 write_table(); /* does not return */
2629 sun_set_pcylcount();
2636 #endif /* ADVANCED mode */
2639 is_ide_cdrom_or_tape(const char *device)
2643 struct stat statbuf;
2646 /* No device was given explicitly, and we are trying some
2647 likely things. But opening /dev/hdc may produce errors like
2648 "hdc: tray open or drive not ready"
2649 if it happens to be a CD-ROM drive. It even happens that
2650 the process hangs on the attempt to read a music CD.
2651 So try to be careful. This only works since 2.1.73. */
2653 if (strncmp("/dev/hd", device, 7))
2656 snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
2657 procf = fopen(buf, "r");
2658 if (procf != NULL && fgets(buf, sizeof(buf), procf))
2659 is_ide = (!strncmp(buf, "cdrom", 5) ||
2660 !strncmp(buf, "tape", 4));
2662 /* Now when this proc file does not exist, skip the
2663 device when it is read-only. */
2664 if (stat(device, &statbuf) == 0)
2665 is_ide = ((statbuf.st_mode & 0222) == 0);
2674 trydev(const char *device, int user_specified)
2678 disk_device = device;
2679 if (setjmp(listingbuf))
2681 if (!user_specified)
2682 if (is_ide_cdrom_or_tape(device))
2684 fd = open(disk_device, type_open);
2686 gb = get_boot(try_only);
2687 if (gb > 0) { /* I/O error */
2689 } else if (gb < 0) { /* no DOS signature */
2690 list_disk_geometry();
2694 #if ENABLE_FEATURE_OSF_LABEL
2695 if (bsd_trydev(device) < 0)
2697 printf("Disk %s doesn't contain a valid "
2698 "partition table\n", device);
2703 #if ENABLE_FEATURE_FDISK_WRITABLE
2704 if (!LABEL_IS_SUN && g_partitions > 4){
2705 delete_partition(ext_index);
2710 /* Ignore other errors, since we try IDE
2711 and SCSI hard disks which may not be
2712 installed on the system. */
2713 if (errno == EACCES) {
2714 printf("Cannot open %s\n", device);
2720 /* for fdisk -l: try all things in /proc/partitions
2721 that look like a partition name (do not end in a digit) */
2726 char line[100], ptname[100], devname[120], *s;
2729 procpt = fopen_or_warn("/proc/partitions", "r");
2731 while (fgets(line, sizeof(line), procpt)) {
2732 if (sscanf(line, " %d %d %d %[^\n ]",
2733 &ma, &mi, &sz, ptname) != 4)
2735 for (s = ptname; *s; s++);
2738 sprintf(devname, "/dev/%s", ptname);
2741 #if ENABLE_FEATURE_CLEAN_UP
2746 #if ENABLE_FEATURE_FDISK_WRITABLE
2748 unknown_command(int c)
2750 printf("%c: unknown command\n", c);
2754 int fdisk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
2755 int fdisk_main(int argc, char **argv)
2760 * fdisk -l [-b sectorsize] [-u] device ...
2761 * fdisk -s [partition] ...
2762 * fdisk [-b sectorsize] [-u] device
2764 * Options -C, -H, -S set the geometry.
2773 OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
2778 opt_complementary = "b+:C+:H+:S+"; /* numeric params */
2779 opt = getopt32(argv, "b:C:H:lS:u" USE_FEATURE_FDISK_BLKSIZE("s"),
2780 §or_size, &user_cylinders, &user_heads, &user_sectors);
2783 if (opt & OPT_b) { // -b
2784 /* Ugly: this sector size is really per device,
2785 so cannot be combined with multiple disks,
2786 and the same goes for the C/H/S options.
2788 if (sector_size != 512 && sector_size != 1024
2789 && sector_size != 2048)
2792 user_set_sector_size = 1;
2794 if (user_heads <= 0 || user_heads >= 256)
2796 if (user_sectors <= 0 || user_sectors >= 64)
2799 display_in_cyl_units = 0; // -u
2801 if (user_set_sector_size && argc != 1)
2802 printf("Warning: the -b (set sector size) option should"
2803 " be used with one specified device\n");
2805 #if ENABLE_FEATURE_FDISK_WRITABLE
2809 type_open = O_RDONLY;
2812 #if defined(__GNUC__)
2813 /* avoid gcc warning:
2814 variable `k' might be clobbered by `longjmp' */
2818 for (k = 0; k < argc; k++)
2821 /* we no longer have default device names */
2822 /* but, we can use /proc/partitions instead */
2826 #if ENABLE_FEATURE_FDISK_WRITABLE
2830 #if ENABLE_FEATURE_FDISK_BLKSIZE
2836 type_open = O_RDONLY;
2841 for (j = 0; j < argc; j++) {
2842 disk_device = argv[j];
2843 fd = open(disk_device, type_open);
2845 fdisk_fatal(unable_to_open);
2846 if (ioctl(fd, BLKGETSIZE, &size))
2847 fdisk_fatal(ioctl_error);
2850 printf("%ld\n", size/2);
2852 printf("%s: %ld\n", argv[j], size/2);
2858 #if ENABLE_FEATURE_FDISK_WRITABLE
2862 disk_device = argv[0];
2866 /* OSF label, and no DOS label */
2867 printf("Detected an OSF/1 disklabel on %s, entering "
2868 "disklabel mode\n", disk_device);
2870 /*Why do we do this? It seems to be counter-intuitive*/
2871 current_label_type = label_dos;
2872 /* If we return we may want to make an empty DOS label? */
2878 c = tolower(read_nonempty("Command (m for help): "));
2882 toggle_active(get_partition(1, g_partitions));
2883 else if (LABEL_IS_SUN)
2884 toggle_sunflags(get_partition(1, g_partitions),
2886 else if (LABEL_IS_SGI)
2887 sgi_set_bootpartition(
2888 get_partition(1, g_partitions));
2894 printf("\nThe current boot file is: %s\n",
2895 sgi_get_bootfile());
2896 if (read_maybe_empty("Please enter the name of the "
2897 "new boot file: ") == '\n')
2898 printf("Boot file unchanged\n");
2900 sgi_set_bootfile(line_ptr);
2902 #if ENABLE_FEATURE_OSF_LABEL
2909 toggle_dos_compatibility_flag();
2910 else if (LABEL_IS_SUN)
2911 toggle_sunflags(get_partition(1, g_partitions),
2913 else if (LABEL_IS_SGI)
2914 sgi_set_swappartition(
2915 get_partition(1, g_partitions));
2922 /* If sgi_label then don't use get_existing_partition,
2923 let the user select a partition, since
2924 get_existing_partition() only works for Linux-like
2926 if (!LABEL_IS_SGI) {
2927 j = get_existing_partition(1, g_partitions);
2929 j = get_partition(1, g_partitions);
2932 delete_partition(j);
2941 list_types(get_sys_types());
2960 #if ENABLE_FEATURE_SUN_LABEL
2974 write_table(); /* does not return */
2976 #if ENABLE_FEATURE_FDISK_ADVANCED
2979 printf("\n\tSorry, no experts menu for SGI "
2980 "partition tables available\n\n");
2991 #endif /* FEATURE_FDISK_WRITABLE */