1 /* vi: set sw=4 ts=4: */
3 * fdisk.c -- Partition table manipulator for Linux.
5 * Copyright (C) 1992 A. V. Le Blanc (LeBlanc@mcc.ac.uk)
6 * Copyright (C) 2001,2002 Vladimir Oleynik <dzo@simtreas.ru> (initial bb port)
8 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
11 //config: bool "fdisk (41 kb)"
13 //config: select PLATFORM_LINUX
15 //config: The fdisk utility is used to divide hard disks into one or more
16 //config: logical disks, which are generally called partitions. This utility
17 //config: can be used to list and edit the set of partitions or BSD style
18 //config: 'disk slices' that are defined on a hard drive.
20 //config:config FDISK_SUPPORT_LARGE_DISKS
21 //config: bool "Support over 4GB disks"
23 //config: depends on FDISK
24 //config: depends on !LFS # with LFS no special code is needed
26 //config:config FEATURE_FDISK_WRITABLE
27 //config: bool "Write support"
29 //config: depends on FDISK
31 //config: Enabling this option allows you to create or change a partition table
32 //config: and write those changes out to disk. If you leave this option
33 //config: disabled, you will only be able to view the partition table.
35 //config:config FEATURE_AIX_LABEL
36 //config: bool "Support AIX disklabels"
38 //config: depends on FDISK && FEATURE_FDISK_WRITABLE
40 //config: Enabling this option allows you to create or change AIX disklabels.
41 //config: Most people can safely leave this option disabled.
43 //config:config FEATURE_SGI_LABEL
44 //config: bool "Support SGI disklabels"
46 //config: depends on FDISK && FEATURE_FDISK_WRITABLE
48 //config: Enabling this option allows you to create or change SGI disklabels.
49 //config: Most people can safely leave this option disabled.
51 //config:config FEATURE_SUN_LABEL
52 //config: bool "Support SUN disklabels"
54 //config: depends on FDISK && FEATURE_FDISK_WRITABLE
56 //config: Enabling this option allows you to create or change SUN disklabels.
57 //config: Most people can safely leave this option disabled.
59 //config:config FEATURE_OSF_LABEL
60 //config: bool "Support BSD disklabels"
62 //config: depends on FDISK && FEATURE_FDISK_WRITABLE
64 //config: Enabling this option allows you to create or change BSD disklabels
65 //config: and define and edit BSD disk slices.
67 //config:config FEATURE_GPT_LABEL
68 //config: bool "Support GPT disklabels"
70 //config: depends on FDISK && FEATURE_FDISK_WRITABLE
72 //config: Enabling this option allows you to view GUID Partition Table
75 //config:config FEATURE_FDISK_ADVANCED
76 //config: bool "Support expert mode"
78 //config: depends on FDISK && FEATURE_FDISK_WRITABLE
80 //config: Enabling this option allows you to do terribly unsafe things like
81 //config: define arbitrary drive geometry, move the beginning of data in a
82 //config: partition, and similarly evil things. Unless you have a very good
83 //config: reason you would be wise to leave this disabled.
85 //applet:IF_FDISK(APPLET(fdisk, BB_DIR_SBIN, BB_SUID_DROP))
87 //kbuild:lib-$(CONFIG_FDISK) += fdisk.o
89 /* Looks like someone forgot to add this to config system */
90 //usage:#ifndef ENABLE_FEATURE_FDISK_BLKSIZE
91 //usage:# define ENABLE_FEATURE_FDISK_BLKSIZE 0
92 //usage:# define IF_FEATURE_FDISK_BLKSIZE(a)
95 //usage:#define fdisk_trivial_usage
96 //usage: "[-ul" IF_FEATURE_FDISK_BLKSIZE("s") "] "
97 //usage: "[-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SSZ] DISK"
98 //usage:#define fdisk_full_usage "\n\n"
99 //usage: "Change partition table\n"
100 //usage: "\n -u Start and End are in sectors (instead of cylinders)"
101 //usage: "\n -l Show partition table for each DISK, then exit"
102 //usage: IF_FEATURE_FDISK_BLKSIZE(
103 //usage: "\n -s Show partition sizes in kb for each DISK, then exit"
105 //usage: "\n -b 2048 (for certain MO disks) use 2048-byte sectors"
106 //usage: "\n -C CYLINDERS Set number of cylinders/heads/sectors"
107 //usage: "\n -H HEADS Typically 255"
108 //usage: "\n -S SECTORS Typically 63"
110 #ifndef _LARGEFILE64_SOURCE
112 # define _LARGEFILE64_SOURCE
114 #include <assert.h> /* assert */
115 #include <sys/mount.h>
116 #if !defined(BLKSSZGET)
117 # define BLKSSZGET _IO(0x12, 104)
119 #if !defined(BLKGETSIZE64)
120 # define BLKGETSIZE64 _IOR(0x12,114,size_t)
126 # define inline_if_little_endian ALWAYS_INLINE
128 # define inline_if_little_endian /* nothing */
132 /* Looks like someone forgot to add this to config system */
133 #ifndef ENABLE_FEATURE_FDISK_BLKSIZE
134 # define ENABLE_FEATURE_FDISK_BLKSIZE 0
135 # define IF_FEATURE_FDISK_BLKSIZE(a)
138 #define DEFAULT_SECTOR_SIZE 512
139 #define DEFAULT_SECTOR_SIZE_STR "512"
140 #define MAX_SECTOR_SIZE 2048
141 #define SECTOR_SIZE 512 /* still used in osf/sgi/sun code */
142 #define MAXIMUM_PARTS 60
144 #define ACTIVE_FLAG 0x80
146 #define EXTENDED 0x05
147 #define WIN98_EXTENDED 0x0f
148 #define LINUX_PARTITION 0x81
149 #define LINUX_SWAP 0x82
150 #define LINUX_NATIVE 0x83
151 #define LINUX_EXTENDED 0x85
152 #define LINUX_LVM 0x8e
153 #define LINUX_RAID 0xfd
163 OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
167 typedef unsigned long long ullong;
168 /* Used for sector numbers. Partition formats we know
169 * do not support more than 2^32 sectors
171 typedef uint32_t sector_t;
172 #if UINT_MAX == 0xffffffff
174 #elif ULONG_MAX == 0xffffffff
175 # define SECT_FMT "l"
177 # error Cant detect sizeof(uint32_t)
182 unsigned char sectors;
183 unsigned short cylinders;
187 #define HDIO_GETGEO 0x0301 /* get device geometry */
189 /* TODO: #if ENABLE_FEATURE_FDISK_WRITABLE */
190 /* (currently fdisk_sun/sgi.c do not have proper WRITABLE #ifs) */
191 static const char msg_building_new_label[] ALIGN1 =
192 "Building a new %s. Changes will remain in memory only,\n"
193 "until you decide to write them. After that the previous content\n"
194 "won't be recoverable.\n\n";
196 static const char msg_part_already_defined[] ALIGN1 =
197 "Partition %u is already defined, delete it before re-adding\n";
202 unsigned char boot_ind; /* 0x80 - active */
203 unsigned char head; /* starting head */
204 unsigned char sector; /* starting sector */
205 unsigned char cyl; /* starting cylinder */
206 unsigned char sys_ind; /* what partition type */
207 unsigned char end_head; /* end head */
208 unsigned char end_sector; /* end sector */
209 unsigned char end_cyl; /* end cylinder */
210 unsigned char start4[4]; /* starting sector counting from 0 */
211 unsigned char size4[4]; /* nr of sectors in partition */
215 * per partition table entry data
217 * The four primary partitions have the same sectorbuffer (MBRbuffer)
218 * and have NULL ext_pointer.
219 * Each logical partition table entry has two pointers, one for the
220 * partition and one link to the next one.
223 struct partition *part_table; /* points into sectorbuffer */
224 struct partition *ext_pointer; /* points into sectorbuffer */
225 sector_t offset_from_dev_start; /* disk sector number */
226 char *sectorbuffer; /* disk sector contents */
227 #if ENABLE_FEATURE_FDISK_WRITABLE
228 char changed; /* boolean */
232 #define unable_to_open "can't open '%s'"
233 #define unable_to_read "can't read from %s"
234 #define unable_to_seek "can't seek on %s"
237 LABEL_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF, LABEL_GPT
240 #define LABEL_IS_DOS (LABEL_DOS == current_label_type)
242 #if ENABLE_FEATURE_SUN_LABEL
243 #define LABEL_IS_SUN (LABEL_SUN == current_label_type)
244 #define STATIC_SUN static
246 #define LABEL_IS_SUN 0
247 #define STATIC_SUN extern
250 #if ENABLE_FEATURE_SGI_LABEL
251 #define LABEL_IS_SGI (LABEL_SGI == current_label_type)
252 #define STATIC_SGI static
254 #define LABEL_IS_SGI 0
255 #define STATIC_SGI extern
258 #if ENABLE_FEATURE_AIX_LABEL
259 #define LABEL_IS_AIX (LABEL_AIX == current_label_type)
260 #define STATIC_AIX static
262 #define LABEL_IS_AIX 0
263 #define STATIC_AIX extern
266 #if ENABLE_FEATURE_OSF_LABEL
267 #define LABEL_IS_OSF (LABEL_OSF == current_label_type)
268 #define STATIC_OSF static
270 #define LABEL_IS_OSF 0
271 #define STATIC_OSF extern
274 #if ENABLE_FEATURE_GPT_LABEL
275 #define LABEL_IS_GPT (LABEL_GPT == current_label_type)
276 #define STATIC_GPT static
278 #define LABEL_IS_GPT 0
279 #define STATIC_GPT extern
282 enum action { OPEN_MAIN, TRY_ONLY, CREATE_EMPTY_DOS, CREATE_EMPTY_SUN };
284 static void update_units(void);
285 #if ENABLE_FEATURE_FDISK_WRITABLE
286 static void change_units(void);
287 static void reread_partition_table(int leave);
288 static void delete_partition(int i);
289 static unsigned get_partition(int warn, unsigned max);
290 static void list_types(const char *const *sys);
291 static sector_t read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg);
293 static const char *partition_type(unsigned char type);
294 static void get_geometry(void);
295 static void read_pte(struct pte *pe, sector_t offset);
296 #if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
297 static int get_boot(enum action what);
299 static int get_boot(void);
305 static sector_t get_start_sect(const struct partition *p);
306 static sector_t get_nr_sects(const struct partition *p);
308 /* DOS partition types */
310 static const char *const i386_sys_types[] = {
314 "\x05" "Extended", /* DOS 3.3+ extended partition */
315 "\x06" "FAT16", /* DOS 16-bit >=32M */
316 "\x07" "HPFS/NTFS", /* OS/2 IFS, eg, HPFS or NTFS or QNX */
317 "\x0a" "OS/2 Boot Manager",/* OS/2 Boot Manager */
318 "\x0b" "Win95 FAT32",
319 "\x0c" "Win95 FAT32 (LBA)",/* LBA really is 'Extended Int 13h' */
320 "\x0e" "Win95 FAT16 (LBA)",
321 "\x0f" "Win95 Ext'd (LBA)",
322 "\x11" "Hidden FAT12",
323 "\x12" "Compaq diagnostics",
324 "\x14" "Hidden FAT16 <32M",
325 "\x16" "Hidden FAT16",
326 "\x17" "Hidden HPFS/NTFS",
327 "\x1b" "Hidden Win95 FAT32",
328 "\x1c" "Hidden W95 FAT32 (LBA)",
329 "\x1e" "Hidden W95 FAT16 (LBA)",
330 "\x3c" "Part.Magic recovery",
331 "\x41" "PPC PReP Boot",
333 "\x63" "GNU HURD or SysV", /* GNU HURD or Mach or Sys V/386 (such as ISC UNIX) */
334 "\x80" "Old Minix", /* Minix 1.4a and earlier */
335 "\x81" "Minix / old Linux",/* Minix 1.4b and later */
336 "\x82" "Linux swap", /* also Solaris */
338 "\x84" "OS/2 hidden C: drive",
339 "\x85" "Linux extended",
340 "\x86" "NTFS volume set",
341 "\x87" "NTFS volume set",
343 "\x9f" "BSD/OS", /* BSDI */
344 "\xa0" "Thinkpad hibernation",
345 "\xa5" "FreeBSD", /* various BSD flavours */
349 "\xab" "Darwin boot",
352 "\xbe" "Solaris boot",
354 "\xee" "EFI GPT", /* Intel EFI GUID Partition Table */
355 "\xef" "EFI (FAT-12/16/32)", /* Intel EFI System Partition */
356 "\xf0" "Linux/PA-RISC boot", /* Linux/PA-RISC boot loader */
357 "\xf2" "DOS secondary", /* DOS 3.3+ secondary */
358 "\xfd" "Linux raid autodetect", /* New (2.2.x) raid partition with
359 autodetect using persistent
361 #if 0 /* ENABLE_WEIRD_PARTITION_TYPES */
364 "\x08" "AIX", /* AIX boot (AIX -- PS/2 port) or SplitDrive */
365 "\x09" "AIX bootable", /* AIX data or Coherent */
367 "\x18" "AST SmartSleep",
370 "\x40" "Venix 80286",
372 "\x4e" "QNX4.x 2nd part",
373 "\x4f" "QNX4.x 3rd part",
375 "\x51" "OnTrack DM6 Aux1", /* (or Novell) */
376 "\x52" "CP/M", /* CP/M or Microport SysV/AT */
377 "\x53" "OnTrack DM6 Aux3",
381 "\x5c" "Priam Edisk",
383 "\x64" "Novell Netware 286",
384 "\x65" "Novell Netware 386",
385 "\x70" "DiskSecure Multi-Boot",
388 "\x94" "Amoeba BBT", /* (bad block table) */
390 "\xbb" "Boot Wizard hidden",
391 "\xc1" "DRDOS/sec (FAT-12)",
392 "\xc4" "DRDOS/sec (FAT-16 < 32M)",
393 "\xc6" "DRDOS/sec (FAT-16)",
395 "\xda" "Non-FS data",
396 "\xdb" "CP/M / CTOS / ...",/* CP/M or Concurrent CP/M or
397 Concurrent DOS or CTOS */
398 "\xde" "Dell Utility", /* Dell PowerEdge Server utilities */
399 "\xdf" "BootIt", /* BootIt EMBRM */
400 "\xe1" "DOS access", /* DOS access or SpeedStor 12-bit FAT
401 extended partition */
402 "\xe3" "DOS R/O", /* DOS R/O or SpeedStor */
403 "\xe4" "SpeedStor", /* SpeedStor 16-bit FAT extended
404 partition < 1024 cyl. */
406 "\xf4" "SpeedStor", /* SpeedStor large partition */
407 "\xfe" "LANstep", /* SpeedStor >1024 cyl. or LANstep */
408 "\xff" "BBT", /* Xenix Bad Block Table */
414 dev_fd = 3 /* the disk */
421 const char *disk_device;
422 int g_partitions; // = 4; /* maximum partition + 1 */
423 unsigned units_per_sector; // = 1;
424 unsigned sector_size; // = DEFAULT_SECTOR_SIZE;
425 unsigned user_set_sector_size;
426 unsigned sector_offset; // = 1;
427 unsigned g_heads, g_sectors, g_cylinders;
428 smallint /* enum label_type */ current_label_type;
429 smallint display_in_cyl_units;
430 #if ENABLE_FEATURE_OSF_LABEL
431 smallint possibly_osf_label;
434 smallint listing; /* no aborts for fdisk -l */
435 smallint dos_compatible_flag; // = 1;
436 #if ENABLE_FEATURE_FDISK_WRITABLE
438 smallint nowarn; /* no warnings for fdisk -l/-s */
440 int ext_index; /* the prime extended partition */
441 unsigned user_cylinders, user_heads, user_sectors;
442 unsigned pt_heads, pt_sectors;
443 unsigned kern_heads, kern_sectors;
444 sector_t extended_offset; /* offset of link pointers */
445 sector_t total_number_of_sectors;
448 char line_buffer[80];
449 /* Raw disk label. For DOS-type partition tables the MBR,
450 * with descriptions of the primary partitions. */
451 char MBRbuffer[MAX_SECTOR_SIZE];
452 /* Partition tables */
453 struct pte ptes[MAXIMUM_PARTS];
455 #define G (*ptr_to_globals)
456 #define line_ptr (G.line_ptr )
457 #define disk_device (G.disk_device )
458 #define g_partitions (G.g_partitions )
459 #define units_per_sector (G.units_per_sector )
460 #define sector_size (G.sector_size )
461 #define user_set_sector_size (G.user_set_sector_size)
462 #define sector_offset (G.sector_offset )
463 #define g_heads (G.g_heads )
464 #define g_sectors (G.g_sectors )
465 #define g_cylinders (G.g_cylinders )
466 #define current_label_type (G.current_label_type )
467 #define display_in_cyl_units (G.display_in_cyl_units)
468 #define possibly_osf_label (G.possibly_osf_label )
469 #define listing (G.listing )
470 #define dos_compatible_flag (G.dos_compatible_flag )
471 #define nowarn (G.nowarn )
472 #define ext_index (G.ext_index )
473 #define user_cylinders (G.user_cylinders )
474 #define user_heads (G.user_heads )
475 #define user_sectors (G.user_sectors )
476 #define pt_heads (G.pt_heads )
477 #define pt_sectors (G.pt_sectors )
478 #define kern_heads (G.kern_heads )
479 #define kern_sectors (G.kern_sectors )
480 #define extended_offset (G.extended_offset )
481 #define total_number_of_sectors (G.total_number_of_sectors)
482 #define listingbuf (G.listingbuf )
483 #define line_buffer (G.line_buffer )
484 #define MBRbuffer (G.MBRbuffer )
485 #define ptes (G.ptes )
486 #define INIT_G() do { \
487 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
488 sector_size = DEFAULT_SECTOR_SIZE; \
491 units_per_sector = 1; \
492 dos_compatible_flag = 1; \
496 /* TODO: move to libbb? */
497 /* TODO: return unsigned long long, FEATURE_FDISK_BLKSIZE _can_ handle
498 * disks > 2^32 sectors
500 static sector_t bb_BLKGETSIZE_sectors(int fd)
503 unsigned long longsectors;
505 if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
506 /* Got bytes, convert to 512 byte sectors */
508 if (v64 != (sector_t)v64) {
510 /* Not only DOS, but all other partition tables
511 * we support can't record more than 32 bit
512 * sector counts or offsets
514 bb_error_msg("device has more than 2^32 sectors, can't use all of them");
519 /* Needs temp of type long */
520 if (ioctl(fd, BLKGETSIZE, &longsectors)) {
521 /* Perhaps this is a disk image */
522 off_t sz = lseek(fd, 0, SEEK_END);
525 longsectors = (uoff_t)sz / sector_size;
526 lseek(fd, 0, SEEK_SET);
528 if (sizeof(long) > sizeof(sector_t)
529 && longsectors != (sector_t)longsectors
537 #define IS_EXTENDED(i) \
538 ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
540 #define cround(n) (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
542 #define scround(x) (((x)+units_per_sector-1)/units_per_sector)
544 #define pt_offset(b, n) \
545 ((struct partition *)((b) + 0x1be + (n) * sizeof(struct partition)))
547 #define sector(s) ((s) & 0x3f)
549 #define cylinder(s, c) ((c) | (((s) & 0xc0) << 2))
554 /* Not really closing, but making sure it is open, and to harmless place */
555 xmove_fd(xopen(bb_dev_null, O_RDONLY), dev_fd);
558 /* Return partition name */
560 partname(const char *dev, int pno, int lth)
567 bufp = auto_string(xzalloc(80));
573 if (isdigit(dev[w-1]))
576 /* devfs kludge - note: fdisk partition names are not supposed
577 to equal kernel names, so there is no reason to do this */
578 if (strcmp(dev + w - 4, "disc") == 0) {
586 snprintf(bufp, bufsiz, "%*.*s%s%-2u",
587 lth-wp-2, w, dev, p, pno);
589 snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
594 static ALWAYS_INLINE struct partition *
595 get_part_table(int i)
597 return ptes[i].part_table;
602 { /* n==1: use singular */
604 return display_in_cyl_units ? "cylinder" : "sector";
605 return display_in_cyl_units ? "cylinders" : "sectors";
609 valid_part_table_flag(const char *mbuffer)
611 return (mbuffer[510] == 0x55 && (uint8_t)mbuffer[511] == 0xaa);
614 static void fdisk_fatal(const char *why)
618 longjmp(listingbuf, 1);
620 bb_error_msg_and_die(why, disk_device);
624 seek_sector(sector_t secno)
626 #if ENABLE_FDISK_SUPPORT_LARGE_DISKS
627 off64_t off = (off64_t)secno * sector_size;
628 if (lseek64(dev_fd, off, SEEK_SET) == (off64_t) -1)
629 fdisk_fatal(unable_to_seek);
631 uint64_t off = (uint64_t)secno * sector_size;
632 if (off > MAXINT(off_t)
633 || lseek(dev_fd, (off_t)off, SEEK_SET) == (off_t) -1
635 fdisk_fatal(unable_to_seek);
640 #if ENABLE_FEATURE_FDISK_WRITABLE
642 set_all_unchanged(void)
646 for (i = 0; i < MAXIMUM_PARTS; i++)
650 static ALWAYS_INLINE void
656 static ALWAYS_INLINE void
657 write_part_table_flag(char *b)
663 /* Read line; return 0 or first printable non-space char */
665 read_line(const char *prompt)
669 sz = read_line_input(NULL, prompt, line_buffer, sizeof(line_buffer));
671 exit(EXIT_SUCCESS); /* Ctrl-D or Ctrl-C */
673 if (line_buffer[sz-1] == '\n')
674 line_buffer[--sz] = '\0';
676 line_ptr = line_buffer;
677 while (*line_ptr != '\0' && (unsigned char)*line_ptr <= ' ')
683 read_nonempty(const char *mesg)
685 while (!read_line(mesg))
691 read_maybe_empty(const char *mesg)
693 if (!read_line(mesg)) {
694 line_ptr = line_buffer;
702 read_hex(const char *const *sys)
706 read_nonempty("Hex code (type L to list codes): ");
707 if ((line_ptr[0] | 0x20) == 'l') {
711 v = bb_strtoul(line_ptr, NULL, 16);
718 write_sector(sector_t secno, const void *buf)
721 xwrite(dev_fd, buf, sector_size);
723 #endif /* FEATURE_FDISK_WRITABLE */
726 #include "fdisk_aix.c"
728 struct sun_partition {
729 unsigned char info[128]; /* Informative text string */
730 unsigned char spare0[14];
732 unsigned char spare1;
734 unsigned char spare2;
737 unsigned char spare1[246]; /* Boot information etc. */
738 unsigned short rspeed; /* Disk rotational speed */
739 unsigned short pcylcount; /* Physical cylinder count */
740 unsigned short sparecyl; /* extra sects per cylinder */
741 unsigned char spare2[4]; /* More magic... */
742 unsigned short ilfact; /* Interleave factor */
743 unsigned short ncyl; /* Data cylinder count */
744 unsigned short nacyl; /* Alt. cylinder count */
745 unsigned short ntrks; /* Tracks per cylinder */
746 unsigned short nsect; /* Sectors per track */
747 unsigned char spare3[4]; /* Even more magic... */
748 struct sun_partinfo {
749 uint32_t start_cylinder;
750 uint32_t num_sectors;
752 unsigned short magic; /* Magic number */
753 unsigned short csum; /* Label xor'd checksum */
755 typedef struct sun_partition sun_partition;
756 #define sunlabel ((sun_partition *)MBRbuffer)
757 STATIC_OSF void bsd_select(void);
758 STATIC_OSF void xbsd_print_disklabel(int);
759 #include "fdisk_osf.c"
761 STATIC_GPT void gpt_list_table(int xtra);
762 #include "fdisk_gpt.c"
764 #if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL
766 fdisk_swap16(uint16_t x)
768 return (x << 8) | (x >> 8);
772 fdisk_swap32(uint32_t x)
775 ((x & 0xFF00) << 8) |
776 ((x & 0xFF0000) >> 8) |
781 STATIC_SGI const char *const sgi_sys_types[];
782 STATIC_SGI unsigned sgi_get_num_sectors(int i);
783 STATIC_SGI int sgi_get_sysid(int i);
784 STATIC_SGI void sgi_delete_partition(int i);
785 STATIC_SGI void sgi_change_sysid(int i, int sys);
786 STATIC_SGI void sgi_list_table(int xtra);
787 #if ENABLE_FEATURE_FDISK_ADVANCED
788 STATIC_SGI void sgi_set_xcyl(void);
790 STATIC_SGI int verify_sgi(int verbose);
791 STATIC_SGI void sgi_add_partition(int n, int sys);
792 STATIC_SGI void sgi_set_swappartition(int i);
793 STATIC_SGI const char *sgi_get_bootfile(void);
794 STATIC_SGI void sgi_set_bootfile(const char* aFile);
795 STATIC_SGI void create_sgiinfo(void);
796 STATIC_SGI void sgi_write_table(void);
797 STATIC_SGI void sgi_set_bootpartition(int i);
798 #include "fdisk_sgi.c"
800 STATIC_SUN const char *const sun_sys_types[];
801 STATIC_SUN void sun_delete_partition(int i);
802 STATIC_SUN void sun_change_sysid(int i, int sys);
803 STATIC_SUN void sun_list_table(int xtra);
804 STATIC_SUN void add_sun_partition(int n, int sys);
805 #if ENABLE_FEATURE_FDISK_ADVANCED
806 STATIC_SUN void sun_set_alt_cyl(void);
807 STATIC_SUN void sun_set_ncyl(int cyl);
808 STATIC_SUN void sun_set_xcyl(void);
809 STATIC_SUN void sun_set_ilfact(void);
810 STATIC_SUN void sun_set_rspeed(void);
811 STATIC_SUN void sun_set_pcylcount(void);
813 STATIC_SUN void toggle_sunflags(int i, unsigned char mask);
814 STATIC_SUN void verify_sun(void);
815 STATIC_SUN void sun_write_table(void);
816 #include "fdisk_sun.c"
819 static inline_if_little_endian unsigned
820 read4_little_endian(const unsigned char *cp)
823 move_from_unaligned32(v, cp);
828 get_start_sect(const struct partition *p)
830 return read4_little_endian(p->start4);
834 get_nr_sects(const struct partition *p)
836 return read4_little_endian(p->size4);
839 #if ENABLE_FEATURE_FDISK_WRITABLE
840 /* start_sect and nr_sects are stored little endian on all machines */
841 /* moreover, they are not aligned correctly */
842 static inline_if_little_endian void
843 store4_little_endian(unsigned char *cp, unsigned val)
845 uint32_t v = SWAP_LE32(val);
846 move_to_unaligned32(cp, v);
850 set_start_sect(struct partition *p, unsigned start_sect)
852 store4_little_endian(p->start4, start_sect);
856 set_nr_sects(struct partition *p, unsigned nr_sects)
858 store4_little_endian(p->size4, nr_sects);
862 /* Allocate a buffer and read a partition table sector */
864 read_pte(struct pte *pe, sector_t offset)
866 pe->offset_from_dev_start = offset;
867 pe->sectorbuffer = xzalloc(sector_size);
869 /* xread would make us abort - bad for fdisk -l */
870 if (full_read(dev_fd, pe->sectorbuffer, sector_size) != sector_size)
871 fdisk_fatal(unable_to_read);
872 #if ENABLE_FEATURE_FDISK_WRITABLE
875 pe->part_table = pe->ext_pointer = NULL;
879 get_partition_start_from_dev_start(const struct pte *pe)
881 return pe->offset_from_dev_start + get_start_sect(pe->part_table);
884 #if ENABLE_FEATURE_FDISK_WRITABLE
886 * Avoid warning about DOS partitions when no DOS partition was changed.
887 * Here a heuristic "is probably dos partition".
888 * We might also do the opposite and warn in all cases except
889 * for "is probably nondos partition".
893 is_dos_partition(int t)
895 return (t == 1 || t == 4 || t == 6 ||
896 t == 0x0b || t == 0x0c || t == 0x0e ||
897 t == 0x11 || t == 0x12 || t == 0x14 || t == 0x16 ||
898 t == 0x1b || t == 0x1c || t == 0x1e || t == 0x24 ||
899 t == 0xc1 || t == 0xc4 || t == 0xc6);
906 puts("Command Action");
908 puts("a\ttoggle a read only flag"); /* sun */
909 puts("b\tedit bsd disklabel");
910 puts("c\ttoggle the mountable flag"); /* sun */
911 puts("d\tdelete a partition");
912 puts("l\tlist known partition types");
913 puts("n\tadd a new partition");
914 puts("o\tcreate a new empty DOS partition table");
915 puts("p\tprint the partition table");
916 puts("q\tquit without saving changes");
917 puts("s\tcreate a new empty Sun disklabel"); /* sun */
918 puts("t\tchange a partition's system id");
919 puts("u\tchange display/entry units");
920 puts("v\tverify the partition table");
921 puts("w\twrite table to disk and exit");
922 #if ENABLE_FEATURE_FDISK_ADVANCED
923 puts("x\textra functionality (experts only)");
925 } else if (LABEL_IS_SGI) {
926 puts("a\tselect bootable partition"); /* sgi flavour */
927 puts("b\tedit bootfile entry"); /* sgi */
928 puts("c\tselect sgi swap partition"); /* sgi flavour */
929 puts("d\tdelete a partition");
930 puts("l\tlist known partition types");
931 puts("n\tadd a new partition");
932 puts("o\tcreate a new empty DOS partition table");
933 puts("p\tprint the partition table");
934 puts("q\tquit without saving changes");
935 puts("s\tcreate a new empty Sun disklabel"); /* sun */
936 puts("t\tchange a partition's system id");
937 puts("u\tchange display/entry units");
938 puts("v\tverify the partition table");
939 puts("w\twrite table to disk and exit");
940 } else if (LABEL_IS_AIX) {
941 puts("o\tcreate a new empty DOS partition table");
942 puts("q\tquit without saving changes");
943 puts("s\tcreate a new empty Sun disklabel"); /* sun */
944 } else if (LABEL_IS_GPT) {
945 puts("o\tcreate a new empty DOS partition table");
946 puts("p\tprint the partition table");
947 puts("q\tquit without saving changes");
948 puts("s\tcreate a new empty Sun disklabel"); /* sun */
950 puts("a\ttoggle a bootable flag");
951 puts("b\tedit bsd disklabel");
952 puts("c\ttoggle the dos compatibility flag");
953 puts("d\tdelete a partition");
954 puts("l\tlist known partition types");
955 puts("n\tadd a new partition");
956 puts("o\tcreate a new empty DOS partition table");
957 puts("p\tprint the partition table");
958 puts("q\tquit without saving changes");
959 puts("s\tcreate a new empty Sun disklabel"); /* sun */
960 puts("t\tchange a partition's system id");
961 puts("u\tchange display/entry units");
962 puts("v\tverify the partition table");
963 puts("w\twrite table to disk and exit");
964 #if ENABLE_FEATURE_FDISK_ADVANCED
965 puts("x\textra functionality (experts only)");
969 #endif /* FEATURE_FDISK_WRITABLE */
972 #if ENABLE_FEATURE_FDISK_ADVANCED
976 puts("Command Action");
978 puts("a\tchange number of alternate cylinders"); /*sun*/
979 puts("c\tchange number of cylinders");
980 puts("d\tprint the raw data in the partition table");
981 puts("e\tchange number of extra sectors per cylinder");/*sun*/
982 puts("h\tchange number of heads");
983 puts("i\tchange interleave factor"); /*sun*/
984 puts("o\tchange rotation speed (rpm)"); /*sun*/
985 puts("p\tprint the partition table");
986 puts("q\tquit without saving changes");
987 puts("r\treturn to main menu");
988 puts("s\tchange number of sectors/track");
989 puts("v\tverify the partition table");
990 puts("w\twrite table to disk and exit");
991 puts("y\tchange number of physical cylinders"); /*sun*/
992 } else if (LABEL_IS_SGI) {
993 puts("b\tmove beginning of data in a partition"); /* !sun */
994 puts("c\tchange number of cylinders");
995 puts("d\tprint the raw data in the partition table");
996 puts("e\tlist extended partitions"); /* !sun */
997 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
998 puts("h\tchange number of heads");
999 puts("p\tprint the partition table");
1000 puts("q\tquit without saving changes");
1001 puts("r\treturn to main menu");
1002 puts("s\tchange number of sectors/track");
1003 puts("v\tverify the partition table");
1004 puts("w\twrite table to disk and exit");
1005 } else if (LABEL_IS_AIX) {
1006 puts("b\tmove beginning of data in a partition"); /* !sun */
1007 puts("c\tchange number of cylinders");
1008 puts("d\tprint the raw data in the partition table");
1009 puts("e\tlist extended partitions"); /* !sun */
1010 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
1011 puts("h\tchange number of heads");
1012 puts("p\tprint the partition table");
1013 puts("q\tquit without saving changes");
1014 puts("r\treturn to main menu");
1015 puts("s\tchange number of sectors/track");
1016 puts("v\tverify the partition table");
1017 puts("w\twrite table to disk and exit");
1019 puts("b\tmove beginning of data in a partition"); /* !sun */
1020 puts("c\tchange number of cylinders");
1021 puts("d\tprint the raw data in the partition table");
1022 puts("e\tlist extended partitions"); /* !sun */
1023 puts("f\tfix partition order"); /* !sun, !aix, !sgi */
1024 #if ENABLE_FEATURE_SGI_LABEL
1025 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
1027 puts("h\tchange number of heads");
1028 puts("p\tprint the partition table");
1029 puts("q\tquit without saving changes");
1030 puts("r\treturn to main menu");
1031 puts("s\tchange number of sectors/track");
1032 puts("v\tverify the partition table");
1033 puts("w\twrite table to disk and exit");
1036 #endif /* ADVANCED mode */
1038 #if ENABLE_FEATURE_FDISK_WRITABLE
1039 static const char *const *
1043 LABEL_IS_SUN ? sun_sys_types :
1044 LABEL_IS_SGI ? sgi_sys_types :
1048 #define get_sys_types() i386_sys_types
1052 partition_type(unsigned char type)
1055 const char *const *types = get_sys_types();
1057 for (i = 0; types[i]; i++)
1058 if ((unsigned char)types[i][0] == type)
1059 return types[i] + 1;
1065 is_cleared_partition(const struct partition *p)
1067 /* We consider partition "cleared" only if it has only zeros */
1068 const char *cp = (const char *)p;
1069 int cnt = sizeof(*p);
1077 clear_partition(struct partition *p)
1080 memset(p, 0, sizeof(*p));
1083 #if ENABLE_FEATURE_FDISK_WRITABLE
1087 return LABEL_IS_SUN ? sunlabel->infos[i].id :
1088 (LABEL_IS_SGI ? sgi_get_sysid(i) :
1089 ptes[i].part_table->sys_ind);
1093 list_types(const char *const *sys)
1097 unsigned last[COLS];
1098 unsigned done, next, size;
1101 for (size = 0; sys[size]; size++)
1105 for (i = COLS-1; i >= 0; i--) {
1106 done += (size + i - done) / (i + 1);
1107 last[COLS-1 - i] = done;
1110 i = done = next = 0;
1112 printf("%c%2x %-22.22s", i ? ' ' : '\n',
1113 (unsigned char)sys[next][0],
1115 next = last[i++] + done;
1116 if (i >= COLS || next >= last[i]) {
1120 } while (done < last[0]);
1124 #define set_hsc(h, s, c, sector) do \
1126 s = sector % g_sectors + 1; \
1127 sector /= g_sectors; \
1128 h = sector % g_heads; \
1129 sector /= g_heads; \
1130 c = sector & 0xff; \
1131 s |= (sector >> 2) & 0xc0; \
1134 static void set_hsc_start_end(struct partition *p, sector_t start, sector_t stop)
1136 if (dos_compatible_flag && (start / (g_sectors * g_heads) > 1023))
1137 start = g_heads * g_sectors * 1024 - 1;
1138 set_hsc(p->head, p->sector, p->cyl, start);
1140 if (dos_compatible_flag && (stop / (g_sectors * g_heads) > 1023))
1141 stop = g_heads * g_sectors * 1024 - 1;
1142 set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
1146 set_partition(int i, int doext, sector_t start, sector_t stop, int sysid)
1148 struct partition *p;
1152 p = ptes[i].ext_pointer;
1153 offset = extended_offset;
1155 p = ptes[i].part_table;
1156 offset = ptes[i].offset_from_dev_start;
1160 set_start_sect(p, start - offset);
1161 set_nr_sects(p, stop - start + 1);
1162 set_hsc_start_end(p, start, stop);
1163 ptes[i].changed = 1;
1170 if (g_heads && g_sectors && g_cylinders)
1173 printf("Unknown value(s) for:");
1179 printf(" cylinders");
1180 #if ENABLE_FEATURE_FDISK_WRITABLE
1181 puts(" (settable in the extra functions menu)");
1191 int cyl_units = g_heads * g_sectors;
1193 if (display_in_cyl_units && cyl_units)
1194 units_per_sector = cyl_units;
1196 units_per_sector = 1; /* in sectors */
1199 #if ENABLE_FEATURE_FDISK_WRITABLE
1201 warn_cylinders(void)
1203 if (LABEL_IS_DOS && g_cylinders > 1024 && !nowarn)
1205 "The number of cylinders for this disk is set to %u.\n"
1206 "There is nothing wrong with that, but this is larger than 1024,\n"
1207 "and could in certain setups cause problems with:\n"
1208 "1) software that runs at boot time (e.g., old versions of LILO)\n"
1209 "2) booting and partitioning software from other OSs\n"
1210 " (e.g., DOS FDISK, OS/2 FDISK)\n",
1216 read_extended(int ext)
1220 struct partition *p, *q;
1224 pex->ext_pointer = pex->part_table;
1226 p = pex->part_table;
1227 if (!get_start_sect(p)) {
1228 puts("Bad offset in primary extended partition");
1232 while (IS_EXTENDED(p->sys_ind)) {
1233 struct pte *pe = &ptes[g_partitions];
1235 if (g_partitions >= MAXIMUM_PARTS) {
1236 /* This is not a Linux restriction, but
1237 this program uses arrays of size MAXIMUM_PARTS.
1238 Do not try to 'improve' this test. */
1239 struct pte *pre = &ptes[g_partitions - 1];
1240 #if ENABLE_FEATURE_FDISK_WRITABLE
1241 printf("Warning: deleting partitions after %u\n",
1245 clear_partition(pre->ext_pointer);
1249 read_pte(pe, extended_offset + get_start_sect(p));
1251 if (!extended_offset)
1252 extended_offset = get_start_sect(p);
1254 q = p = pt_offset(pe->sectorbuffer, 0);
1255 for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) {
1256 if (IS_EXTENDED(p->sys_ind)) {
1257 if (pe->ext_pointer)
1258 printf("Warning: extra link "
1259 "pointer in partition table"
1260 " %u\n", g_partitions + 1);
1262 pe->ext_pointer = p;
1263 } else if (p->sys_ind) {
1265 printf("Warning: ignoring extra "
1266 "data in partition table"
1267 " %u\n", g_partitions + 1);
1273 /* very strange code here... */
1274 if (!pe->part_table) {
1275 if (q != pe->ext_pointer)
1278 pe->part_table = q + 1;
1280 if (!pe->ext_pointer) {
1281 if (q != pe->part_table)
1282 pe->ext_pointer = q;
1284 pe->ext_pointer = q + 1;
1287 p = pe->ext_pointer;
1291 #if ENABLE_FEATURE_FDISK_WRITABLE
1292 /* remove empty links */
1294 for (i = 4; i < g_partitions; i++) {
1295 struct pte *pe = &ptes[i];
1297 if (!get_nr_sects(pe->part_table)
1298 && (g_partitions > 5 || ptes[4].part_table->sys_ind)
1300 printf("Omitting empty partition (%u)\n", i+1);
1301 delete_partition(i);
1302 goto remove; /* numbering changed */
1308 #if ENABLE_FEATURE_FDISK_WRITABLE
1310 create_doslabel(void)
1312 printf(msg_building_new_label, "DOS disklabel");
1314 current_label_type = LABEL_DOS;
1315 #if ENABLE_FEATURE_OSF_LABEL
1316 possibly_osf_label = 0;
1320 memset(&MBRbuffer[510 - 4*16], 0, 4*16);
1321 write_part_table_flag(MBRbuffer);
1322 extended_offset = 0;
1323 set_all_unchanged();
1325 get_boot(CREATE_EMPTY_DOS);
1330 get_sectorsize(void)
1332 if (!user_set_sector_size) {
1334 if (ioctl(dev_fd, BLKSSZGET, &arg) == 0)
1336 if (sector_size != DEFAULT_SECTOR_SIZE)
1337 printf("Note: sector size is %u "
1338 "(not " DEFAULT_SECTOR_SIZE_STR ")\n",
1344 get_kernel_geometry(void)
1346 struct hd_geometry geometry;
1348 if (!ioctl(dev_fd, HDIO_GETGEO, &geometry)) {
1349 kern_heads = geometry.heads;
1350 kern_sectors = geometry.sectors;
1351 /* never use geometry.cylinders - it is truncated */
1356 get_partition_table_geometry(void)
1358 const unsigned char *bufp = (const unsigned char *)MBRbuffer;
1359 struct partition *p;
1360 int i, h, s, hh, ss;
1364 if (!(valid_part_table_flag((char*)bufp)))
1368 for (i = 0; i < 4; i++) {
1369 p = pt_offset(bufp, i);
1370 if (p->sys_ind != 0) {
1371 h = p->end_head + 1;
1372 s = (p->end_sector & 077);
1377 } else if (hh != h || ss != s)
1382 if (!first && !bad) {
1394 sec_fac = sector_size / 512;
1395 #if ENABLE_FEATURE_SUN_LABEL
1396 guess_device_type();
1398 g_heads = g_cylinders = g_sectors = 0;
1399 kern_heads = kern_sectors = 0;
1400 pt_heads = pt_sectors = 0;
1402 get_kernel_geometry();
1403 get_partition_table_geometry();
1405 g_heads = user_heads ? user_heads :
1406 pt_heads ? pt_heads :
1407 kern_heads ? kern_heads : 255;
1408 g_sectors = user_sectors ? user_sectors :
1409 pt_sectors ? pt_sectors :
1410 kern_sectors ? kern_sectors : 63;
1411 total_number_of_sectors = bb_BLKGETSIZE_sectors(dev_fd);
1414 if (dos_compatible_flag)
1415 sector_offset = g_sectors;
1417 g_cylinders = total_number_of_sectors / (g_heads * g_sectors * sec_fac);
1419 g_cylinders = user_cylinders;
1423 * Opens disk_device and optionally reads MBR.
1424 * If what == OPEN_MAIN:
1425 * Open device, read MBR. Abort program on short read. Create empty
1426 * disklabel if the on-disk structure is invalid (WRITABLE mode).
1427 * If what == TRY_ONLY:
1428 * Open device, read MBR. Return an error if anything is out of place.
1429 * Do not create an empty disklabel. This is used for the "list"
1430 * operations: "fdisk -l /dev/sda" and "fdisk -l" (all devices).
1431 * If what == CREATE_EMPTY_*:
1432 * This means that get_boot() was called recursively from create_*label().
1433 * Do not re-open the device; just set up the ptes array and print
1434 * geometry warnings.
1437 * -1: no 0xaa55 flag present (possibly entire disk BSD)
1438 * 0: found or created label
1441 #if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
1442 static int get_boot(enum action what)
1444 static int get_boot(void)
1445 #define get_boot(what) get_boot()
1451 for (i = 0; i < 4; i++) {
1452 struct pte *pe = &ptes[i];
1453 pe->part_table = pt_offset(MBRbuffer, i);
1454 pe->ext_pointer = NULL;
1455 pe->offset_from_dev_start = 0;
1456 pe->sectorbuffer = MBRbuffer;
1457 #if ENABLE_FEATURE_FDISK_WRITABLE
1458 pe->changed = (what == CREATE_EMPTY_DOS);
1462 #if ENABLE_FEATURE_FDISK_WRITABLE
1463 // ALERT! highly idiotic design!
1464 // We end up here when we call get_boot() recursively
1465 // via get_boot() [table is bad] -> create_doslabel() -> get_boot(CREATE_EMPTY_DOS).
1466 // or get_boot() [table is bad] -> create_sunlabel() -> get_boot(CREATE_EMPTY_SUN).
1467 // (just factor out re-init of ptes[0,1,2,3] in a separate fn instead?)
1468 // So skip opening device _again_...
1469 if (what == CREATE_EMPTY_DOS IF_FEATURE_SUN_LABEL(|| what == CREATE_EMPTY_SUN))
1472 fd = open(disk_device, (option_mask32 & OPT_l) ? O_RDONLY : O_RDWR);
1475 fd = open(disk_device, O_RDONLY);
1477 if (what == TRY_ONLY)
1479 fdisk_fatal(unable_to_open);
1481 printf("'%s' is opened for read only\n", disk_device);
1483 xmove_fd(fd, dev_fd);
1484 if (512 != full_read(dev_fd, MBRbuffer, 512)) {
1485 if (what == TRY_ONLY) {
1489 fdisk_fatal(unable_to_read);
1492 fd = open(disk_device, O_RDONLY);
1495 if (512 != full_read(fd, MBRbuffer, 512)) {
1499 xmove_fd(fd, dev_fd);
1505 #if ENABLE_FEATURE_SUN_LABEL
1506 if (check_sun_label())
1509 #if ENABLE_FEATURE_SGI_LABEL
1510 if (check_sgi_label())
1513 #if ENABLE_FEATURE_AIX_LABEL
1514 if (check_aix_label())
1517 #if ENABLE_FEATURE_GPT_LABEL
1518 if (check_gpt_label())
1521 #if ENABLE_FEATURE_OSF_LABEL
1522 if (check_osf_label()) {
1523 possibly_osf_label = 1;
1524 if (!valid_part_table_flag(MBRbuffer)) {
1525 current_label_type = LABEL_OSF;
1528 puts("This disk has both DOS and BSD magic.\n"
1529 "Give the 'b' command to go to BSD mode.");
1533 #if !ENABLE_FEATURE_FDISK_WRITABLE
1534 if (!valid_part_table_flag(MBRbuffer))
1537 if (!valid_part_table_flag(MBRbuffer)) {
1538 if (what == OPEN_MAIN) {
1539 puts("Device contains neither a valid DOS "
1540 "partition table, nor Sun, SGI, OSF or GPT "
1543 IF_FEATURE_SUN_LABEL(create_sunlabel();)
1553 #endif /* FEATURE_FDISK_WRITABLE */
1556 IF_FEATURE_FDISK_WRITABLE(warn_cylinders();)
1559 for (i = 0; i < 4; i++) {
1560 if (IS_EXTENDED(ptes[i].part_table->sys_ind)) {
1561 if (g_partitions != 4)
1562 printf("Ignoring extra extended "
1563 "partition %u\n", i + 1);
1569 for (i = 3; i < g_partitions; i++) {
1570 struct pte *pe = &ptes[i];
1571 if (!valid_part_table_flag(pe->sectorbuffer)) {
1572 printf("Warning: invalid flag 0x%02x,0x%02x of partition "
1573 "table %u will be corrected by w(rite)\n",
1574 pe->sectorbuffer[510],
1575 pe->sectorbuffer[511],
1577 IF_FEATURE_FDISK_WRITABLE(pe->changed = 1;)
1584 #if ENABLE_FEATURE_FDISK_WRITABLE
1586 * Print the message MESG, then read an integer between LOW and HIGH (inclusive).
1587 * If the user hits Enter, DFLT is returned.
1588 * Answers like +10 are interpreted as offsets from BASE.
1590 * There is no default if DFLT is not between LOW and HIGH.
1593 read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg)
1597 const char *fmt = "%s (%u-%u, default %u): ";
1599 if (dflt < low || dflt > high) {
1600 fmt = "%s (%u-%u): ";
1605 int use_default = default_ok;
1607 /* ask question and read answer */
1609 printf(fmt, mesg, low, high, dflt);
1610 read_maybe_empty("");
1611 } while (*line_ptr != '\n' && !isdigit(*line_ptr)
1612 && *line_ptr != '-' && *line_ptr != '+');
1614 if (*line_ptr == '+' || *line_ptr == '-') {
1615 int minus = (*line_ptr == '-');
1616 unsigned scale_shift;
1618 if (sizeof(value) <= sizeof(long))
1619 value = strtoul(line_ptr + 1, NULL, 10);
1621 value = strtoull(line_ptr + 1, NULL, 10);
1623 /* (1) if 2nd char is digit, use_default = 0.
1624 * (2) move line_ptr to first non-digit.
1626 while (isdigit(*++line_ptr))
1630 switch (*line_ptr | 0x20) {
1632 scale_shift = 10; /* 1024 */
1635 * fdisk from util-linux 2.31 seems to round '+NNNk' and '+NNNK' to megabytes,
1636 * (512-byte) sector count of the partition does not equal NNN*2:
1638 * Last sector, +sectors or +size{K,M,G,T,P} (1953792-1000215215, default 1000215215): +9727k
1639 * Device Boot Start End Sectors Size Id Type
1640 * /dev/sdaN 1953792 1972223 18432 9M 83 Linux <-- size exactly 9*1024*1024 bytes
1642 * Last sector, +sectors or +size{K,M,G,T,P} (1953792-1000215215, default 1000215215): +9728k
1643 * /dev/sdaN 1953792 1974271 20480 10M 83 Linux <-- size exactly 10*1024*1024 bytes
1645 * If 'k' means 1000 bytes (not 1024), then 9728k = 9728*1000 = 9500*1024,
1646 * exactly halfway from 9000 to 10000, which explains why it jumps to next mbyte
1649 * 'm' does not seem to behave this way: it means 1024*1024 bytes.
1651 * Not sure we want to copy this. If user says he wants 1234kbyte partition,
1652 * we do _exactly that_: 1234kbytes = 2468 sectors.
1655 scale_shift = 20; /* 1024*1024 */
1658 scale_shift = 30; /* 1024*1024*1024 */
1661 scale_shift = 40; /* 1024*1024*1024*1024 */
1670 bytes = (ullong) value << scale_shift;
1671 unit = sector_size * units_per_sector;
1672 bytes += unit/2; /* round */
1674 value = (bytes != 0 ? bytes - 1 : 0);
1680 if (sizeof(value) <= sizeof(long))
1681 value = strtoul(line_ptr, NULL, 10);
1683 value = strtoull(line_ptr, NULL, 10);
1684 while (isdigit(*line_ptr)) {
1691 printf("Using default value %u\n", value);
1693 if (value >= low && value <= high)
1695 puts("Value is out of range");
1701 get_partition(int warn, unsigned max)
1706 i = read_int(1, 0, max, 0, "Partition number") - 1;
1710 if ((!LABEL_IS_SUN && !LABEL_IS_SGI && !pe->part_table->sys_ind)
1711 || (LABEL_IS_SUN && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id))
1712 || (LABEL_IS_SGI && !sgi_get_num_sectors(i))
1714 printf("Warning: partition %u has empty type\n", i+1);
1721 get_existing_partition(int warn, unsigned max)
1726 for (i = 0; i < max; i++) {
1727 struct pte *pe = &ptes[i];
1728 struct partition *p = pe->part_table;
1730 if (p && !is_cleared_partition(p)) {
1737 printf("Selected partition %u\n", pno+1);
1740 puts("No partition is defined yet!");
1744 return get_partition(warn, max);
1748 get_nonexisting_partition(void)
1754 for (i = 0; i < max; i++) {
1755 struct pte *pe = &ptes[i];
1756 struct partition *p = pe->part_table;
1758 if (p && is_cleared_partition(p)) {
1765 printf("Selected partition %u\n", pno+1);
1768 puts("All primary partitions have been defined already!");
1772 return get_partition(/*warn*/ 0, max);
1779 display_in_cyl_units = !display_in_cyl_units;
1781 printf("Changing display/entry units to %s\n",
1786 toggle_active(int i)
1788 struct pte *pe = &ptes[i];
1789 struct partition *p = pe->part_table;
1791 if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
1792 printf("WARNING: Partition %u is an extended partition\n", i + 1);
1793 p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
1798 toggle_dos_compatibility_flag(void)
1800 dos_compatible_flag = 1 - dos_compatible_flag;
1801 if (dos_compatible_flag) {
1802 sector_offset = g_sectors;
1803 printf("DOS Compatibility flag is %sset\n", "");
1806 printf("DOS Compatibility flag is %sset\n", "not ");
1811 delete_partition(int i)
1813 struct pte *pe = &ptes[i];
1814 struct partition *p = pe->part_table;
1815 struct partition *q = pe->ext_pointer;
1817 /* Note that for the fifth partition (i == 4) we don't actually
1818 * decrement partitions.
1821 if (warn_geometry())
1822 return; /* C/H/S not set */
1826 sun_delete_partition(i);
1830 sgi_delete_partition(i);
1835 if (IS_EXTENDED(p->sys_ind) && i == ext_index) {
1837 ptes[ext_index].ext_pointer = NULL;
1838 extended_offset = 0;
1844 if (!q->sys_ind && i > 4) {
1845 /* the last one in the chain - just delete */
1848 clear_partition(ptes[i].ext_pointer);
1849 ptes[i].changed = 1;
1851 /* not the last one - further ones will be moved down */
1853 /* delete this link in the chain */
1854 p = ptes[i-1].ext_pointer;
1856 set_start_sect(p, get_start_sect(q));
1857 set_nr_sects(p, get_nr_sects(q));
1858 ptes[i-1].changed = 1;
1859 } else if (g_partitions > 5) { /* 5 will be moved to 4 */
1860 /* the first logical in a longer chain */
1863 if (pe->part_table) /* prevent SEGFAULT */
1864 set_start_sect(pe->part_table,
1865 get_partition_start_from_dev_start(pe) -
1867 pe->offset_from_dev_start = extended_offset;
1871 if (g_partitions > 5) {
1873 while (i < g_partitions) {
1874 ptes[i] = ptes[i+1];
1878 /* the only logical: clear only */
1879 clear_partition(ptes[i].part_table);
1887 int i, sys, origsys;
1888 struct partition *p;
1890 /* If sgi_label then don't use get_existing_partition,
1891 let the user select a partition, since get_existing_partition()
1892 only works for Linux like partition tables. */
1893 if (!LABEL_IS_SGI) {
1894 i = get_existing_partition(0, g_partitions);
1896 i = get_partition(0, g_partitions);
1900 p = ptes[i].part_table;
1901 origsys = sys = get_sysid(i);
1903 /* if changing types T to 0 is allowed, then
1904 the reverse change must be allowed, too */
1905 if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) {
1906 printf("Partition %u does not exist yet!\n", i + 1);
1910 sys = read_hex(get_sys_types());
1912 if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) {
1913 puts("Type 0 means free space to many systems\n"
1914 "(but not to Linux). Having partitions of\n"
1915 "type 0 is probably unwise.");
1919 if (!LABEL_IS_SUN && !LABEL_IS_SGI) {
1920 if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {
1921 puts("You cannot change a partition into"
1922 " an extended one or vice versa");
1928 #if ENABLE_FEATURE_SUN_LABEL
1929 if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK)
1930 puts("Consider leaving partition 3 "
1931 "as Whole disk (5),\n"
1932 "as SunOS/Solaris expects it and "
1933 "even Linux likes it\n");
1935 #if ENABLE_FEATURE_SGI_LABEL
1938 (i == 10 && sys != SGI_ENTIRE_DISK) ||
1939 (i == 8 && sys != 0)
1942 puts("Consider leaving partition 9 "
1943 "as volume header (0),\nand "
1944 "partition 11 as entire volume (6)"
1945 "as IRIX expects it\n");
1951 sun_change_sysid(i, sys);
1952 } else if (LABEL_IS_SGI) {
1953 sgi_change_sysid(i, sys);
1957 printf("Changed system type of partition %u "
1958 "to %x (%s)\n", i + 1, sys,
1959 partition_type(sys));
1960 ptes[i].changed = 1;
1961 //if (is_dos_partition(origsys) || is_dos_partition(sys))
1967 #endif /* FEATURE_FDISK_WRITABLE */
1970 /* check_consistency() and linear2chs() added Sat Mar 6 12:28:16 1993,
1971 * faith@cs.unc.edu, based on code fragments from pfdisk by Gordon W. Ross,
1972 * Jan. 1990 (version 1.2.1 by Gordon W. Ross Aug. 1990; Modified by S.
1973 * Lubkin Oct. 1991). */
1976 linear2chs(unsigned ls, unsigned *c, unsigned *h, unsigned *s)
1978 int spc = g_heads * g_sectors;
1982 *h = ls / g_sectors;
1983 *s = ls % g_sectors + 1; /* sectors count from 1 */
1987 check_consistency(const struct partition *p, int partition)
1989 unsigned pbc, pbh, pbs; /* physical beginning c, h, s */
1990 unsigned pec, peh, pes; /* physical ending c, h, s */
1991 unsigned lbc, lbh, lbs; /* logical beginning c, h, s */
1992 unsigned lec, leh, les; /* logical ending c, h, s */
1994 if (!g_heads || !g_sectors || (partition >= 4))
1995 return; /* do not check extended partitions */
1997 /* physical beginning c, h, s */
1998 pbc = cylinder(p->sector, p->cyl);
2000 pbs = sector(p->sector);
2002 /* physical ending c, h, s */
2003 pec = cylinder(p->end_sector, p->end_cyl);
2005 pes = sector(p->end_sector);
2007 /* compute logical beginning (c, h, s) */
2008 linear2chs(get_start_sect(p), &lbc, &lbh, &lbs);
2010 /* compute logical ending (c, h, s) */
2011 linear2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
2013 /* Same physical / logical beginning? */
2014 if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
2015 printf("Partition %u has different physical/logical "
2016 "start (non-Linux?):\n", partition + 1);
2017 printf(" phys=(%u,%u,%u) ", pbc, pbh, pbs);
2018 printf("logical=(%u,%u,%u)\n", lbc, lbh, lbs);
2021 /* Same physical / logical ending? */
2022 if (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
2023 printf("Partition %u has different physical/logical "
2024 "end:\n", partition + 1);
2025 printf(" phys=(%u,%u,%u) ", pec, peh, pes);
2026 printf("logical=(%u,%u,%u)\n", lec, leh, les);
2031 list_disk_geometry(void)
2033 ullong bytes = ((ullong)total_number_of_sectors << 9);
2034 ullong xbytes = bytes / (1024*1024);
2037 if (xbytes >= 10000) {
2038 xbytes += 512; /* fdisk util-linux 2.28 does this */
2042 printf("Disk %s: %llu %cB, %llu bytes, %"SECT_FMT"u sectors\n"
2043 "%u cylinders, %u heads, %u sectors/track\n"
2044 "Units: %s of %u * %u = %u bytes\n\n",
2045 disk_device, xbytes, x,
2046 bytes, total_number_of_sectors,
2047 g_cylinders, g_heads, g_sectors,
2049 units_per_sector, sector_size, units_per_sector * sector_size
2054 * Check whether partition entries are ordered by their starting positions.
2055 * Return 0 if OK. Return i if partition i should have been earlier.
2056 * Two separate checks: primary and logical partitions.
2059 wrong_p_order(int *prev)
2061 const struct pte *pe;
2062 const struct partition *p;
2063 sector_t last_p_start_pos = 0, p_start_pos;
2064 unsigned i, last_i = 0;
2066 for (i = 0; i < g_partitions; i++) {
2069 last_p_start_pos = 0;
2074 p_start_pos = get_partition_start_from_dev_start(pe);
2076 if (last_p_start_pos > p_start_pos) {
2082 last_p_start_pos = p_start_pos;
2089 #if ENABLE_FEATURE_FDISK_ADVANCED
2091 * Fix the chain of logicals.
2092 * extended_offset is unchanged, the set of sectors used is unchanged
2093 * The chain is sorted so that sectors increase, and so that
2094 * starting sectors increase.
2096 * After this it may still be that cfdisk doesnt like the table.
2097 * (This is because cfdisk considers expanded parts, from link to
2098 * end of partition, and these may still overlap.)
2100 * sfdisk /dev/hda > ohda; sfdisk /dev/hda < ohda
2104 fix_chain_of_logicals(void)
2106 int j, oj, ojj, sj, sjj;
2107 struct partition *pj,*pjj,tmp;
2109 /* Stage 1: sort sectors but leave sector of part 4 */
2110 /* (Its sector is the global extended_offset.) */
2112 for (j = 5; j < g_partitions - 1; j++) {
2113 oj = ptes[j].offset_from_dev_start;
2114 ojj = ptes[j+1].offset_from_dev_start;
2116 ptes[j].offset_from_dev_start = ojj;
2117 ptes[j+1].offset_from_dev_start = oj;
2118 pj = ptes[j].part_table;
2119 set_start_sect(pj, get_start_sect(pj)+oj-ojj);
2120 pjj = ptes[j+1].part_table;
2121 set_start_sect(pjj, get_start_sect(pjj)+ojj-oj);
2122 set_start_sect(ptes[j-1].ext_pointer,
2123 ojj-extended_offset);
2124 set_start_sect(ptes[j].ext_pointer,
2125 oj-extended_offset);
2130 /* Stage 2: sort starting sectors */
2132 for (j = 4; j < g_partitions - 1; j++) {
2133 pj = ptes[j].part_table;
2134 pjj = ptes[j+1].part_table;
2135 sj = get_start_sect(pj);
2136 sjj = get_start_sect(pjj);
2137 oj = ptes[j].offset_from_dev_start;
2138 ojj = ptes[j+1].offset_from_dev_start;
2139 if (oj+sj > ojj+sjj) {
2143 set_start_sect(pj, ojj+sjj-oj);
2144 set_start_sect(pjj, oj+sj-ojj);
2149 /* Probably something was changed */
2150 for (j = 4; j < g_partitions; j++)
2151 ptes[j].changed = 1;
2156 fix_partition_table_order(void)
2158 struct pte *pei, *pek;
2161 if (!wrong_p_order(NULL)) {
2162 puts("Ordering is already correct\n");
2166 while ((i = wrong_p_order(&k)) != 0 && i < 4) {
2167 /* partition i should have come earlier, move it */
2168 /* We have to move data in the MBR */
2169 struct partition *pi, *pk, *pe, pbuf;
2173 pe = pei->ext_pointer;
2174 pei->ext_pointer = pek->ext_pointer;
2175 pek->ext_pointer = pe;
2177 pi = pei->part_table;
2178 pk = pek->part_table;
2180 memmove(&pbuf, pi, sizeof(struct partition));
2181 memmove(pi, pk, sizeof(struct partition));
2182 memmove(pk, &pbuf, sizeof(struct partition));
2184 pei->changed = pek->changed = 1;
2188 fix_chain_of_logicals();
2195 chs_string11(unsigned cyl, unsigned head, unsigned sect)
2197 char *buf = auto_string(xzalloc(sizeof(int)*3 * 3));
2198 sprintf(buf, "%u,%u,%u", cylinder(sect,cyl), head, sector(sect));
2203 list_table(int xtra)
2208 sun_list_table(xtra);
2212 sgi_list_table(xtra);
2216 gpt_list_table(xtra);
2220 list_disk_geometry();
2223 xbsd_print_disklabel(xtra);
2227 /* Heuristic: we list partition 3 of /dev/foo as /dev/foo3,
2228 * but if the device name ends in a digit, say /dev/foo1,
2229 * then the partition is called /dev/foo1p3.
2231 w = strlen(disk_device);
2232 if (w && isdigit(disk_device[w-1]))
2237 printf("%-*s Boot StartCHS EndCHS StartLBA EndLBA Sectors Size Id Type\n",
2240 for (i = 0; i < g_partitions; i++) {
2241 const struct partition *p;
2242 const struct pte *pe = &ptes[i];
2245 sector_t start_sect;
2250 if (!p || is_cleared_partition(p))
2253 sprintf(boot4, "%02x", p->boot_ind);
2254 if ((p->boot_ind & 0x7f) == 0) {
2255 /* 0x80 shown as '*', 0x00 is ' ' */
2256 boot4[0] = p->boot_ind ? '*' : ' ';
2260 start_sect = get_partition_start_from_dev_start(pe);
2261 end_sect = start_sect;
2262 nr_sects = get_nr_sects(p);
2264 end_sect += nr_sects - 1;
2266 smart_ulltoa5((ullong)nr_sects * sector_size,
2267 numstr6, " KMGTPEZY")[0] = '\0';
2269 #define SFMT SECT_FMT
2270 // Boot StartCHS EndCHS StartLBA EndLBA Sectors Size Id Type
2271 printf("%s%s %-11s"/**/" %-11s"/**/" %10"SFMT"u %10"SFMT"u %10"SFMT"u %s %2x %s\n",
2272 partname(disk_device, i+1, w+2),
2274 chs_string11(p->cyl, p->head, p->sector),
2275 chs_string11(p->end_cyl, p->end_head, p->end_sector),
2281 partition_type(p->sys_ind)
2284 check_consistency(p, i);
2287 /* Is partition table in disk order? It need not be, but... */
2288 /* partition table entries are not checked for correct order
2289 * if this is a sgi, sun or aix labeled disk... */
2290 if (LABEL_IS_DOS && wrong_p_order(NULL)) {
2292 puts("\nPartition table entries are not in disk order");
2296 #if ENABLE_FEATURE_FDISK_ADVANCED
2298 x_list_table(int extend)
2300 const struct pte *pe;
2301 const struct partition *p;
2304 printf("\nDisk %s: %u heads, %u sectors, %u cylinders\n\n",
2305 disk_device, g_heads, g_sectors, g_cylinders);
2306 puts("Nr AF Hd Sec Cyl Hd Sec Cyl Start Size ID");
2307 for (i = 0; i < g_partitions; i++) {
2309 p = (extend ? pe->ext_pointer : pe->part_table);
2311 printf("%2u %02x%4u%4u%5u%4u%4u%5u%11"SECT_FMT"u%11"SECT_FMT"u %02x\n",
2315 cylinder(p->sector, p->cyl),
2317 sector(p->end_sector),
2318 cylinder(p->end_sector, p->end_cyl),
2324 check_consistency(p, i);
2330 #if ENABLE_FEATURE_FDISK_WRITABLE
2332 fill_bounds(sector_t *first, sector_t *last)
2335 const struct pte *pe = &ptes[0];
2336 const struct partition *p;
2338 for (i = 0; i < g_partitions; pe++,i++) {
2340 if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) {
2341 first[i] = 0xffffffff;
2344 first[i] = get_partition_start_from_dev_start(pe);
2345 last[i] = first[i] + get_nr_sects(p) - 1;
2351 check(int n, unsigned h, unsigned s, unsigned c, sector_t start)
2353 sector_t total, real_s, real_c;
2355 real_s = sector(s) - 1;
2356 real_c = cylinder(s, c);
2357 total = (real_c * g_sectors + real_s) * g_heads + h;
2359 printf("Partition %u contains sector 0\n", n);
2361 printf("Partition %u: head %u greater than maximum %u\n",
2363 if (real_s >= g_sectors)
2364 printf("Partition %u: sector %u greater than "
2365 "maximum %u\n", n, s, g_sectors);
2366 if (real_c >= g_cylinders)
2367 printf("Partition %u: cylinder %"SECT_FMT"u greater than "
2368 "maximum %u\n", n, real_c + 1, g_cylinders);
2369 if (g_cylinders <= 1024 && start != total)
2370 printf("Partition %u: previous sectors %"SECT_FMT"u disagrees with "
2371 "total %"SECT_FMT"u\n", n, start, total);
2380 sector_t first[g_partitions], last[g_partitions];
2381 struct partition *p;
2383 if (warn_geometry())
2395 fill_bounds(first, last);
2396 for (i = 0; i < g_partitions; i++) {
2397 struct pte *pe = &ptes[i];
2400 if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
2401 check_consistency(p, i);
2402 if (get_partition_start_from_dev_start(pe) < first[i])
2403 printf("Warning: bad start-of-data in "
2404 "partition %u\n", i + 1);
2405 check(i + 1, p->end_head, p->end_sector, p->end_cyl,
2407 total += last[i] + 1 - first[i];
2408 for (j = 0; j < i; j++) {
2409 if ((first[i] >= first[j] && first[i] <= last[j])
2410 || ((last[i] <= last[j] && last[i] >= first[j]))) {
2411 printf("Warning: partition %u overlaps "
2412 "partition %u\n", j + 1, i + 1);
2413 total += first[i] >= first[j] ?
2414 first[i] : first[j];
2415 total -= last[i] <= last[j] ?
2422 if (extended_offset) {
2423 struct pte *pex = &ptes[ext_index];
2424 sector_t e_last = get_start_sect(pex->part_table) +
2425 get_nr_sects(pex->part_table) - 1;
2427 for (i = 4; i < g_partitions; i++) {
2429 p = ptes[i].part_table;
2431 if (i != 4 || i + 1 < g_partitions)
2432 printf("Warning: partition %u "
2433 "is empty\n", i + 1);
2434 } else if (first[i] < extended_offset || last[i] > e_last) {
2435 printf("Logical partition %u not entirely in "
2436 "partition %u\n", i + 1, ext_index + 1);
2441 chs_size = (sector_t)g_heads * g_sectors * g_cylinders;
2442 if (total > chs_size)
2443 printf("Total allocated sectors %u"
2444 " greater than CHS size %"SECT_FMT"u\n",
2448 total = chs_size - total;
2450 printf("%"SECT_FMT"u unallocated sectors\n", total);
2455 add_partition(int n, int sys)
2457 char mesg[256]; /* 48 does not suffice in Japanese */
2458 int i, num_read = 0;
2459 struct partition *p = ptes[n].part_table;
2460 struct partition *q = ptes[ext_index].part_table;
2461 sector_t limit, temp;
2462 sector_t start, stop = 0;
2463 sector_t first[g_partitions], last[g_partitions];
2465 if (p && p->sys_ind) {
2466 printf(msg_part_already_defined, n + 1);
2469 fill_bounds(first, last);
2471 start = sector_offset;
2472 if (display_in_cyl_units || !total_number_of_sectors)
2473 limit = (sector_t) g_heads * g_sectors * g_cylinders - 1;
2475 limit = total_number_of_sectors - 1;
2476 if (extended_offset) {
2477 first[ext_index] = extended_offset;
2478 last[ext_index] = get_start_sect(q) +
2479 get_nr_sects(q) - 1;
2482 start = extended_offset + sector_offset;
2483 limit = get_start_sect(q) + get_nr_sects(q) - 1;
2485 if (display_in_cyl_units)
2486 for (i = 0; i < g_partitions; i++)
2487 first[i] = (cround(first[i]) - 1) * units_per_sector;
2489 snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));
2492 for (i = 0; i < g_partitions; i++) {
2495 if (start == ptes[i].offset_from_dev_start)
2496 start += sector_offset;
2497 lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
2498 if (start >= first[i] && start <= lastplusoff)
2499 start = lastplusoff + 1;
2503 if (start >= temp+units_per_sector && num_read) {
2504 printf("Sector %"SECT_FMT"u is already allocated\n", temp);
2508 if (!num_read && start == temp) {
2509 sector_t saved_start;
2511 saved_start = start;
2512 start = read_int(cround(saved_start), cround(saved_start), cround(limit), 0, mesg);
2513 if (display_in_cyl_units) {
2514 start = (start - 1) * units_per_sector;
2515 if (start < saved_start)
2516 start = saved_start;
2520 } while (start != temp || !num_read);
2521 if (n > 4) { /* NOT for fifth partition */
2522 struct pte *pe = &ptes[n];
2524 pe->offset_from_dev_start = start - sector_offset;
2525 if (pe->offset_from_dev_start == extended_offset) { /* must be corrected */
2526 pe->offset_from_dev_start++;
2527 if (sector_offset == 1)
2532 for (i = 0; i < g_partitions; i++) {
2533 struct pte *pe = &ptes[i];
2535 if (start < pe->offset_from_dev_start && limit >= pe->offset_from_dev_start)
2536 limit = pe->offset_from_dev_start - 1;
2537 if (start < first[i] && limit >= first[i])
2538 limit = first[i] - 1;
2540 if (start > limit) {
2541 puts("No free sectors available");
2546 if (cround(start) == cround(limit)) {
2549 snprintf(mesg, sizeof(mesg),
2550 "Last %s or +size{,K,M,G,T}",
2553 stop = read_int(cround(start), cround(limit), cround(limit), cround(start), mesg);
2554 if (display_in_cyl_units) {
2555 stop = stop * units_per_sector - 1;
2561 set_partition(n, 0, start, stop, sys);
2563 set_partition(n - 1, 1, ptes[n].offset_from_dev_start, stop, EXTENDED);
2565 if (IS_EXTENDED(sys)) {
2566 struct pte *pe4 = &ptes[4];
2567 struct pte *pen = &ptes[n];
2570 pen->ext_pointer = p;
2571 pe4->offset_from_dev_start = extended_offset = start;
2572 pe4->sectorbuffer = xzalloc(sector_size);
2573 pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
2574 pe4->ext_pointer = pe4->part_table + 1;
2583 if (g_partitions > 5 || ptes[4].part_table->sys_ind) {
2584 struct pte *pe = &ptes[g_partitions];
2586 pe->sectorbuffer = xzalloc(sector_size);
2587 pe->part_table = pt_offset(pe->sectorbuffer, 0);
2588 pe->ext_pointer = pe->part_table + 1;
2589 pe->offset_from_dev_start = 0;
2593 add_partition(g_partitions - 1, LINUX_NATIVE);
2599 int i, free_primary = 0;
2601 if (warn_geometry())
2605 add_sun_partition(get_partition(0, g_partitions), LINUX_NATIVE);
2609 sgi_add_partition(get_partition(0, g_partitions), LINUX_NATIVE);
2613 puts("Sorry - this fdisk cannot handle AIX disk labels.\n"
2614 "If you want to add DOS-type partitions, create a new empty DOS partition\n"
2615 "table first (use 'o'). This will destroy the present disk contents.");
2619 for (i = 0; i < 4; i++)
2620 free_primary += !ptes[i].part_table->sys_ind;
2622 if (!free_primary && g_partitions >= MAXIMUM_PARTS) {
2623 puts("The maximum number of partitions has been created");
2627 if (!free_primary) {
2628 if (extended_offset)
2631 puts("You must delete some partition and add "
2632 "an extended partition first");
2635 snprintf(line, sizeof(line),
2637 " p primary partition (1-4)\n"
2640 "l logical (5 or over)" : "e extended"));
2642 c = read_nonempty(line);
2643 c |= 0x20; /* lowercase */
2645 i = get_nonexisting_partition();
2647 add_partition(i, LINUX_NATIVE);
2650 if (c == 'l' && extended_offset) {
2654 if (c == 'e' && !extended_offset) {
2655 i = get_nonexisting_partition();
2657 add_partition(i, EXTENDED);
2660 printf("Invalid partition number "
2661 "for type '%c'\n", c);
2667 reread_partition_table(int leave)
2671 puts("Calling ioctl() to re-read partition table");
2673 /* Users with slow external USB disks on a 320MHz ARM system (year 2011)
2674 * report that sleep is needed, otherwise BLKRRPART may fail with -EIO:
2677 i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
2678 "WARNING: rereading partition table "
2679 "failed, kernel still uses old table");
2683 "\nWARNING: If you have created or modified any DOS 6.x\n"
2684 "partitions, please see the fdisk manual page for additional\n"
2689 if (ENABLE_FEATURE_CLEAN_UP)
2701 for (i = 0; i < 3; i++)
2702 if (ptes[i].changed)
2703 ptes[3].changed = 1;
2704 for (i = 3; i < g_partitions; i++) {
2705 struct pte *pe = &ptes[i];
2707 write_part_table_flag(pe->sectorbuffer);
2708 write_sector(pe->offset_from_dev_start, pe->sectorbuffer);
2712 else if (LABEL_IS_SGI) {
2713 /* no test on change? the "altered" msg below might be mistaken */
2716 else if (LABEL_IS_SUN) {
2717 for (i = 0; i < 8; i++) {
2718 if (ptes[i].changed) {
2725 puts("The partition table has been altered.");
2726 reread_partition_table(1);
2728 #endif /* FEATURE_FDISK_WRITABLE */
2730 #if ENABLE_FEATURE_FDISK_ADVANCED
2731 #define MAX_PER_LINE 16
2733 print_buffer(char *pbuffer)
2737 for (i = 0, l = 0; i < sector_size; i++, l++) {
2739 printf("0x%03X:", i);
2740 printf(" %02X", (unsigned char) pbuffer[i]);
2741 if (l == MAX_PER_LINE - 1) {
2756 printf("Device: %s\n", disk_device);
2757 if (LABEL_IS_SGI || LABEL_IS_SUN)
2758 print_buffer(MBRbuffer);
2760 for (i = 3; i < g_partitions; i++)
2761 print_buffer(ptes[i].sectorbuffer);
2766 move_begin(unsigned i)
2768 struct pte *pe = &ptes[i];
2769 struct partition *p = pe->part_table;
2770 sector_t new, first, nr_sects;
2772 if (warn_geometry())
2774 nr_sects = get_nr_sects(p);
2775 if (!p->sys_ind || !nr_sects || IS_EXTENDED(p->sys_ind)) {
2776 printf("Partition %u has no data area\n", i + 1);
2779 first = get_partition_start_from_dev_start(pe); /* == pe->offset_from_dev_start + get_start_sect(p) */
2780 new = read_int(0 /*was:first*/, first, first + nr_sects - 1, first, "New beginning of data");
2782 sector_t new_relative = new - pe->offset_from_dev_start;
2783 nr_sects += (get_start_sect(p) - new_relative);
2784 set_start_sect(p, new_relative);
2785 set_nr_sects(p, nr_sects);
2786 read_nonempty("Recalculate C/H/S values? (Y/N): ");
2787 if ((line_ptr[0] | 0x20) == 'y')
2788 set_hsc_start_end(p, new, new + nr_sects - 1);
2800 c = 0x20 | read_nonempty("Expert command (m for help): ");
2808 move_begin(get_partition(0, g_partitions));
2811 user_cylinders = g_cylinders =
2812 read_int(1, g_cylinders, 1048576, 0,
2813 "Number of cylinders");
2815 sun_set_ncyl(g_cylinders);
2825 else if (LABEL_IS_SUN)
2827 else if (LABEL_IS_DOS)
2832 fix_partition_table_order();
2835 #if ENABLE_FEATURE_SGI_LABEL
2840 user_heads = g_heads = read_int(1, g_heads, 256, 0, "Number of heads");
2858 if (ENABLE_FEATURE_CLEAN_UP)
2865 user_sectors = g_sectors = read_int(1, g_sectors, 63, 0, "Number of sectors");
2866 if (dos_compatible_flag) {
2867 sector_offset = g_sectors;
2868 puts("Warning: setting sector offset for DOS "
2877 write_table(); /* does not return */
2881 sun_set_pcylcount();
2888 #endif /* ADVANCED mode */
2891 is_ide_cdrom_or_tape(const char *device)
2895 struct stat statbuf;
2898 /* No device was given explicitly, and we are trying some
2899 likely things. But opening /dev/hdc may produce errors like
2900 "hdc: tray open or drive not ready"
2901 if it happens to be a CD-ROM drive. It even happens that
2902 the process hangs on the attempt to read a music CD.
2903 So try to be careful. This only works since 2.1.73. */
2905 if (!is_prefixed_with(device, "/dev/hd"))
2908 snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
2909 procf = fopen_for_read(buf);
2910 if (procf != NULL && fgets(buf, sizeof(buf), procf))
2911 is_ide = (is_prefixed_with(buf, "cdrom") ||
2912 is_prefixed_with(buf, "tape"));
2914 /* Now when this proc file does not exist, skip the
2915 device when it is read-only. */
2916 if (stat(device, &statbuf) == 0)
2917 is_ide = ((statbuf.st_mode & 0222) == 0);
2926 open_list_and_close(const char *device, int user_specified)
2930 disk_device = device;
2931 if (setjmp(listingbuf))
2933 if (!user_specified)
2934 if (is_ide_cdrom_or_tape(device))
2937 /* Open disk_device, save file descriptor to dev_fd */
2939 gb = get_boot(TRY_ONLY);
2940 if (gb > 0) { /* I/O error */
2941 /* Ignore other errors, since we try IDE
2942 and SCSI hard disks which may not be
2943 installed on the system. */
2944 if (user_specified || errno == EACCES)
2945 bb_perror_msg("can't open '%s'", device);
2949 if (gb < 0) { /* no DOS signature */
2950 list_disk_geometry();
2953 #if ENABLE_FEATURE_OSF_LABEL
2954 if (bsd_trydev(device) < 0)
2956 printf("Disk %s doesn't contain a valid "
2957 "partition table\n", device);
2960 #if ENABLE_FEATURE_FDISK_WRITABLE
2961 if (!LABEL_IS_SUN && g_partitions > 4) {
2962 delete_partition(ext_index);
2970 /* Is it a whole disk? The digit check is still useful
2971 for Xen devices for example. */
2972 static int is_whole_disk(const char *disk)
2975 int fd = open(disk, O_RDONLY);
2978 struct hd_geometry geometry;
2979 int err = ioctl(fd, HDIO_GETGEO, &geometry);
2982 return (geometry.start == 0);
2985 /* Treat "nameN" as a partition name, not whole disk */
2986 /* note: mmcblk0 should work from the geometry check above */
2988 if (len != 0 && isdigit(disk[len - 1]))
2994 /* for fdisk -l: try all things in /proc/partitions
2995 that look like a partition name (do not end in a digit) */
2997 list_devs_in_proc_partititons(void)
3000 char line[100], ptname[100], devname[120];
3003 procpt = fopen_or_warn("/proc/partitions", "r");
3005 while (fgets(line, sizeof(line), procpt)) {
3006 if (sscanf(line, " %u %u %u %[^\n ]",
3007 &ma, &mi, &sz, ptname) != 4)
3010 sprintf(devname, "/dev/%s", ptname);
3011 if (is_whole_disk(devname))
3012 open_list_and_close(devname, 0);
3014 #if ENABLE_FEATURE_CLEAN_UP
3019 #if ENABLE_FEATURE_FDISK_WRITABLE
3021 unknown_command(int c)
3023 printf("%c: unknown command\n", c);
3027 int fdisk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
3028 int fdisk_main(int argc UNUSED_PARAM, char **argv)
3033 * fdisk -l [-b sectorsize] [-u] device ...
3034 * fdisk -s [partition] ...
3035 * fdisk [-b sectorsize] [-u] device
3037 * Options -C, -H, -S set the geometry.
3041 close_dev_fd(); /* needed: fd 3 must not stay closed */
3043 opt = getopt32(argv, "b:+C:+H:+lS:+u" IF_FEATURE_FDISK_BLKSIZE("s"),
3044 §or_size, &user_cylinders, &user_heads, &user_sectors);
3047 /* Ugly: this sector size is really per device,
3048 * so cannot be combined with multiple disks,
3049 * and the same goes for the C/H/S options.
3051 if (sector_size < 512
3052 || sector_size > 0x10000
3053 || (sector_size & (sector_size-1)) /* not power of 2 */
3058 user_set_sector_size = 1;
3060 if (user_heads <= 0 || user_heads >= 256)
3062 if (user_sectors <= 0 || user_sectors >= 64)
3065 display_in_cyl_units = 0; // -u
3067 #if ENABLE_FEATURE_FDISK_WRITABLE
3074 open_list_and_close(*argv, 1);
3077 /* we don't have device names, */
3078 /* use /proc/partitions instead */
3079 list_devs_in_proc_partititons();
3082 #if ENABLE_FEATURE_FDISK_WRITABLE
3086 #if ENABLE_FEATURE_FDISK_BLKSIZE
3093 for (j = 0; argv[j]; j++) {
3094 unsigned long long size;
3095 fd = xopen(argv[j], O_RDONLY);
3096 size = bb_BLKGETSIZE_sectors(fd) / 2;
3099 printf("%llu\n", size);
3101 printf("%s: %llu\n", argv[j], size);
3107 #if ENABLE_FEATURE_FDISK_WRITABLE
3108 if (!argv[0] || argv[1])
3111 disk_device = argv[0];
3112 get_boot(OPEN_MAIN);
3115 /* OSF label, and no DOS label */
3116 printf("Detected an OSF/1 disklabel on %s, entering "
3117 "disklabel mode\n", disk_device);
3119 /*Why do we do this? It seems to be counter-intuitive*/
3120 current_label_type = LABEL_DOS;
3121 /* If we return we may want to make an empty DOS label? */
3127 c = 0x20 | read_nonempty("Command (m for help): ");
3131 toggle_active(get_partition(1, g_partitions));
3132 else if (LABEL_IS_SUN)
3133 toggle_sunflags(get_partition(1, g_partitions),
3135 else if (LABEL_IS_SGI)
3136 sgi_set_bootpartition(
3137 get_partition(1, g_partitions));
3143 printf("\nThe current boot file is: %s\n",
3144 sgi_get_bootfile());
3145 if (read_maybe_empty("Please enter the name of the "
3146 "new boot file: ") == '\n')
3147 puts("Boot file unchanged");
3149 sgi_set_bootfile(line_ptr);
3151 #if ENABLE_FEATURE_OSF_LABEL
3158 toggle_dos_compatibility_flag();
3159 else if (LABEL_IS_SUN)
3160 toggle_sunflags(get_partition(1, g_partitions),
3162 else if (LABEL_IS_SGI)
3163 sgi_set_swappartition(
3164 get_partition(1, g_partitions));
3171 /* If sgi_label then don't use get_existing_partition,
3172 let the user select a partition, since
3173 get_existing_partition() only works for Linux-like
3175 if (!LABEL_IS_SGI) {
3176 j = get_existing_partition(1, g_partitions);
3178 j = get_partition(1, g_partitions);
3181 delete_partition(j);
3190 list_types(get_sys_types());
3205 if (ENABLE_FEATURE_CLEAN_UP)
3210 #if ENABLE_FEATURE_SUN_LABEL
3224 write_table(); /* does not return */
3226 #if ENABLE_FEATURE_FDISK_ADVANCED
3229 puts("\n\tSorry, no experts menu for SGI "
3230 "partition tables available\n");
3241 #endif /* FEATURE_FDISK_WRITABLE */