util-linux/fdisk.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * fdisk.c -- Partition table manipulator for Linux.
   4  *
   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)
   7  *
   8  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   9  */
  10 //config:config FDISK
  11 //config:       bool "fdisk (41 kb)"
  12 //config:       default y
  13 //config:       select PLATFORM_LINUX
  14 //config:       help
  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.
  19 //config:
  20 //config:config FDISK_SUPPORT_LARGE_DISKS
  21 //config:       bool "Support over 4GB disks"
  22 //config:       default y
  23 //config:       depends on FDISK
  24 //config:       depends on !LFS   # with LFS no special code is needed
  25 //config:
  26 //config:config FEATURE_FDISK_WRITABLE
  27 //config:       bool "Write support"
  28 //config:       default y
  29 //config:       depends on FDISK
  30 //config:       help
  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.
  34 //config:
  35 //config:config FEATURE_AIX_LABEL
  36 //config:       bool "Support AIX disklabels"
  37 //config:       default n
  38 //config:       depends on FDISK && FEATURE_FDISK_WRITABLE
  39 //config:       help
  40 //config:       Enabling this option allows you to create or change AIX disklabels.
  41 //config:       Most people can safely leave this option disabled.
  42 //config:
  43 //config:config FEATURE_SGI_LABEL
  44 //config:       bool "Support SGI disklabels"
  45 //config:       default n
  46 //config:       depends on FDISK && FEATURE_FDISK_WRITABLE
  47 //config:       help
  48 //config:       Enabling this option allows you to create or change SGI disklabels.
  49 //config:       Most people can safely leave this option disabled.
  50 //config:
  51 //config:config FEATURE_SUN_LABEL
  52 //config:       bool "Support SUN disklabels"
  53 //config:       default n
  54 //config:       depends on FDISK && FEATURE_FDISK_WRITABLE
  55 //config:       help
  56 //config:       Enabling this option allows you to create or change SUN disklabels.
  57 //config:       Most people can safely leave this option disabled.
  58 //config:
  59 //config:config FEATURE_OSF_LABEL
  60 //config:       bool "Support BSD disklabels"
  61 //config:       default n
  62 //config:       depends on FDISK && FEATURE_FDISK_WRITABLE
  63 //config:       help
  64 //config:       Enabling this option allows you to create or change BSD disklabels
  65 //config:       and define and edit BSD disk slices.
  66 //config:
  67 //config:config FEATURE_GPT_LABEL
  68 //config:       bool "Support GPT disklabels"
  69 //config:       default n
  70 //config:       depends on FDISK && FEATURE_FDISK_WRITABLE
  71 //config:       help
  72 //config:       Enabling this option allows you to view GUID Partition Table
  73 //config:       disklabels.
  74 //config:
  75 //config:config FEATURE_FDISK_ADVANCED
  76 //config:       bool "Support expert mode"
  77 //config:       default y
  78 //config:       depends on FDISK && FEATURE_FDISK_WRITABLE
  79 //config:       help
  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.
  84
  85 //applet:IF_FDISK(APPLET(fdisk, BB_DIR_SBIN, BB_SUID_DROP))
  86
  87 //kbuild:lib-$(CONFIG_FDISK) += fdisk.o
  88
  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)
  93 //usage:#endif
  94 //usage:
  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"
 104 //usage:        )
 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"
 109
 110 #ifndef _LARGEFILE64_SOURCE
 111 /* For lseek64 */
 112 # define _LARGEFILE64_SOURCE
 113 #endif
 114 #include <assert.h>             /* assert */
 115 #include <sys/mount.h>
 116 #if !defined(BLKSSZGET)
 117 # define BLKSSZGET _IO(0x12, 104)
 118 #endif
 119 #if !defined(BLKGETSIZE64)
 120 # define BLKGETSIZE64 _IOR(0x12,114,size_t)
 121 #endif
 122 #include "libbb.h"
 123 #include "unicode.h"
 124
 125 #if BB_LITTLE_ENDIAN
 126 # define inline_if_little_endian ALWAYS_INLINE
 127 #else
 128 # define inline_if_little_endian /* nothing */
 129 #endif
 130
 131
 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)
 136 #endif
 137
 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
 143
 144 #define ACTIVE_FLAG             0x80
 145
 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
 154
 155
 156 enum {
 157         OPT_b = 1 << 0,
 158         OPT_C = 1 << 1,
 159         OPT_H = 1 << 2,
 160         OPT_l = 1 << 3,
 161         OPT_S = 1 << 4,
 162         OPT_u = 1 << 5,
 163         OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
 164 };
 165
 166
 167 typedef unsigned long long ullong;
 168 /* Used for sector numbers. Partition formats we know
 169  * do not support more than 2^32 sectors
 170  */
 171 typedef uint32_t sector_t;
 172 #if UINT_MAX == 4294967295
 173 # define SECT_FMT ""
 174 #elif ULONG_MAX == 4294967295
 175 # define SECT_FMT "l"
 176 #else
 177 # error Cant detect sizeof(uint32_t)
 178 #endif
 179
 180 struct hd_geometry {
 181         unsigned char heads;
 182         unsigned char sectors;
 183         unsigned short cylinders;
 184         unsigned long start;
 185 };
 186
 187 #define HDIO_GETGEO     0x0301  /* get device geometry */
 188
 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";
 195
 196 static const char msg_part_already_defined[] ALIGN1 =
 197 "Partition %u is already defined, delete it before re-adding\n";
 198 /* #endif */
 199
 200
 201 struct partition {
 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 */
 212 } PACKED;
 213
 214 /*
 215  * per partition table entry data
 216  *
 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.
 221  */
 222 struct pte {
 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 */
 229 #endif
 230 };
 231
 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"
 235
 236 enum label_type {
 237         LABEL_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF, LABEL_GPT
 238 };
 239
 240 #define LABEL_IS_DOS    (LABEL_DOS == current_label_type)
 241
 242 #if ENABLE_FEATURE_SUN_LABEL
 243 #define LABEL_IS_SUN    (LABEL_SUN == current_label_type)
 244 #define STATIC_SUN static
 245 #else
 246 #define LABEL_IS_SUN    0
 247 #define STATIC_SUN extern
 248 #endif
 249
 250 #if ENABLE_FEATURE_SGI_LABEL
 251 #define LABEL_IS_SGI    (LABEL_SGI == current_label_type)
 252 #define STATIC_SGI static
 253 #else
 254 #define LABEL_IS_SGI    0
 255 #define STATIC_SGI extern
 256 #endif
 257
 258 #if ENABLE_FEATURE_AIX_LABEL
 259 #define LABEL_IS_AIX    (LABEL_AIX == current_label_type)
 260 #define STATIC_AIX static
 261 #else
 262 #define LABEL_IS_AIX    0
 263 #define STATIC_AIX extern
 264 #endif
 265
 266 #if ENABLE_FEATURE_OSF_LABEL
 267 #define LABEL_IS_OSF    (LABEL_OSF == current_label_type)
 268 #define STATIC_OSF static
 269 #else
 270 #define LABEL_IS_OSF    0
 271 #define STATIC_OSF extern
 272 #endif
 273
 274 #if ENABLE_FEATURE_GPT_LABEL
 275 #define LABEL_IS_GPT    (LABEL_GPT == current_label_type)
 276 #define STATIC_GPT static
 277 #else
 278 #define LABEL_IS_GPT    0
 279 #define STATIC_GPT extern
 280 #endif
 281
 282 enum action { OPEN_MAIN, TRY_ONLY, CREATE_EMPTY_DOS, CREATE_EMPTY_SUN };
 283
 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);
 292 #endif
 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);
 298 #else
 299 static int get_boot(void);
 300 #endif
 301
 302 #define PLURAL   0
 303 #define SINGULAR 1
 304
 305 static sector_t get_start_sect(const struct partition *p);
 306 static sector_t get_nr_sects(const struct partition *p);
 307
 308 /* DOS partition types */
 309
 310 static const char *const i386_sys_types[] = {
 311         "\x00" "Empty",
 312         "\x01" "FAT12",
 313         "\x04" "FAT16 <32M",
 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",
 332         "\x42" "SFS",
 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 */
 337         "\x83" "Linux",
 338         "\x84" "OS/2 hidden C: drive",
 339         "\x85" "Linux extended",
 340         "\x86" "NTFS volume set",
 341         "\x87" "NTFS volume set",
 342         "\x8e" "Linux LVM",
 343         "\x9f" "BSD/OS",           /* BSDI */
 344         "\xa0" "Thinkpad hibernation",
 345         "\xa5" "FreeBSD",          /* various BSD flavours */
 346         "\xa6" "OpenBSD",
 347         "\xa8" "Darwin UFS",
 348         "\xa9" "NetBSD",
 349         "\xab" "Darwin boot",
 350         "\xb7" "BSDI fs",
 351         "\xb8" "BSDI swap",
 352         "\xbe" "Solaris boot",
 353         "\xeb" "BeOS fs",
 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
 360                                                 superblock */
 361 #if 0 /* ENABLE_WEIRD_PARTITION_TYPES */
 362         "\x02" "XENIX root",
 363         "\x03" "XENIX usr",
 364         "\x08" "AIX",              /* AIX boot (AIX -- PS/2 port) or SplitDrive */
 365         "\x09" "AIX bootable",     /* AIX data or Coherent */
 366         "\x10" "OPUS",
 367         "\x18" "AST SmartSleep",
 368         "\x24" "NEC DOS",
 369         "\x39" "Plan 9",
 370         "\x40" "Venix 80286",
 371         "\x4d" "QNX4.x",
 372         "\x4e" "QNX4.x 2nd part",
 373         "\x4f" "QNX4.x 3rd part",
 374         "\x50" "OnTrack DM",
 375         "\x51" "OnTrack DM6 Aux1", /* (or Novell) */
 376         "\x52" "CP/M",             /* CP/M or Microport SysV/AT */
 377         "\x53" "OnTrack DM6 Aux3",
 378         "\x54" "OnTrackDM6",
 379         "\x55" "EZ-Drive",
 380         "\x56" "Golden Bow",
 381         "\x5c" "Priam Edisk",
 382         "\x61" "SpeedStor",
 383         "\x64" "Novell Netware 286",
 384         "\x65" "Novell Netware 386",
 385         "\x70" "DiskSecure Multi-Boot",
 386         "\x75" "PC/IX",
 387         "\x93" "Amoeba",
 388         "\x94" "Amoeba BBT",       /* (bad block table) */
 389         "\xa7" "NeXTSTEP",
 390         "\xbb" "Boot Wizard hidden",
 391         "\xc1" "DRDOS/sec (FAT-12)",
 392         "\xc4" "DRDOS/sec (FAT-16 < 32M)",
 393         "\xc6" "DRDOS/sec (FAT-16)",
 394         "\xc7" "Syrinx",
 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. */
 405         "\xf1" "SpeedStor",
 406         "\xf4" "SpeedStor",        /* SpeedStor large partition */
 407         "\xfe" "LANstep",          /* SpeedStor >1024 cyl. or LANstep */
 408         "\xff" "BBT",              /* Xenix Bad Block Table */
 409 #endif
 410         NULL
 411 };
 412
 413 enum {
 414         dev_fd = 3                  /* the disk */
 415 };
 416
 417 /* Globals */
 418 struct globals {
 419         char *line_ptr;
 420
 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; // = 1;
 430 #if ENABLE_FEATURE_OSF_LABEL
 431         smallint possibly_osf_label;
 432 #endif
 433
 434         smallint listing;               /* no aborts for fdisk -l */
 435         smallint dos_compatible_flag; // = 1;
 436 #if ENABLE_FEATURE_FDISK_WRITABLE
 437         //int dos_changed;
 438         smallint nowarn;                /* no warnings for fdisk -l/-s */
 439 #endif
 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;
 446
 447         jmp_buf listingbuf;
 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];
 454 };
 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; \
 489         sector_offset = 1; \
 490         g_partitions = 4; \
 491         display_in_cyl_units = 1; \
 492         units_per_sector = 1; \
 493         dos_compatible_flag = 1; \
 494 } while (0)
 495
 496
 497 /* TODO: move to libbb? */
 498 /* TODO: return unsigned long long, FEATURE_FDISK_BLKSIZE _can_ handle
 499  * disks > 2^32 sectors
 500  */
 501 static sector_t bb_BLKGETSIZE_sectors(int fd)
 502 {
 503         uint64_t v64;
 504         unsigned long longsectors;
 505
 506         if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
 507                 /* Got bytes, convert to 512 byte sectors */
 508                 v64 >>= 9;
 509                 if (v64 != (sector_t)v64) {
 510  ret_trunc:
 511                         /* Not only DOS, but all other partition tables
 512                          * we support can't record more than 32 bit
 513                          * sector counts or offsets
 514                          */
 515                         bb_error_msg("device has more than 2^32 sectors, can't use all of them");
 516                         v64 = (uint32_t)-1L;
 517                 }
 518                 return v64;
 519         }
 520         /* Needs temp of type long */
 521         if (ioctl(fd, BLKGETSIZE, &longsectors)) {
 522                 /* Perhaps this is a disk image */
 523                 off_t sz = lseek(fd, 0, SEEK_END);
 524                 longsectors = 0;
 525                 if (sz > 0)
 526                         longsectors = (uoff_t)sz / sector_size;
 527                 lseek(fd, 0, SEEK_SET);
 528         }
 529         if (sizeof(long) > sizeof(sector_t)
 530          && longsectors != (sector_t)longsectors
 531         ) {
 532                 goto ret_trunc;
 533         }
 534         return longsectors;
 535 }
 536
 537
 538 #define IS_EXTENDED(i) \
 539         ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
 540
 541 #define cround(n)       (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
 542
 543 #define scround(x)      (((x)+units_per_sector-1)/units_per_sector)
 544
 545 #define pt_offset(b, n) \
 546         ((struct partition *)((b) + 0x1be + (n) * sizeof(struct partition)))
 547
 548 #define sector(s)       ((s) & 0x3f)
 549
 550 #define cylinder(s, c)  ((c) | (((s) & 0xc0) << 2))
 551
 552 static void
 553 close_dev_fd(void)
 554 {
 555         /* Not really closing, but making sure it is open, and to harmless place */
 556         xmove_fd(xopen(bb_dev_null, O_RDONLY), dev_fd);
 557 }
 558
 559 /* Return partition name */
 560 static const char *
 561 partname(const char *dev, int pno, int lth)
 562 {
 563         const char *p;
 564         int w, wp;
 565         int bufsiz;
 566         char *bufp;
 567
 568         bufp = auto_string(xzalloc(80));
 569         bufsiz = 80;
 570
 571         w = strlen(dev);
 572         p = "";
 573
 574         if (isdigit(dev[w-1]))
 575                 p = "p";
 576
 577         /* devfs kludge - note: fdisk partition names are not supposed
 578            to equal kernel names, so there is no reason to do this */
 579         if (strcmp(dev + w - 4, "disc") == 0) {
 580                 w -= 4;
 581                 p = "part";
 582         }
 583
 584         wp = strlen(p);
 585
 586         if (lth) {
 587                 snprintf(bufp, bufsiz, "%*.*s%s%-2u",
 588                         lth-wp-2, w, dev, p, pno);
 589         } else {
 590                 snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
 591         }
 592         return bufp;
 593 }
 594
 595 static ALWAYS_INLINE struct partition *
 596 get_part_table(int i)
 597 {
 598         return ptes[i].part_table;
 599 }
 600
 601 static const char *
 602 str_units(int n)
 603 {      /* n==1: use singular */
 604         if (n == 1)
 605                 return display_in_cyl_units ? "cylinder" : "sector";
 606         return display_in_cyl_units ? "cylinders" : "sectors";
 607 }
 608
 609 static int
 610 valid_part_table_flag(const char *mbuffer)
 611 {
 612         return (mbuffer[510] == 0x55 && (uint8_t)mbuffer[511] == 0xaa);
 613 }
 614
 615 static void fdisk_fatal(const char *why)
 616 {
 617         if (listing) {
 618                 close_dev_fd();
 619                 longjmp(listingbuf, 1);
 620         }
 621         bb_error_msg_and_die(why, disk_device);
 622 }
 623
 624 static void
 625 seek_sector(sector_t secno)
 626 {
 627 #if ENABLE_FDISK_SUPPORT_LARGE_DISKS
 628         off64_t off = (off64_t)secno * sector_size;
 629         if (lseek64(dev_fd, off, SEEK_SET) == (off64_t) -1)
 630                 fdisk_fatal(unable_to_seek);
 631 #else
 632         uint64_t off = (uint64_t)secno * sector_size;
 633         if (off > MAXINT(off_t)
 634          || lseek(dev_fd, (off_t)off, SEEK_SET) == (off_t) -1
 635         ) {
 636                 fdisk_fatal(unable_to_seek);
 637         }
 638 #endif
 639 }
 640
 641 #if ENABLE_FEATURE_FDISK_WRITABLE
 642 /* Read line; return 0 or first printable char */
 643 static int
 644 read_line(const char *prompt)
 645 {
 646         int sz;
 647
 648         sz = read_line_input(NULL, prompt, line_buffer, sizeof(line_buffer));
 649         if (sz <= 0)
 650                 exit(EXIT_SUCCESS); /* Ctrl-D or Ctrl-C */
 651
 652         if (line_buffer[sz-1] == '\n')
 653                 line_buffer[--sz] = '\0';
 654
 655         line_ptr = line_buffer;
 656         while (*line_ptr != '\0' && (unsigned char)*line_ptr <= ' ')
 657                 line_ptr++;
 658         return *line_ptr;
 659 }
 660
 661 static void
 662 set_all_unchanged(void)
 663 {
 664         int i;
 665
 666         for (i = 0; i < MAXIMUM_PARTS; i++)
 667                 ptes[i].changed = 0;
 668 }
 669
 670 static ALWAYS_INLINE void
 671 set_changed(int i)
 672 {
 673         ptes[i].changed = 1;
 674 }
 675
 676 static ALWAYS_INLINE void
 677 write_part_table_flag(char *b)
 678 {
 679         b[510] = 0x55;
 680         b[511] = 0xaa;
 681 }
 682
 683 static char
 684 read_nonempty(const char *mesg)
 685 {
 686         while (!read_line(mesg))
 687                 continue;
 688         return *line_ptr;
 689 }
 690
 691 static char
 692 read_maybe_empty(const char *mesg)
 693 {
 694         if (!read_line(mesg)) {
 695                 line_ptr = line_buffer;
 696                 line_ptr[0] = '\n';
 697                 line_ptr[1] = '\0';
 698         }
 699         return line_ptr[0];
 700 }
 701
 702 static int
 703 read_hex(const char *const *sys)
 704 {
 705         unsigned long v;
 706         while (1) {
 707                 read_nonempty("Hex code (type L to list codes): ");
 708                 if ((line_ptr[0] | 0x20) == 'l') {
 709                         list_types(sys);
 710                         continue;
 711                 }
 712                 v = bb_strtoul(line_ptr, NULL, 16);
 713                 if (v <= 0xff)
 714                         return v;
 715         }
 716 }
 717
 718 static void
 719 write_sector(sector_t secno, const void *buf)
 720 {
 721         seek_sector(secno);
 722         xwrite(dev_fd, buf, sector_size);
 723 }
 724 #endif /* FEATURE_FDISK_WRITABLE */
 725
 726
 727 #include "fdisk_aix.c"
 728
 729 struct sun_partition {
 730         unsigned char info[128];   /* Informative text string */
 731         unsigned char spare0[14];
 732         struct sun_info {
 733                 unsigned char spare1;
 734                 unsigned char id;
 735                 unsigned char spare2;
 736                 unsigned char flags;
 737         } infos[8];
 738         unsigned char spare1[246]; /* Boot information etc. */
 739         unsigned short rspeed;     /* Disk rotational speed */
 740         unsigned short pcylcount;  /* Physical cylinder count */
 741         unsigned short sparecyl;   /* extra sects per cylinder */
 742         unsigned char spare2[4];   /* More magic... */
 743         unsigned short ilfact;     /* Interleave factor */
 744         unsigned short ncyl;       /* Data cylinder count */
 745         unsigned short nacyl;      /* Alt. cylinder count */
 746         unsigned short ntrks;      /* Tracks per cylinder */
 747         unsigned short nsect;      /* Sectors per track */
 748         unsigned char spare3[4];   /* Even more magic... */
 749         struct sun_partinfo {
 750                 uint32_t start_cylinder;
 751                 uint32_t num_sectors;
 752         } partitions[8];
 753         unsigned short magic;      /* Magic number */
 754         unsigned short csum;       /* Label xor'd checksum */
 755 } FIX_ALIASING;
 756 typedef struct sun_partition sun_partition;
 757 #define sunlabel ((sun_partition *)MBRbuffer)
 758 STATIC_OSF void bsd_select(void);
 759 STATIC_OSF void xbsd_print_disklabel(int);
 760 #include "fdisk_osf.c"
 761
 762 STATIC_GPT void gpt_list_table(int xtra);
 763 #include "fdisk_gpt.c"
 764
 765 #if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL
 766 static uint16_t
 767 fdisk_swap16(uint16_t x)
 768 {
 769         return (x << 8) | (x >> 8);
 770 }
 771
 772 static uint32_t
 773 fdisk_swap32(uint32_t x)
 774 {
 775         return (x << 24) |
 776                ((x & 0xFF00) << 8) |
 777                ((x & 0xFF0000) >> 8) |
 778                (x >> 24);
 779 }
 780 #endif
 781
 782 STATIC_SGI const char *const sgi_sys_types[];
 783 STATIC_SGI unsigned sgi_get_num_sectors(int i);
 784 STATIC_SGI int sgi_get_sysid(int i);
 785 STATIC_SGI void sgi_delete_partition(int i);
 786 STATIC_SGI void sgi_change_sysid(int i, int sys);
 787 STATIC_SGI void sgi_list_table(int xtra);
 788 #if ENABLE_FEATURE_FDISK_ADVANCED
 789 STATIC_SGI void sgi_set_xcyl(void);
 790 #endif
 791 STATIC_SGI int verify_sgi(int verbose);
 792 STATIC_SGI void sgi_add_partition(int n, int sys);
 793 STATIC_SGI void sgi_set_swappartition(int i);
 794 STATIC_SGI const char *sgi_get_bootfile(void);
 795 STATIC_SGI void sgi_set_bootfile(const char* aFile);
 796 STATIC_SGI void create_sgiinfo(void);
 797 STATIC_SGI void sgi_write_table(void);
 798 STATIC_SGI void sgi_set_bootpartition(int i);
 799 #include "fdisk_sgi.c"
 800
 801 STATIC_SUN const char *const sun_sys_types[];
 802 STATIC_SUN void sun_delete_partition(int i);
 803 STATIC_SUN void sun_change_sysid(int i, int sys);
 804 STATIC_SUN void sun_list_table(int xtra);
 805 STATIC_SUN void add_sun_partition(int n, int sys);
 806 #if ENABLE_FEATURE_FDISK_ADVANCED
 807 STATIC_SUN void sun_set_alt_cyl(void);
 808 STATIC_SUN void sun_set_ncyl(int cyl);
 809 STATIC_SUN void sun_set_xcyl(void);
 810 STATIC_SUN void sun_set_ilfact(void);
 811 STATIC_SUN void sun_set_rspeed(void);
 812 STATIC_SUN void sun_set_pcylcount(void);
 813 #endif
 814 STATIC_SUN void toggle_sunflags(int i, unsigned char mask);
 815 STATIC_SUN void verify_sun(void);
 816 STATIC_SUN void sun_write_table(void);
 817 #include "fdisk_sun.c"
 818
 819
 820 static inline_if_little_endian unsigned
 821 read4_little_endian(const unsigned char *cp)
 822 {
 823         uint32_t v;
 824         move_from_unaligned32(v, cp);
 825         return SWAP_LE32(v);
 826 }
 827
 828 static sector_t
 829 get_start_sect(const struct partition *p)
 830 {
 831         return read4_little_endian(p->start4);
 832 }
 833
 834 static sector_t
 835 get_nr_sects(const struct partition *p)
 836 {
 837         return read4_little_endian(p->size4);
 838 }
 839
 840 #if ENABLE_FEATURE_FDISK_WRITABLE
 841 /* start_sect and nr_sects are stored little endian on all machines */
 842 /* moreover, they are not aligned correctly */
 843 static inline_if_little_endian void
 844 store4_little_endian(unsigned char *cp, unsigned val)
 845 {
 846         uint32_t v = SWAP_LE32(val);
 847         move_to_unaligned32(cp, v);
 848 }
 849
 850 static void
 851 set_start_sect(struct partition *p, unsigned start_sect)
 852 {
 853         store4_little_endian(p->start4, start_sect);
 854 }
 855
 856 static void
 857 set_nr_sects(struct partition *p, unsigned nr_sects)
 858 {
 859         store4_little_endian(p->size4, nr_sects);
 860 }
 861 #endif
 862
 863 /* Allocate a buffer and read a partition table sector */
 864 static void
 865 read_pte(struct pte *pe, sector_t offset)
 866 {
 867         pe->offset_from_dev_start = offset;
 868         pe->sectorbuffer = xzalloc(sector_size);
 869         seek_sector(offset);
 870         /* xread would make us abort - bad for fdisk -l */
 871         if (full_read(dev_fd, pe->sectorbuffer, sector_size) != sector_size)
 872                 fdisk_fatal(unable_to_read);
 873 #if ENABLE_FEATURE_FDISK_WRITABLE
 874         pe->changed = 0;
 875 #endif
 876         pe->part_table = pe->ext_pointer = NULL;
 877 }
 878
 879 static sector_t
 880 get_partition_start_from_dev_start(const struct pte *pe)
 881 {
 882         return pe->offset_from_dev_start + get_start_sect(pe->part_table);
 883 }
 884
 885 #if ENABLE_FEATURE_FDISK_WRITABLE
 886 /*
 887  * Avoid warning about DOS partitions when no DOS partition was changed.
 888  * Here a heuristic "is probably dos partition".
 889  * We might also do the opposite and warn in all cases except
 890  * for "is probably nondos partition".
 891  */
 892 #ifdef UNUSED
 893 static int
 894 is_dos_partition(int t)
 895 {
 896         return (t == 1 || t == 4 || t == 6 ||
 897                 t == 0x0b || t == 0x0c || t == 0x0e ||
 898                 t == 0x11 || t == 0x12 || t == 0x14 || t == 0x16 ||
 899                 t == 0x1b || t == 0x1c || t == 0x1e || t == 0x24 ||
 900                 t == 0xc1 || t == 0xc4 || t == 0xc6);
 901 }
 902 #endif
 903
 904 static void
 905 menu(void)
 906 {
 907         puts("Command Action");
 908         if (LABEL_IS_SUN) {
 909                 puts("a\ttoggle a read only flag");           /* sun */
 910                 puts("b\tedit bsd disklabel");
 911                 puts("c\ttoggle the mountable flag");         /* sun */
 912                 puts("d\tdelete a partition");
 913                 puts("l\tlist known partition types");
 914                 puts("n\tadd a new partition");
 915                 puts("o\tcreate a new empty DOS partition table");
 916                 puts("p\tprint the partition table");
 917                 puts("q\tquit without saving changes");
 918                 puts("s\tcreate a new empty Sun disklabel");  /* sun */
 919                 puts("t\tchange a partition's system id");
 920                 puts("u\tchange display/entry units");
 921                 puts("v\tverify the partition table");
 922                 puts("w\twrite table to disk and exit");
 923 #if ENABLE_FEATURE_FDISK_ADVANCED
 924                 puts("x\textra functionality (experts only)");
 925 #endif
 926         } else if (LABEL_IS_SGI) {
 927                 puts("a\tselect bootable partition");    /* sgi flavour */
 928                 puts("b\tedit bootfile entry");          /* sgi */
 929                 puts("c\tselect sgi swap partition");    /* sgi flavour */
 930                 puts("d\tdelete a partition");
 931                 puts("l\tlist known partition types");
 932                 puts("n\tadd a new partition");
 933                 puts("o\tcreate a new empty DOS partition table");
 934                 puts("p\tprint the partition table");
 935                 puts("q\tquit without saving changes");
 936                 puts("s\tcreate a new empty Sun disklabel");  /* sun */
 937                 puts("t\tchange a partition's system id");
 938                 puts("u\tchange display/entry units");
 939                 puts("v\tverify the partition table");
 940                 puts("w\twrite table to disk and exit");
 941         } else if (LABEL_IS_AIX) {
 942                 puts("o\tcreate a new empty DOS partition table");
 943                 puts("q\tquit without saving changes");
 944                 puts("s\tcreate a new empty Sun disklabel");  /* sun */
 945         } else if (LABEL_IS_GPT) {
 946                 puts("o\tcreate a new empty DOS partition table");
 947                 puts("p\tprint the partition table");
 948                 puts("q\tquit without saving changes");
 949                 puts("s\tcreate a new empty Sun disklabel");  /* sun */
 950         } else {
 951                 puts("a\ttoggle a bootable flag");
 952                 puts("b\tedit bsd disklabel");
 953                 puts("c\ttoggle the dos compatibility flag");
 954                 puts("d\tdelete a partition");
 955                 puts("l\tlist known partition types");
 956                 puts("n\tadd a new partition");
 957                 puts("o\tcreate a new empty DOS partition table");
 958                 puts("p\tprint the partition table");
 959                 puts("q\tquit without saving changes");
 960                 puts("s\tcreate a new empty Sun disklabel");  /* sun */
 961                 puts("t\tchange a partition's system id");
 962                 puts("u\tchange display/entry units");
 963                 puts("v\tverify the partition table");
 964                 puts("w\twrite table to disk and exit");
 965 #if ENABLE_FEATURE_FDISK_ADVANCED
 966                 puts("x\textra functionality (experts only)");
 967 #endif
 968         }
 969 }
 970 #endif /* FEATURE_FDISK_WRITABLE */
 971
 972
 973 #if ENABLE_FEATURE_FDISK_ADVANCED
 974 static void
 975 xmenu(void)
 976 {
 977         puts("Command Action");
 978         if (LABEL_IS_SUN) {
 979                 puts("a\tchange number of alternate cylinders");      /*sun*/
 980                 puts("c\tchange number of cylinders");
 981                 puts("d\tprint the raw data in the partition table");
 982                 puts("e\tchange number of extra sectors per cylinder");/*sun*/
 983                 puts("h\tchange number of heads");
 984                 puts("i\tchange interleave factor");                  /*sun*/
 985                 puts("o\tchange rotation speed (rpm)");               /*sun*/
 986                 puts("p\tprint the partition table");
 987                 puts("q\tquit without saving changes");
 988                 puts("r\treturn to main menu");
 989                 puts("s\tchange number of sectors/track");
 990                 puts("v\tverify the partition table");
 991                 puts("w\twrite table to disk and exit");
 992                 puts("y\tchange number of physical cylinders");       /*sun*/
 993         } else if (LABEL_IS_SGI) {
 994                 puts("b\tmove beginning of data in a partition"); /* !sun */
 995                 puts("c\tchange number of cylinders");
 996                 puts("d\tprint the raw data in the partition table");
 997                 puts("e\tlist extended partitions");          /* !sun */
 998                 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
 999                 puts("h\tchange number of heads");
1000                 puts("p\tprint the partition table");
1001                 puts("q\tquit without saving changes");
1002                 puts("r\treturn to main menu");
1003                 puts("s\tchange number of sectors/track");
1004                 puts("v\tverify the partition table");
1005                 puts("w\twrite table to disk and exit");
1006         } else if (LABEL_IS_AIX) {
1007                 puts("b\tmove beginning of data in a partition"); /* !sun */
1008                 puts("c\tchange number of cylinders");
1009                 puts("d\tprint the raw data in the partition table");
1010                 puts("e\tlist extended partitions");          /* !sun */
1011                 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
1012                 puts("h\tchange number of heads");
1013                 puts("p\tprint the partition table");
1014                 puts("q\tquit without saving changes");
1015                 puts("r\treturn to main menu");
1016                 puts("s\tchange number of sectors/track");
1017                 puts("v\tverify the partition table");
1018                 puts("w\twrite table to disk and exit");
1019         } else {
1020                 puts("b\tmove beginning of data in a partition"); /* !sun */
1021                 puts("c\tchange number of cylinders");
1022                 puts("d\tprint the raw data in the partition table");
1023                 puts("e\tlist extended partitions");          /* !sun */
1024                 puts("f\tfix partition order");               /* !sun, !aix, !sgi */
1025 #if ENABLE_FEATURE_SGI_LABEL
1026                 puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
1027 #endif
1028                 puts("h\tchange number of heads");
1029                 puts("p\tprint the partition table");
1030                 puts("q\tquit without saving changes");
1031                 puts("r\treturn to main menu");
1032                 puts("s\tchange number of sectors/track");
1033                 puts("v\tverify the partition table");
1034                 puts("w\twrite table to disk and exit");
1035         }
1036 }
1037 #endif /* ADVANCED mode */
1038
1039 #if ENABLE_FEATURE_FDISK_WRITABLE
1040 static const char *const *
1041 get_sys_types(void)
1042 {
1043         return (
1044                 LABEL_IS_SUN ? sun_sys_types :
1045                 LABEL_IS_SGI ? sgi_sys_types :
1046                 i386_sys_types);
1047 }
1048 #else
1049 #define get_sys_types() i386_sys_types
1050 #endif
1051
1052 static const char *
1053 partition_type(unsigned char type)
1054 {
1055         int i;
1056         const char *const *types = get_sys_types();
1057
1058         for (i = 0; types[i]; i++)
1059                 if ((unsigned char)types[i][0] == type)
1060                         return types[i] + 1;
1061
1062         return "Unknown";
1063 }
1064
1065 static int
1066 is_cleared_partition(const struct partition *p)
1067 {
1068         /* We consider partition "cleared" only if it has only zeros */
1069         const char *cp = (const char *)p;
1070         int cnt = sizeof(*p);
1071         char bits = 0;
1072         while (--cnt >= 0)
1073                 bits |= *cp++;
1074         return (bits == 0);
1075 }
1076
1077 static void
1078 clear_partition(struct partition *p)
1079 {
1080         if (p)
1081                 memset(p, 0, sizeof(*p));
1082 }
1083
1084 #if ENABLE_FEATURE_FDISK_WRITABLE
1085 static int
1086 get_sysid(int i)
1087 {
1088         return LABEL_IS_SUN ? sunlabel->infos[i].id :
1089                         (LABEL_IS_SGI ? sgi_get_sysid(i) :
1090                                 ptes[i].part_table->sys_ind);
1091 }
1092
1093 static void
1094 list_types(const char *const *sys)
1095 {
1096         enum { COLS = 3 };
1097
1098         unsigned last[COLS];
1099         unsigned done, next, size;
1100         int i;
1101
1102         for (size = 0; sys[size]; size++)
1103                 continue;
1104
1105         done = 0;
1106         for (i = COLS-1; i >= 0; i--) {
1107                 done += (size + i - done) / (i + 1);
1108                 last[COLS-1 - i] = done;
1109         }
1110
1111         i = done = next = 0;
1112         do {
1113                 printf("%c%2x %-22.22s", i ? ' ' : '\n',
1114                         (unsigned char)sys[next][0],
1115                         sys[next] + 1);
1116                 next = last[i++] + done;
1117                 if (i >= COLS || next >= last[i]) {
1118                         i = 0;
1119                         next = ++done;
1120                 }
1121         } while (done < last[0]);
1122         bb_putchar('\n');
1123 }
1124
1125 #define set_hsc(h, s, c, sector) do \
1126 { \
1127         s = sector % g_sectors + 1;  \
1128         sector /= g_sectors;         \
1129         h = sector % g_heads;        \
1130         sector /= g_heads;           \
1131         c = sector & 0xff;           \
1132         s |= (sector >> 2) & 0xc0;   \
1133 } while (0)
1134
1135 static void set_hsc_start_end(struct partition *p, sector_t start, sector_t stop)
1136 {
1137         if (dos_compatible_flag && (start / (g_sectors * g_heads) > 1023))
1138                 start = g_heads * g_sectors * 1024 - 1;
1139         set_hsc(p->head, p->sector, p->cyl, start);
1140
1141         if (dos_compatible_flag && (stop / (g_sectors * g_heads) > 1023))
1142                 stop = g_heads * g_sectors * 1024 - 1;
1143         set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
1144 }
1145
1146 static void
1147 set_partition(int i, int doext, sector_t start, sector_t stop, int sysid)
1148 {
1149         struct partition *p;
1150         sector_t offset;
1151
1152         if (doext) {
1153                 p = ptes[i].ext_pointer;
1154                 offset = extended_offset;
1155         } else {
1156                 p = ptes[i].part_table;
1157                 offset = ptes[i].offset_from_dev_start;
1158         }
1159         p->boot_ind = 0;
1160         p->sys_ind = sysid;
1161         set_start_sect(p, start - offset);
1162         set_nr_sects(p, stop - start + 1);
1163         set_hsc_start_end(p, start, stop);
1164         ptes[i].changed = 1;
1165 }
1166 #endif
1167
1168 static int
1169 warn_geometry(void)
1170 {
1171         if (g_heads && g_sectors && g_cylinders)
1172                 return 0;
1173
1174         printf("Unknown value(s) for:");
1175         if (!g_heads)
1176                 printf(" heads");
1177         if (!g_sectors)
1178                 printf(" sectors");
1179         if (!g_cylinders)
1180                 printf(" cylinders");
1181 #if ENABLE_FEATURE_FDISK_WRITABLE
1182         puts(" (settable in the extra functions menu)");
1183 #else
1184         bb_putchar('\n');
1185 #endif
1186         return 1;
1187 }
1188
1189 static void
1190 update_units(void)
1191 {
1192         int cyl_units = g_heads * g_sectors;
1193
1194         if (display_in_cyl_units && cyl_units)
1195                 units_per_sector = cyl_units;
1196         else
1197                 units_per_sector = 1;   /* in sectors */
1198 }
1199
1200 #if ENABLE_FEATURE_FDISK_WRITABLE
1201 static void
1202 warn_cylinders(void)
1203 {
1204         if (LABEL_IS_DOS && g_cylinders > 1024 && !nowarn)
1205                 printf("\n"
1206 "The number of cylinders for this disk is set to %u.\n"
1207 "There is nothing wrong with that, but this is larger than 1024,\n"
1208 "and could in certain setups cause problems with:\n"
1209 "1) software that runs at boot time (e.g., old versions of LILO)\n"
1210 "2) booting and partitioning software from other OSs\n"
1211 "   (e.g., DOS FDISK, OS/2 FDISK)\n",
1212                         g_cylinders);
1213 }
1214 #endif
1215
1216 static void
1217 read_extended(int ext)
1218 {
1219         int i;
1220         struct pte *pex;
1221         struct partition *p, *q;
1222
1223         ext_index = ext;
1224         pex = &ptes[ext];
1225         pex->ext_pointer = pex->part_table;
1226
1227         p = pex->part_table;
1228         if (!get_start_sect(p)) {
1229                 puts("Bad offset in primary extended partition");
1230                 return;
1231         }
1232
1233         while (IS_EXTENDED(p->sys_ind)) {
1234                 struct pte *pe = &ptes[g_partitions];
1235
1236                 if (g_partitions >= MAXIMUM_PARTS) {
1237                         /* This is not a Linux restriction, but
1238                            this program uses arrays of size MAXIMUM_PARTS.
1239                            Do not try to 'improve' this test. */
1240                         struct pte *pre = &ptes[g_partitions - 1];
1241 #if ENABLE_FEATURE_FDISK_WRITABLE
1242                         printf("Warning: deleting partitions after %u\n",
1243                                 g_partitions);
1244                         pre->changed = 1;
1245 #endif
1246                         clear_partition(pre->ext_pointer);
1247                         return;
1248                 }
1249
1250                 read_pte(pe, extended_offset + get_start_sect(p));
1251
1252                 if (!extended_offset)
1253                         extended_offset = get_start_sect(p);
1254
1255                 q = p = pt_offset(pe->sectorbuffer, 0);
1256                 for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) {
1257                         if (IS_EXTENDED(p->sys_ind)) {
1258                                 if (pe->ext_pointer)
1259                                         printf("Warning: extra link "
1260                                                 "pointer in partition table"
1261                                                 " %u\n", g_partitions + 1);
1262                                 else
1263                                         pe->ext_pointer = p;
1264                         } else if (p->sys_ind) {
1265                                 if (pe->part_table)
1266                                         printf("Warning: ignoring extra "
1267                                                   "data in partition table"
1268                                                   " %u\n", g_partitions + 1);
1269                                 else
1270                                         pe->part_table = p;
1271                         }
1272                 }
1273
1274                 /* very strange code here... */
1275                 if (!pe->part_table) {
1276                         if (q != pe->ext_pointer)
1277                                 pe->part_table = q;
1278                         else
1279                                 pe->part_table = q + 1;
1280                 }
1281                 if (!pe->ext_pointer) {
1282                         if (q != pe->part_table)
1283                                 pe->ext_pointer = q;
1284                         else
1285                                 pe->ext_pointer = q + 1;
1286                 }
1287
1288                 p = pe->ext_pointer;
1289                 g_partitions++;
1290         }
1291
1292 #if ENABLE_FEATURE_FDISK_WRITABLE
1293         /* remove empty links */
1294  remove:
1295         for (i = 4; i < g_partitions; i++) {
1296                 struct pte *pe = &ptes[i];
1297
1298                 if (!get_nr_sects(pe->part_table)
1299                  && (g_partitions > 5 || ptes[4].part_table->sys_ind)
1300                 ) {
1301                         printf("Omitting empty partition (%u)\n", i+1);
1302                         delete_partition(i);
1303                         goto remove;    /* numbering changed */
1304                 }
1305         }
1306 #endif
1307 }
1308
1309 #if ENABLE_FEATURE_FDISK_WRITABLE
1310 static void
1311 create_doslabel(void)
1312 {
1313         printf(msg_building_new_label, "DOS disklabel");
1314
1315         current_label_type = LABEL_DOS;
1316 #if ENABLE_FEATURE_OSF_LABEL
1317         possibly_osf_label = 0;
1318 #endif
1319         g_partitions = 4;
1320
1321         memset(&MBRbuffer[510 - 4*16], 0, 4*16);
1322         write_part_table_flag(MBRbuffer);
1323         extended_offset = 0;
1324         set_all_unchanged();
1325         set_changed(0);
1326         get_boot(CREATE_EMPTY_DOS);
1327 }
1328 #endif
1329
1330 static void
1331 get_sectorsize(void)
1332 {
1333         if (!user_set_sector_size) {
1334                 int arg;
1335                 if (ioctl(dev_fd, BLKSSZGET, &arg) == 0)
1336                         sector_size = arg;
1337                 if (sector_size != DEFAULT_SECTOR_SIZE)
1338                         printf("Note: sector size is %u "
1339                                 "(not " DEFAULT_SECTOR_SIZE_STR ")\n",
1340                                 sector_size);
1341         }
1342 }
1343
1344 static void
1345 get_kernel_geometry(void)
1346 {
1347         struct hd_geometry geometry;
1348
1349         if (!ioctl(dev_fd, HDIO_GETGEO, &geometry)) {
1350                 kern_heads = geometry.heads;
1351                 kern_sectors = geometry.sectors;
1352                 /* never use geometry.cylinders - it is truncated */
1353         }
1354 }
1355
1356 static void
1357 get_partition_table_geometry(void)
1358 {
1359         const unsigned char *bufp = (const unsigned char *)MBRbuffer;
1360         struct partition *p;
1361         int i, h, s, hh, ss;
1362         int first = 1;
1363         int bad = 0;
1364
1365         if (!(valid_part_table_flag((char*)bufp)))
1366                 return;
1367
1368         hh = ss = 0;
1369         for (i = 0; i < 4; i++) {
1370                 p = pt_offset(bufp, i);
1371                 if (p->sys_ind != 0) {
1372                         h = p->end_head + 1;
1373                         s = (p->end_sector & 077);
1374                         if (first) {
1375                                 hh = h;
1376                                 ss = s;
1377                                 first = 0;
1378                         } else if (hh != h || ss != s)
1379                                 bad = 1;
1380                 }
1381         }
1382
1383         if (!first && !bad) {
1384                 pt_heads = hh;
1385                 pt_sectors = ss;
1386         }
1387 }
1388
1389 static void
1390 get_geometry(void)
1391 {
1392         int sec_fac;
1393
1394         get_sectorsize();
1395         sec_fac = sector_size / 512;
1396 #if ENABLE_FEATURE_SUN_LABEL
1397         guess_device_type();
1398 #endif
1399         g_heads = g_cylinders = g_sectors = 0;
1400         kern_heads = kern_sectors = 0;
1401         pt_heads = pt_sectors = 0;
1402
1403         get_kernel_geometry();
1404         get_partition_table_geometry();
1405
1406         g_heads = user_heads ? user_heads :
1407                 pt_heads ? pt_heads :
1408                 kern_heads ? kern_heads : 255;
1409         g_sectors = user_sectors ? user_sectors :
1410                 pt_sectors ? pt_sectors :
1411                 kern_sectors ? kern_sectors : 63;
1412         total_number_of_sectors = bb_BLKGETSIZE_sectors(dev_fd);
1413
1414         sector_offset = 1;
1415         if (dos_compatible_flag)
1416                 sector_offset = g_sectors;
1417
1418         g_cylinders = total_number_of_sectors / (g_heads * g_sectors * sec_fac);
1419         if (!g_cylinders)
1420                 g_cylinders = user_cylinders;
1421 }
1422
1423 /*
1424  * Opens disk_device and optionally reads MBR.
1425  *    If what == OPEN_MAIN:
1426  *      Open device, read MBR.  Abort program on short read.  Create empty
1427  *      disklabel if the on-disk structure is invalid (WRITABLE mode).
1428  *    If what == TRY_ONLY:
1429  *      Open device, read MBR.  Return an error if anything is out of place.
1430  *      Do not create an empty disklabel.  This is used for the "list"
1431  *      operations: "fdisk -l /dev/sda" and "fdisk -l" (all devices).
1432  *    If what == CREATE_EMPTY_*:
1433  *      This means that get_boot() was called recursively from create_*label().
1434  *      Do not re-open the device; just set up the ptes array and print
1435  *      geometry warnings.
1436  *
1437  * Returns:
1438  *   -1: no 0xaa55 flag present (possibly entire disk BSD)
1439  *    0: found or created label
1440  *    1: I/O error
1441  */
1442 #if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
1443 static int get_boot(enum action what)
1444 #else
1445 static int get_boot(void)
1446 #define get_boot(what) get_boot()
1447 #endif
1448 {
1449         int i, fd;
1450
1451         g_partitions = 4;
1452         for (i = 0; i < 4; i++) {
1453                 struct pte *pe = &ptes[i];
1454                 pe->part_table = pt_offset(MBRbuffer, i);
1455                 pe->ext_pointer = NULL;
1456                 pe->offset_from_dev_start = 0;
1457                 pe->sectorbuffer = MBRbuffer;
1458 #if ENABLE_FEATURE_FDISK_WRITABLE
1459                 pe->changed = (what == CREATE_EMPTY_DOS);
1460 #endif
1461         }
1462
1463 #if ENABLE_FEATURE_FDISK_WRITABLE
1464 // ALERT! highly idiotic design!
1465 // We end up here when we call get_boot() recursively
1466 // via get_boot() [table is bad] -> create_doslabel() -> get_boot(CREATE_EMPTY_DOS).
1467 // or get_boot() [table is bad] -> create_sunlabel() -> get_boot(CREATE_EMPTY_SUN).
1468 // (just factor out re-init of ptes[0,1,2,3] in a separate fn instead?)
1469 // So skip opening device _again_...
1470         if (what == CREATE_EMPTY_DOS  IF_FEATURE_SUN_LABEL(|| what == CREATE_EMPTY_SUN))
1471                 goto created_table;
1472
1473         fd = open(disk_device, (option_mask32 & OPT_l) ? O_RDONLY : O_RDWR);
1474
1475         if (fd < 0) {
1476                 fd = open(disk_device, O_RDONLY);
1477                 if (fd < 0) {
1478                         if (what == TRY_ONLY)
1479                                 return 1;
1480                         fdisk_fatal(unable_to_open);
1481                 }
1482                 printf("'%s' is opened for read only\n", disk_device);
1483         }
1484         xmove_fd(fd, dev_fd);
1485         if (512 != full_read(dev_fd, MBRbuffer, 512)) {
1486                 if (what == TRY_ONLY) {
1487                         close_dev_fd();
1488                         return 1;
1489                 }
1490                 fdisk_fatal(unable_to_read);
1491         }
1492 #else
1493         fd = open(disk_device, O_RDONLY);
1494         if (fd < 0)
1495                 return 1;
1496         if (512 != full_read(fd, MBRbuffer, 512)) {
1497                 close(fd);
1498                 return 1;
1499         }
1500         xmove_fd(fd, dev_fd);
1501 #endif
1502
1503         get_geometry();
1504         update_units();
1505
1506 #if ENABLE_FEATURE_SUN_LABEL
1507         if (check_sun_label())
1508                 return 0;
1509 #endif
1510 #if ENABLE_FEATURE_SGI_LABEL
1511         if (check_sgi_label())
1512                 return 0;
1513 #endif
1514 #if ENABLE_FEATURE_AIX_LABEL
1515         if (check_aix_label())
1516                 return 0;
1517 #endif
1518 #if ENABLE_FEATURE_GPT_LABEL
1519         if (check_gpt_label())
1520                 return 0;
1521 #endif
1522 #if ENABLE_FEATURE_OSF_LABEL
1523         if (check_osf_label()) {
1524                 possibly_osf_label = 1;
1525                 if (!valid_part_table_flag(MBRbuffer)) {
1526                         current_label_type = LABEL_OSF;
1527                         return 0;
1528                 }
1529                 puts("This disk has both DOS and BSD magic.\n"
1530                      "Give the 'b' command to go to BSD mode.");
1531         }
1532 #endif
1533
1534 #if !ENABLE_FEATURE_FDISK_WRITABLE
1535         if (!valid_part_table_flag(MBRbuffer))
1536                 return -1;
1537 #else
1538         if (!valid_part_table_flag(MBRbuffer)) {
1539                 if (what == OPEN_MAIN) {
1540                         puts("Device contains neither a valid DOS "
1541                              "partition table, nor Sun, SGI, OSF or GPT "
1542                              "disklabel");
1543 #ifdef __sparc__
1544                         IF_FEATURE_SUN_LABEL(create_sunlabel();)
1545 #else
1546                         create_doslabel();
1547 #endif
1548                         return 0;
1549                 }
1550                 /* TRY_ONLY: */
1551                 return -1;
1552         }
1553  created_table:
1554 #endif /* FEATURE_FDISK_WRITABLE */
1555
1556
1557         IF_FEATURE_FDISK_WRITABLE(warn_cylinders();)
1558         warn_geometry();
1559
1560         for (i = 0; i < 4; i++) {
1561                 if (IS_EXTENDED(ptes[i].part_table->sys_ind)) {
1562                         if (g_partitions != 4)
1563                                 printf("Ignoring extra extended "
1564                                         "partition %u\n", i + 1);
1565                         else
1566                                 read_extended(i);
1567                 }
1568         }
1569
1570         for (i = 3; i < g_partitions; i++) {
1571                 struct pte *pe = &ptes[i];
1572                 if (!valid_part_table_flag(pe->sectorbuffer)) {
1573                         printf("Warning: invalid flag 0x%02x,0x%02x of partition "
1574                                 "table %u will be corrected by w(rite)\n",
1575                                 pe->sectorbuffer[510],
1576                                 pe->sectorbuffer[511],
1577                                 i + 1);
1578                         IF_FEATURE_FDISK_WRITABLE(pe->changed = 1;)
1579                 }
1580         }
1581
1582         return 0;
1583 }
1584
1585 #if ENABLE_FEATURE_FDISK_WRITABLE
1586 /*
1587  * Print the message MESG, then read an integer between LOW and HIGH (inclusive).
1588  * If the user hits Enter, DFLT is returned.
1589  * Answers like +10 are interpreted as offsets from BASE.
1590  *
1591  * There is no default if DFLT is not between LOW and HIGH.
1592  */
1593 static sector_t
1594 read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg)
1595 {
1596         sector_t value;
1597         int default_ok = 1;
1598         const char *fmt = "%s (%u-%u, default %u): ";
1599
1600         if (dflt < low || dflt > high) {
1601                 fmt = "%s (%u-%u): ";
1602                 default_ok = 0;
1603         }
1604
1605         while (1) {
1606                 int use_default = default_ok;
1607
1608                 /* ask question and read answer */
1609                 do {
1610                         printf(fmt, mesg, low, high, dflt);
1611                         read_maybe_empty("");
1612                 } while (*line_ptr != '\n' && !isdigit(*line_ptr)
1613                  && *line_ptr != '-' && *line_ptr != '+');
1614
1615                 if (*line_ptr == '+' || *line_ptr == '-') {
1616                         int minus = (*line_ptr == '-');
1617                         int absolute = 0;
1618
1619                         value = atoi(line_ptr + 1);
1620
1621                         /* (1) if 2nd char is digit, use_default = 0.
1622                          * (2) move line_ptr to first non-digit. */
1623                         while (isdigit(*++line_ptr))
1624                                 use_default = 0;
1625
1626                         switch (*line_ptr) {
1627                         case 'c':
1628                         case 'C':
1629                                 if (!display_in_cyl_units)
1630                                         value *= g_heads * g_sectors;
1631                                 break;
1632                         case 'K':
1633                                 absolute = 1024;
1634                                 break;
1635                         case 'k':
1636                                 absolute = 1000;
1637                                 break;
1638                         case 'm':
1639                         case 'M':
1640                                 absolute = 1000000;
1641                                 break;
1642                         case 'g':
1643                         case 'G':
1644                                 absolute = 1000000000;
1645                                 break;
1646                         default:
1647                                 break;
1648                         }
1649                         if (absolute) {
1650                                 ullong bytes;
1651                                 unsigned long unit;
1652
1653                                 bytes = (ullong) value * absolute;
1654                                 unit = sector_size * units_per_sector;
1655                                 bytes += unit/2; /* round */
1656                                 bytes /= unit;
1657                                 value = bytes;
1658                         }
1659                         if (minus)
1660                                 value = -value;
1661                         value += base;
1662                 } else {
1663                         value = atoi(line_ptr);
1664                         while (isdigit(*line_ptr)) {
1665                                 line_ptr++;
1666                                 use_default = 0;
1667                         }
1668                 }
1669                 if (use_default) {
1670                         value = dflt;
1671                         printf("Using default value %u\n", value);
1672                 }
1673                 if (value >= low && value <= high)
1674                         break;
1675                 puts("Value is out of range");
1676         }
1677         return value;
1678 }
1679
1680 static unsigned
1681 get_partition(int warn, unsigned max)
1682 {
1683         struct pte *pe;
1684         unsigned i;
1685
1686         i = read_int(1, 0, max, 0, "Partition number") - 1;
1687         pe = &ptes[i];
1688
1689         if (warn) {
1690                 if ((!LABEL_IS_SUN && !LABEL_IS_SGI && !pe->part_table->sys_ind)
1691                  || (LABEL_IS_SUN && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id))
1692                  || (LABEL_IS_SGI && !sgi_get_num_sectors(i))
1693                 ) {
1694                         printf("Warning: partition %u has empty type\n", i+1);
1695                 }
1696         }
1697         return i;
1698 }
1699
1700 static int
1701 get_existing_partition(int warn, unsigned max)
1702 {
1703         int pno = -1;
1704         unsigned i;
1705
1706         for (i = 0; i < max; i++) {
1707                 struct pte *pe = &ptes[i];
1708                 struct partition *p = pe->part_table;
1709
1710                 if (p && !is_cleared_partition(p)) {
1711                         if (pno >= 0)
1712                                 goto not_unique;
1713                         pno = i;
1714                 }
1715         }
1716         if (pno >= 0) {
1717                 printf("Selected partition %u\n", pno+1);
1718                 return pno;
1719         }
1720         puts("No partition is defined yet!");
1721         return -1;
1722
1723  not_unique:
1724         return get_partition(warn, max);
1725 }
1726
1727 static int
1728 get_nonexisting_partition(int warn, unsigned max)
1729 {
1730         int pno = -1;
1731         unsigned i;
1732
1733         for (i = 0; i < max; i++) {
1734                 struct pte *pe = &ptes[i];
1735                 struct partition *p = pe->part_table;
1736
1737                 if (p && is_cleared_partition(p)) {
1738                         if (pno >= 0)
1739                                 goto not_unique;
1740                         pno = i;
1741                 }
1742         }
1743         if (pno >= 0) {
1744                 printf("Selected partition %u\n", pno+1);
1745                 return pno;
1746         }
1747         puts("All primary partitions have been defined already!");
1748         return -1;
1749
1750  not_unique:
1751         return get_partition(warn, max);
1752 }
1753
1754
1755 static void
1756 change_units(void)
1757 {
1758         display_in_cyl_units = !display_in_cyl_units;
1759         update_units();
1760         printf("Changing display/entry units to %s\n",
1761                 str_units(PLURAL));
1762 }
1763
1764 static void
1765 toggle_active(int i)
1766 {
1767         struct pte *pe = &ptes[i];
1768         struct partition *p = pe->part_table;
1769
1770         if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
1771                 printf("WARNING: Partition %u is an extended partition\n", i + 1);
1772         p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
1773         pe->changed = 1;
1774 }
1775
1776 static void
1777 toggle_dos_compatibility_flag(void)
1778 {
1779         dos_compatible_flag = 1 - dos_compatible_flag;
1780         if (dos_compatible_flag) {
1781                 sector_offset = g_sectors;
1782                 printf("DOS Compatibility flag is %sset\n", "");
1783         } else {
1784                 sector_offset = 1;
1785                 printf("DOS Compatibility flag is %sset\n", "not ");
1786         }
1787 }
1788
1789 static void
1790 delete_partition(int i)
1791 {
1792         struct pte *pe = &ptes[i];
1793         struct partition *p = pe->part_table;
1794         struct partition *q = pe->ext_pointer;
1795
1796 /* Note that for the fifth partition (i == 4) we don't actually
1797  * decrement partitions.
1798  */
1799
1800         if (warn_geometry())
1801                 return;         /* C/H/S not set */
1802         pe->changed = 1;
1803
1804         if (LABEL_IS_SUN) {
1805                 sun_delete_partition(i);
1806                 return;
1807         }
1808         if (LABEL_IS_SGI) {
1809                 sgi_delete_partition(i);
1810                 return;
1811         }
1812
1813         if (i < 4) {
1814                 if (IS_EXTENDED(p->sys_ind) && i == ext_index) {
1815                         g_partitions = 4;
1816                         ptes[ext_index].ext_pointer = NULL;
1817                         extended_offset = 0;
1818                 }
1819                 clear_partition(p);
1820                 return;
1821         }
1822
1823         if (!q->sys_ind && i > 4) {
1824                 /* the last one in the chain - just delete */
1825                 --g_partitions;
1826                 --i;
1827                 clear_partition(ptes[i].ext_pointer);
1828                 ptes[i].changed = 1;
1829         } else {
1830                 /* not the last one - further ones will be moved down */
1831                 if (i > 4) {
1832                         /* delete this link in the chain */
1833                         p = ptes[i-1].ext_pointer;
1834                         *p = *q;
1835                         set_start_sect(p, get_start_sect(q));
1836                         set_nr_sects(p, get_nr_sects(q));
1837                         ptes[i-1].changed = 1;
1838                 } else if (g_partitions > 5) {    /* 5 will be moved to 4 */
1839                         /* the first logical in a longer chain */
1840                         pe = &ptes[5];
1841
1842                         if (pe->part_table) /* prevent SEGFAULT */
1843                                 set_start_sect(pe->part_table,
1844                                                 get_partition_start_from_dev_start(pe) -
1845                                                 extended_offset);
1846                         pe->offset_from_dev_start = extended_offset;
1847                         pe->changed = 1;
1848                 }
1849
1850                 if (g_partitions > 5) {
1851                         g_partitions--;
1852                         while (i < g_partitions) {
1853                                 ptes[i] = ptes[i+1];
1854                                 i++;
1855                         }
1856                 } else {
1857                         /* the only logical: clear only */
1858                         clear_partition(ptes[i].part_table);
1859                 }
1860         }
1861 }
1862
1863 static void
1864 change_sysid(void)
1865 {
1866         int i, sys, origsys;
1867         struct partition *p;
1868
1869         /* If sgi_label then don't use get_existing_partition,
1870            let the user select a partition, since get_existing_partition()
1871            only works for Linux like partition tables. */
1872         if (!LABEL_IS_SGI) {
1873                 i = get_existing_partition(0, g_partitions);
1874         } else {
1875                 i = get_partition(0, g_partitions);
1876         }
1877         if (i == -1)
1878                 return;
1879         p = ptes[i].part_table;
1880         origsys = sys = get_sysid(i);
1881
1882         /* if changing types T to 0 is allowed, then
1883            the reverse change must be allowed, too */
1884         if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) {
1885                 printf("Partition %u does not exist yet!\n", i + 1);
1886                 return;
1887         }
1888         while (1) {
1889                 sys = read_hex(get_sys_types());
1890
1891                 if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) {
1892                         puts("Type 0 means free space to many systems\n"
1893                                 "(but not to Linux). Having partitions of\n"
1894                                 "type 0 is probably unwise.");
1895                         /* break; */
1896                 }
1897
1898                 if (!LABEL_IS_SUN && !LABEL_IS_SGI) {
1899                         if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {
1900                                 puts("You cannot change a partition into"
1901                                         " an extended one or vice versa");
1902                                 break;
1903                         }
1904                 }
1905
1906                 if (sys < 256) {
1907 #if ENABLE_FEATURE_SUN_LABEL
1908                         if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK)
1909                                 puts("Consider leaving partition 3 "
1910                                         "as Whole disk (5),\n"
1911                                         "as SunOS/Solaris expects it and "
1912                                         "even Linux likes it\n");
1913 #endif
1914 #if ENABLE_FEATURE_SGI_LABEL
1915                         if (LABEL_IS_SGI &&
1916                                 (
1917                                         (i == 10 && sys != SGI_ENTIRE_DISK) ||
1918                                         (i == 8 && sys != 0)
1919                                 )
1920                         ) {
1921                                 puts("Consider leaving partition 9 "
1922                                         "as volume header (0),\nand "
1923                                         "partition 11 as entire volume (6)"
1924                                         "as IRIX expects it\n");
1925                         }
1926 #endif
1927                         if (sys == origsys)
1928                                 break;
1929                         if (LABEL_IS_SUN) {
1930                                 sun_change_sysid(i, sys);
1931                         } else if (LABEL_IS_SGI) {
1932                                 sgi_change_sysid(i, sys);
1933                         } else
1934                                 p->sys_ind = sys;
1935
1936                         printf("Changed system type of partition %u "
1937                                 "to %x (%s)\n", i + 1, sys,
1938                                 partition_type(sys));
1939                         ptes[i].changed = 1;
1940                         //if (is_dos_partition(origsys) || is_dos_partition(sys))
1941                         //      dos_changed = 1;
1942                         break;
1943                 }
1944         }
1945 }
1946 #endif /* FEATURE_FDISK_WRITABLE */
1947
1948
1949 /* check_consistency() and linear2chs() added Sat Mar 6 12:28:16 1993,
1950  * faith@cs.unc.edu, based on code fragments from pfdisk by Gordon W. Ross,
1951  * Jan.  1990 (version 1.2.1 by Gordon W. Ross Aug. 1990; Modified by S.
1952  * Lubkin Oct.  1991). */
1953
1954 static void
1955 linear2chs(unsigned ls, unsigned *c, unsigned *h, unsigned *s)
1956 {
1957         int spc = g_heads * g_sectors;
1958
1959         *c = ls / spc;
1960         ls = ls % spc;
1961         *h = ls / g_sectors;
1962         *s = ls % g_sectors + 1;  /* sectors count from 1 */
1963 }
1964
1965 static void
1966 check_consistency(const struct partition *p, int partition)
1967 {
1968         unsigned pbc, pbh, pbs;          /* physical beginning c, h, s */
1969         unsigned pec, peh, pes;          /* physical ending c, h, s */
1970         unsigned lbc, lbh, lbs;          /* logical beginning c, h, s */
1971         unsigned lec, leh, les;          /* logical ending c, h, s */
1972
1973         if (!g_heads || !g_sectors || (partition >= 4))
1974                 return;         /* do not check extended partitions */
1975
1976 /* physical beginning c, h, s */
1977         pbc = cylinder(p->sector, p->cyl);
1978         pbh = p->head;
1979         pbs = sector(p->sector);
1980
1981 /* physical ending c, h, s */
1982         pec = cylinder(p->end_sector, p->end_cyl);
1983         peh = p->end_head;
1984         pes = sector(p->end_sector);
1985
1986 /* compute logical beginning (c, h, s) */
1987         linear2chs(get_start_sect(p), &lbc, &lbh, &lbs);
1988
1989 /* compute logical ending (c, h, s) */
1990         linear2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
1991
1992 /* Same physical / logical beginning? */
1993         if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
1994                 printf("Partition %u has different physical/logical "
1995                         "start (non-Linux?):\n", partition + 1);
1996                 printf("     phys=(%u,%u,%u) ", pbc, pbh, pbs);
1997                 printf("logical=(%u,%u,%u)\n", lbc, lbh, lbs);
1998         }
1999
2000 /* Same physical / logical ending? */
2001         if (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
2002                 printf("Partition %u has different physical/logical "
2003                         "end:\n", partition + 1);
2004                 printf("     phys=(%u,%u,%u) ", pec, peh, pes);
2005                 printf("logical=(%u,%u,%u)\n", lec, leh, les);
2006         }
2007
2008 /* Ending on cylinder boundary? */
2009         if (peh != (g_heads - 1) || pes != g_sectors) {
2010                 printf("Partition %u does not end on cylinder boundary\n",
2011                         partition + 1);
2012         }
2013 }
2014
2015 static void
2016 list_disk_geometry(void)
2017 {
2018         ullong bytes = ((ullong)total_number_of_sectors << 9);
2019         ullong xbytes = bytes / (1024*1024);
2020         char x = 'M';
2021
2022         if (xbytes >= 10000) {
2023                 xbytes += 512; /* fdisk util-linux 2.28 does this */
2024                 xbytes /= 1024;
2025                 x = 'G';
2026         }
2027         printf("Disk %s: %llu %cB, %llu bytes, %"SECT_FMT"u sectors\n"
2028                 "%u cylinders, %u heads, %u sectors/track\n"
2029                 "Units: %s of %u * %u = %u bytes\n\n",
2030                 disk_device, xbytes, x,
2031                 bytes, total_number_of_sectors,
2032                 g_cylinders, g_heads, g_sectors,
2033                 str_units(PLURAL),
2034                 units_per_sector, sector_size, units_per_sector * sector_size
2035         );
2036 }
2037
2038 /*
2039  * Check whether partition entries are ordered by their starting positions.
2040  * Return 0 if OK. Return i if partition i should have been earlier.
2041  * Two separate checks: primary and logical partitions.
2042  */
2043 static int
2044 wrong_p_order(int *prev)
2045 {
2046         const struct pte *pe;
2047         const struct partition *p;
2048         sector_t last_p_start_pos = 0, p_start_pos;
2049         unsigned i, last_i = 0;
2050
2051         for (i = 0; i < g_partitions; i++) {
2052                 if (i == 4) {
2053                         last_i = 4;
2054                         last_p_start_pos = 0;
2055                 }
2056                 pe = &ptes[i];
2057                 p = pe->part_table;
2058                 if (p->sys_ind) {
2059                         p_start_pos = get_partition_start_from_dev_start(pe);
2060
2061                         if (last_p_start_pos > p_start_pos) {
2062                                 if (prev)
2063                                         *prev = last_i;
2064                                 return i;
2065                         }
2066
2067                         last_p_start_pos = p_start_pos;
2068                         last_i = i;
2069                 }
2070         }
2071         return 0;
2072 }
2073
2074 #if ENABLE_FEATURE_FDISK_ADVANCED
2075 /*
2076  * Fix the chain of logicals.
2077  * extended_offset is unchanged, the set of sectors used is unchanged
2078  * The chain is sorted so that sectors increase, and so that
2079  * starting sectors increase.
2080  *
2081  * After this it may still be that cfdisk doesnt like the table.
2082  * (This is because cfdisk considers expanded parts, from link to
2083  * end of partition, and these may still overlap.)
2084  * Now
2085  *   sfdisk /dev/hda > ohda; sfdisk /dev/hda < ohda
2086  * may help.
2087  */
2088 static void
2089 fix_chain_of_logicals(void)
2090 {
2091         int j, oj, ojj, sj, sjj;
2092         struct partition *pj,*pjj,tmp;
2093
2094         /* Stage 1: sort sectors but leave sector of part 4 */
2095         /* (Its sector is the global extended_offset.) */
2096  stage1:
2097         for (j = 5; j < g_partitions - 1; j++) {
2098                 oj = ptes[j].offset_from_dev_start;
2099                 ojj = ptes[j+1].offset_from_dev_start;
2100                 if (oj > ojj) {
2101                         ptes[j].offset_from_dev_start = ojj;
2102                         ptes[j+1].offset_from_dev_start = oj;
2103                         pj = ptes[j].part_table;
2104                         set_start_sect(pj, get_start_sect(pj)+oj-ojj);
2105                         pjj = ptes[j+1].part_table;
2106                         set_start_sect(pjj, get_start_sect(pjj)+ojj-oj);
2107                         set_start_sect(ptes[j-1].ext_pointer,
2108                                            ojj-extended_offset);
2109                         set_start_sect(ptes[j].ext_pointer,
2110                                            oj-extended_offset);
2111                         goto stage1;
2112                 }
2113         }
2114
2115         /* Stage 2: sort starting sectors */
2116  stage2:
2117         for (j = 4; j < g_partitions - 1; j++) {
2118                 pj = ptes[j].part_table;
2119                 pjj = ptes[j+1].part_table;
2120                 sj = get_start_sect(pj);
2121                 sjj = get_start_sect(pjj);
2122                 oj = ptes[j].offset_from_dev_start;
2123                 ojj = ptes[j+1].offset_from_dev_start;
2124                 if (oj+sj > ojj+sjj) {
2125                         tmp = *pj;
2126                         *pj = *pjj;
2127                         *pjj = tmp;
2128                         set_start_sect(pj, ojj+sjj-oj);
2129                         set_start_sect(pjj, oj+sj-ojj);
2130                         goto stage2;
2131                 }
2132         }
2133
2134         /* Probably something was changed */
2135         for (j = 4; j < g_partitions; j++)
2136                 ptes[j].changed = 1;
2137 }
2138
2139
2140 static void
2141 fix_partition_table_order(void)
2142 {
2143         struct pte *pei, *pek;
2144         int i,k;
2145
2146         if (!wrong_p_order(NULL)) {
2147                 puts("Ordering is already correct\n");
2148                 return;
2149         }
2150
2151         while ((i = wrong_p_order(&k)) != 0 && i < 4) {
2152                 /* partition i should have come earlier, move it */
2153                 /* We have to move data in the MBR */
2154                 struct partition *pi, *pk, *pe, pbuf;
2155                 pei = &ptes[i];
2156                 pek = &ptes[k];
2157
2158                 pe = pei->ext_pointer;
2159                 pei->ext_pointer = pek->ext_pointer;
2160                 pek->ext_pointer = pe;
2161
2162                 pi = pei->part_table;
2163                 pk = pek->part_table;
2164
2165                 memmove(&pbuf, pi, sizeof(struct partition));
2166                 memmove(pi, pk, sizeof(struct partition));
2167                 memmove(pk, &pbuf, sizeof(struct partition));
2168
2169                 pei->changed = pek->changed = 1;
2170         }
2171
2172         if (i)
2173                 fix_chain_of_logicals();
2174
2175         puts("Done");
2176 }
2177 #endif
2178
2179 static const char *
2180 chs_string11(unsigned cyl, unsigned head, unsigned sect)
2181 {
2182         char *buf = auto_string(xzalloc(sizeof(int)*3 * 3));
2183         sprintf(buf, "%u,%u,%u", cylinder(sect,cyl), head, sector(sect));
2184         return buf;
2185 }
2186
2187 static void
2188 list_table(int xtra)
2189 {
2190         int i, w;
2191
2192         if (LABEL_IS_SUN) {
2193                 sun_list_table(xtra);
2194                 return;
2195         }
2196         if (LABEL_IS_SGI) {
2197                 sgi_list_table(xtra);
2198                 return;
2199         }
2200         if (LABEL_IS_GPT) {
2201                 gpt_list_table(xtra);
2202                 return;
2203         }
2204
2205         list_disk_geometry();
2206
2207         if (LABEL_IS_OSF) {
2208                 xbsd_print_disklabel(xtra);
2209                 return;
2210         }
2211
2212         /* Heuristic: we list partition 3 of /dev/foo as /dev/foo3,
2213          * but if the device name ends in a digit, say /dev/foo1,
2214          * then the partition is called /dev/foo1p3.
2215          */
2216         w = strlen(disk_device);
2217         if (w && isdigit(disk_device[w-1]))
2218                 w++;
2219         if (w < 7)
2220                 w = 7;
2221
2222         printf("%-*s Boot StartCHS    EndCHS        StartLBA     EndLBA    Sectors  Size Id Type\n",
2223                    w-1, "Device");
2224
2225         for (i = 0; i < g_partitions; i++) {
2226                 const struct partition *p;
2227                 const struct pte *pe = &ptes[i];
2228                 char boot4[4];
2229                 char numstr6[6];
2230                 sector_t start_sect;
2231                 sector_t end_sect;
2232                 sector_t nr_sects;
2233
2234                 p = pe->part_table;
2235                 if (!p || is_cleared_partition(p))
2236                         continue;
2237
2238                 sprintf(boot4, "%02x", p->boot_ind);
2239                 if ((p->boot_ind & 0x7f) == 0) {
2240                         /* 0x80 shown as '*', 0x00 is ' ' */
2241                         boot4[0] = p->boot_ind ? '*' : ' ';
2242                         boot4[1] = ' ';
2243                 }
2244
2245                 start_sect = get_partition_start_from_dev_start(pe);
2246                 end_sect = start_sect;
2247                 nr_sects = get_nr_sects(p);
2248                 if (nr_sects != 0)
2249                         end_sect += nr_sects - 1;
2250
2251                 smart_ulltoa5((ullong)nr_sects * sector_size,
2252                         numstr6, " KMGTPEZY")[0] = '\0';
2253
2254 #define SFMT SECT_FMT
2255                 //      Boot StartCHS    EndCHS        StartLBA     EndLBA    Sectors  Size Id Type
2256                 printf("%s%s %-11s"/**/" %-11s"/**/" %10"SFMT"u %10"SFMT"u %10"SFMT"u %s %2x %s\n",
2257                         partname(disk_device, i+1, w+2),
2258                         boot4,
2259                         chs_string11(p->cyl, p->head, p->sector),
2260                         chs_string11(p->end_cyl, p->end_head, p->end_sector),
2261                         start_sect,
2262                         end_sect,
2263                         nr_sects,
2264                         numstr6,
2265                         p->sys_ind,
2266                         partition_type(p->sys_ind)
2267                 );
2268 #undef SFMT
2269                 check_consistency(p, i);
2270         }
2271
2272         /* Is partition table in disk order? It need not be, but... */
2273         /* partition table entries are not checked for correct order
2274          * if this is a sgi, sun or aix labeled disk... */
2275         if (LABEL_IS_DOS && wrong_p_order(NULL)) {
2276                 /* FIXME */
2277                 puts("\nPartition table entries are not in disk order");
2278         }
2279 }
2280
2281 #if ENABLE_FEATURE_FDISK_ADVANCED
2282 static void
2283 x_list_table(int extend)
2284 {
2285         const struct pte *pe;
2286         const struct partition *p;
2287         int i;
2288
2289         printf("\nDisk %s: %u heads, %u sectors, %u cylinders\n\n",
2290                 disk_device, g_heads, g_sectors, g_cylinders);
2291         puts("Nr AF  Hd Sec  Cyl  Hd Sec  Cyl      Start       Size ID");
2292         for (i = 0; i < g_partitions; i++) {
2293                 pe = &ptes[i];
2294                 p = (extend ? pe->ext_pointer : pe->part_table);
2295                 if (p != NULL) {
2296                         printf("%2u %02x%4u%4u%5u%4u%4u%5u%11"SECT_FMT"u%11"SECT_FMT"u %02x\n",
2297                                 i + 1, p->boot_ind,
2298                                 p->head,
2299                                 sector(p->sector),
2300                                 cylinder(p->sector, p->cyl),
2301                                 p->end_head,
2302                                 sector(p->end_sector),
2303                                 cylinder(p->end_sector, p->end_cyl),
2304                                 get_start_sect(p),
2305                                 get_nr_sects(p),
2306                                 p->sys_ind
2307                         );
2308                         if (p->sys_ind)
2309                                 check_consistency(p, i);
2310                 }
2311         }
2312 }
2313 #endif
2314
2315 #if ENABLE_FEATURE_FDISK_WRITABLE
2316 static void
2317 fill_bounds(sector_t *first, sector_t *last)
2318 {
2319         unsigned i;
2320         const struct pte *pe = &ptes[0];
2321         const struct partition *p;
2322
2323         for (i = 0; i < g_partitions; pe++,i++) {
2324                 p = pe->part_table;
2325                 if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) {
2326                         first[i] = 0xffffffff;
2327                         last[i] = 0;
2328                 } else {
2329                         first[i] = get_partition_start_from_dev_start(pe);
2330                         last[i] = first[i] + get_nr_sects(p) - 1;
2331                 }
2332         }
2333 }
2334
2335 static void
2336 check(int n, unsigned h, unsigned s, unsigned c, sector_t start)
2337 {
2338         sector_t total, real_s, real_c;
2339
2340         real_s = sector(s) - 1;
2341         real_c = cylinder(s, c);
2342         total = (real_c * g_sectors + real_s) * g_heads + h;
2343         if (!total)
2344                 printf("Partition %u contains sector 0\n", n);
2345         if (h >= g_heads)
2346                 printf("Partition %u: head %u greater than maximum %u\n",
2347                         n, h + 1, g_heads);
2348         if (real_s >= g_sectors)
2349                 printf("Partition %u: sector %u greater than "
2350                         "maximum %u\n", n, s, g_sectors);
2351         if (real_c >= g_cylinders)
2352                 printf("Partition %u: cylinder %"SECT_FMT"u greater than "
2353                         "maximum %u\n", n, real_c + 1, g_cylinders);
2354         if (g_cylinders <= 1024 && start != total)
2355                 printf("Partition %u: previous sectors %"SECT_FMT"u disagrees with "
2356                         "total %"SECT_FMT"u\n", n, start, total);
2357 }
2358
2359 static void
2360 verify(void)
2361 {
2362         int i, j;
2363         sector_t total = 1;
2364         sector_t chs_size;
2365         sector_t first[g_partitions], last[g_partitions];
2366         struct partition *p;
2367
2368         if (warn_geometry())
2369                 return;
2370
2371         if (LABEL_IS_SUN) {
2372                 verify_sun();
2373                 return;
2374         }
2375         if (LABEL_IS_SGI) {
2376                 verify_sgi(1);
2377                 return;
2378         }
2379
2380         fill_bounds(first, last);
2381         for (i = 0; i < g_partitions; i++) {
2382                 struct pte *pe = &ptes[i];
2383
2384                 p = pe->part_table;
2385                 if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
2386                         check_consistency(p, i);
2387                         if (get_partition_start_from_dev_start(pe) < first[i])
2388                                 printf("Warning: bad start-of-data in "
2389                                         "partition %u\n", i + 1);
2390                         check(i + 1, p->end_head, p->end_sector, p->end_cyl,
2391                                 last[i]);
2392                         total += last[i] + 1 - first[i];
2393                         for (j = 0; j < i; j++) {
2394                                 if ((first[i] >= first[j] && first[i] <= last[j])
2395                                  || ((last[i] <= last[j] && last[i] >= first[j]))) {
2396                                         printf("Warning: partition %u overlaps "
2397                                                 "partition %u\n", j + 1, i + 1);
2398                                         total += first[i] >= first[j] ?
2399                                                 first[i] : first[j];
2400                                         total -= last[i] <= last[j] ?
2401                                                 last[i] : last[j];
2402                                 }
2403                         }
2404                 }
2405         }
2406
2407         if (extended_offset) {
2408                 struct pte *pex = &ptes[ext_index];
2409                 sector_t e_last = get_start_sect(pex->part_table) +
2410                         get_nr_sects(pex->part_table) - 1;
2411
2412                 for (i = 4; i < g_partitions; i++) {
2413                         total++;
2414                         p = ptes[i].part_table;
2415                         if (!p->sys_ind) {
2416                                 if (i != 4 || i + 1 < g_partitions)
2417                                         printf("Warning: partition %u "
2418                                                 "is empty\n", i + 1);
2419                         } else if (first[i] < extended_offset || last[i] > e_last) {
2420                                 printf("Logical partition %u not entirely in "
2421                                         "partition %u\n", i + 1, ext_index + 1);
2422                         }
2423                 }
2424         }
2425
2426         chs_size = (sector_t)g_heads * g_sectors * g_cylinders;
2427         if (total > chs_size)
2428                 printf("Total allocated sectors %u"
2429                         " greater than CHS size %"SECT_FMT"u\n",
2430                         total, chs_size
2431                 );
2432         else {
2433                 total = chs_size - total;
2434                 if (total != 0)
2435                         printf("%"SECT_FMT"u unallocated sectors\n", total);
2436         }
2437 }
2438
2439 static void
2440 add_partition(int n, int sys)
2441 {
2442         char mesg[256];         /* 48 does not suffice in Japanese */
2443         int i, num_read = 0;
2444         struct partition *p = ptes[n].part_table;
2445         struct partition *q = ptes[ext_index].part_table;
2446         sector_t limit, temp;
2447         sector_t start, stop = 0;
2448         sector_t first[g_partitions], last[g_partitions];
2449
2450         if (p && p->sys_ind) {
2451                 printf(msg_part_already_defined, n + 1);
2452                 return;
2453         }
2454         fill_bounds(first, last);
2455         if (n < 4) {
2456                 start = sector_offset;
2457                 if (display_in_cyl_units || !total_number_of_sectors)
2458                         limit = (sector_t) g_heads * g_sectors * g_cylinders - 1;
2459                 else
2460                         limit = total_number_of_sectors - 1;
2461                 if (extended_offset) {
2462                         first[ext_index] = extended_offset;
2463                         last[ext_index] = get_start_sect(q) +
2464                                 get_nr_sects(q) - 1;
2465                 }
2466         } else {
2467                 start = extended_offset + sector_offset;
2468                 limit = get_start_sect(q) + get_nr_sects(q) - 1;
2469         }
2470         if (display_in_cyl_units)
2471                 for (i = 0; i < g_partitions; i++)
2472                         first[i] = (cround(first[i]) - 1) * units_per_sector;
2473
2474         snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));
2475         do {
2476                 temp = start;
2477                 for (i = 0; i < g_partitions; i++) {
2478                         int lastplusoff;
2479
2480                         if (start == ptes[i].offset_from_dev_start)
2481                                 start += sector_offset;
2482                         lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
2483                         if (start >= first[i] && start <= lastplusoff)
2484                                 start = lastplusoff + 1;
2485                 }
2486                 if (start > limit)
2487                         break;
2488                 if (start >= temp+units_per_sector && num_read) {
2489                         printf("Sector %"SECT_FMT"u is already allocated\n", temp);
2490                         temp = start;
2491                         num_read = 0;
2492                 }
2493                 if (!num_read && start == temp) {
2494                         sector_t saved_start;
2495
2496                         saved_start = start;
2497                         start = read_int(cround(saved_start), cround(saved_start), cround(limit), 0, mesg);
2498                         if (display_in_cyl_units) {
2499                                 start = (start - 1) * units_per_sector;
2500                                 if (start < saved_start)
2501                                         start = saved_start;
2502                         }
2503                         num_read = 1;
2504                 }
2505         } while (start != temp || !num_read);
2506         if (n > 4) {                    /* NOT for fifth partition */
2507                 struct pte *pe = &ptes[n];
2508
2509                 pe->offset_from_dev_start = start - sector_offset;
2510                 if (pe->offset_from_dev_start == extended_offset) { /* must be corrected */
2511                         pe->offset_from_dev_start++;
2512                         if (sector_offset == 1)
2513                                 start++;
2514                 }
2515         }
2516
2517         for (i = 0; i < g_partitions; i++) {
2518                 struct pte *pe = &ptes[i];
2519
2520                 if (start < pe->offset_from_dev_start && limit >= pe->offset_from_dev_start)
2521                         limit = pe->offset_from_dev_start - 1;
2522                 if (start < first[i] && limit >= first[i])
2523                         limit = first[i] - 1;
2524         }
2525         if (start > limit) {
2526                 puts("No free sectors available");
2527                 if (n > 4)
2528                         g_partitions--;
2529                 return;
2530         }
2531         if (cround(start) == cround(limit)) {
2532                 stop = limit;
2533         } else {
2534                 snprintf(mesg, sizeof(mesg),
2535                          "Last %s or +size or +sizeM or +sizeK",
2536                          str_units(SINGULAR));
2537                 stop = read_int(cround(start), cround(limit), cround(limit), cround(start), mesg);
2538                 if (display_in_cyl_units) {
2539                         stop = stop * units_per_sector - 1;
2540                         if (stop >limit)
2541                                 stop = limit;
2542                 }
2543         }
2544
2545         set_partition(n, 0, start, stop, sys);
2546         if (n > 4)
2547                 set_partition(n - 1, 1, ptes[n].offset_from_dev_start, stop, EXTENDED);
2548
2549         if (IS_EXTENDED(sys)) {
2550                 struct pte *pe4 = &ptes[4];
2551                 struct pte *pen = &ptes[n];
2552
2553                 ext_index = n;
2554                 pen->ext_pointer = p;
2555                 pe4->offset_from_dev_start = extended_offset = start;
2556                 pe4->sectorbuffer = xzalloc(sector_size);
2557                 pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
2558                 pe4->ext_pointer = pe4->part_table + 1;
2559                 pe4->changed = 1;
2560                 g_partitions = 5;
2561         }
2562 }
2563
2564 static void
2565 add_logical(void)
2566 {
2567         if (g_partitions > 5 || ptes[4].part_table->sys_ind) {
2568                 struct pte *pe = &ptes[g_partitions];
2569
2570                 pe->sectorbuffer = xzalloc(sector_size);
2571                 pe->part_table = pt_offset(pe->sectorbuffer, 0);
2572                 pe->ext_pointer = pe->part_table + 1;
2573                 pe->offset_from_dev_start = 0;
2574                 pe->changed = 1;
2575                 g_partitions++;
2576         }
2577         add_partition(g_partitions - 1, LINUX_NATIVE);
2578 }
2579
2580 static void
2581 new_partition(void)
2582 {
2583         int i, free_primary = 0;
2584
2585         if (warn_geometry())
2586                 return;
2587
2588         if (LABEL_IS_SUN) {
2589                 add_sun_partition(get_partition(0, g_partitions), LINUX_NATIVE);
2590                 return;
2591         }
2592         if (LABEL_IS_SGI) {
2593                 sgi_add_partition(get_partition(0, g_partitions), LINUX_NATIVE);
2594                 return;
2595         }
2596         if (LABEL_IS_AIX) {
2597                 puts("Sorry - this fdisk cannot handle AIX disk labels.\n"
2598 "If you want to add DOS-type partitions, create a new empty DOS partition\n"
2599 "table first (use 'o'). This will destroy the present disk contents.");
2600                 return;
2601         }
2602
2603         for (i = 0; i < 4; i++)
2604                 free_primary += !ptes[i].part_table->sys_ind;
2605
2606         if (!free_primary && g_partitions >= MAXIMUM_PARTS) {
2607                 puts("The maximum number of partitions has been created");
2608                 return;
2609         }
2610
2611         if (!free_primary) {
2612                 if (extended_offset)
2613                         add_logical();
2614                 else
2615                         puts("You must delete some partition and add "
2616                                  "an extended partition first");
2617         } else {
2618                 char c, line[80];
2619                 snprintf(line, sizeof(line),
2620                         "Command action\n"
2621                         "   %s\n"
2622                         "   p   primary partition (1-4)\n",
2623                         (extended_offset ?
2624                         "l   logical (5 or over)" : "e   extended"));
2625                 while (1) {
2626                         c = read_nonempty(line);
2627                         if ((c | 0x20) == 'p') {
2628                                 i = get_nonexisting_partition(0, 4);
2629                                 if (i >= 0)
2630                                         add_partition(i, LINUX_NATIVE);
2631                                 return;
2632                         }
2633                         if (c == 'l' && extended_offset) {
2634                                 add_logical();
2635                                 return;
2636                         }
2637                         if (c == 'e' && !extended_offset) {
2638                                 i = get_nonexisting_partition(0, 4);
2639                                 if (i >= 0)
2640                                         add_partition(i, EXTENDED);
2641                                 return;
2642                         }
2643                         printf("Invalid partition number "
2644                                          "for type '%c'\n", c);
2645                 }
2646         }
2647 }
2648
2649 static void
2650 reread_partition_table(int leave)
2651 {
2652         int i;
2653
2654         puts("Calling ioctl() to re-read partition table");
2655         sync();
2656         /* Users with slow external USB disks on a 320MHz ARM system (year 2011)
2657          * report that sleep is needed, otherwise BLKRRPART may fail with -EIO:
2658          */
2659         sleep(1);
2660         i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
2661                         "WARNING: rereading partition table "
2662                         "failed, kernel still uses old table");
2663 #if 0
2664         if (dos_changed)
2665                 puts(
2666                 "\nWARNING: If you have created or modified any DOS 6.x\n"
2667                 "partitions, please see the fdisk manual page for additional\n"
2668                 "information");
2669 #endif
2670
2671         if (leave) {
2672                 if (ENABLE_FEATURE_CLEAN_UP)
2673                         close_dev_fd();
2674                 exit(i != 0);
2675         }
2676 }
2677
2678 static void
2679 write_table(void)
2680 {
2681         int i;
2682
2683         if (LABEL_IS_DOS) {
2684                 for (i = 0; i < 3; i++)
2685                         if (ptes[i].changed)
2686                                 ptes[3].changed = 1;
2687                 for (i = 3; i < g_partitions; i++) {
2688                         struct pte *pe = &ptes[i];
2689                         if (pe->changed) {
2690                                 write_part_table_flag(pe->sectorbuffer);
2691                                 write_sector(pe->offset_from_dev_start, pe->sectorbuffer);
2692                         }
2693                 }
2694         }
2695         else if (LABEL_IS_SGI) {
2696                 /* no test on change? the "altered" msg below might be mistaken */
2697                 sgi_write_table();
2698         }
2699         else if (LABEL_IS_SUN) {
2700                 for (i = 0; i < 8; i++) {
2701                         if (ptes[i].changed) {
2702                                 sun_write_table();
2703                                 break;
2704                         }
2705                 }
2706         }
2707
2708         puts("The partition table has been altered.");
2709         reread_partition_table(1);
2710 }
2711 #endif /* FEATURE_FDISK_WRITABLE */
2712
2713 #if ENABLE_FEATURE_FDISK_ADVANCED
2714 #define MAX_PER_LINE    16
2715 static void
2716 print_buffer(char *pbuffer)
2717 {
2718         int i,l;
2719
2720         for (i = 0, l = 0; i < sector_size; i++, l++) {
2721                 if (l == 0)
2722                         printf("0x%03X:", i);
2723                 printf(" %02X", (unsigned char) pbuffer[i]);
2724                 if (l == MAX_PER_LINE - 1) {
2725                         bb_putchar('\n');
2726                         l = -1;
2727                 }
2728         }
2729         if (l > 0)
2730                 bb_putchar('\n');
2731         bb_putchar('\n');
2732 }
2733
2734 static void
2735 print_raw(void)
2736 {
2737         int i;
2738
2739         printf("Device: %s\n", disk_device);
2740         if (LABEL_IS_SGI || LABEL_IS_SUN)
2741                 print_buffer(MBRbuffer);
2742         else {
2743                 for (i = 3; i < g_partitions; i++)
2744                         print_buffer(ptes[i].sectorbuffer);
2745         }
2746 }
2747
2748 static void
2749 move_begin(unsigned i)
2750 {
2751         struct pte *pe = &ptes[i];
2752         struct partition *p = pe->part_table;
2753         sector_t new, first, nr_sects;
2754
2755         if (warn_geometry())
2756                 return;
2757         nr_sects = get_nr_sects(p);
2758         if (!p->sys_ind || !nr_sects || IS_EXTENDED(p->sys_ind)) {
2759                 printf("Partition %u has no data area\n", i + 1);
2760                 return;
2761         }
2762         first = get_partition_start_from_dev_start(pe); /* == pe->offset_from_dev_start + get_start_sect(p) */
2763         new = read_int(0 /*was:first*/, first, first + nr_sects - 1, first, "New beginning of data");
2764         if (new != first) {
2765                 sector_t new_relative = new - pe->offset_from_dev_start;
2766                 nr_sects += (get_start_sect(p) - new_relative);
2767                 set_start_sect(p, new_relative);
2768                 set_nr_sects(p, nr_sects);
2769                 read_nonempty("Recalculate C/H/S values? (Y/N): ");
2770                 if ((line_ptr[0] | 0x20) == 'y')
2771                         set_hsc_start_end(p, new, new + nr_sects - 1);
2772                 pe->changed = 1;
2773         }
2774 }
2775
2776 static void
2777 xselect(void)
2778 {
2779         char c;
2780
2781         while (1) {
2782                 bb_putchar('\n');
2783                 c = 0x20 | read_nonempty("Expert command (m for help): ");
2784                 switch (c) {
2785                 case 'a':
2786                         if (LABEL_IS_SUN)
2787                                 sun_set_alt_cyl();
2788                         break;
2789                 case 'b':
2790                         if (LABEL_IS_DOS)
2791                                 move_begin(get_partition(0, g_partitions));
2792                         break;
2793                 case 'c':
2794                         user_cylinders = g_cylinders =
2795                                 read_int(1, g_cylinders, 1048576, 0,
2796                                         "Number of cylinders");
2797                         if (LABEL_IS_SUN)
2798                                 sun_set_ncyl(g_cylinders);
2799                         if (LABEL_IS_DOS)
2800                                 warn_cylinders();
2801                         break;
2802                 case 'd':
2803                         print_raw();
2804                         break;
2805                 case 'e':
2806                         if (LABEL_IS_SGI)
2807                                 sgi_set_xcyl();
2808                         else if (LABEL_IS_SUN)
2809                                 sun_set_xcyl();
2810                         else if (LABEL_IS_DOS)
2811                                 x_list_table(1);
2812                         break;
2813                 case 'f':
2814                         if (LABEL_IS_DOS)
2815                                 fix_partition_table_order();
2816                         break;
2817                 case 'g':
2818 #if ENABLE_FEATURE_SGI_LABEL
2819                         create_sgilabel();
2820 #endif
2821                         break;
2822                 case 'h':
2823                         user_heads = g_heads = read_int(1, g_heads, 256, 0, "Number of heads");
2824                         update_units();
2825                         break;
2826                 case 'i':
2827                         if (LABEL_IS_SUN)
2828                                 sun_set_ilfact();
2829                         break;
2830                 case 'o':
2831                         if (LABEL_IS_SUN)
2832                                 sun_set_rspeed();
2833                         break;
2834                 case 'p':
2835                         if (LABEL_IS_SUN)
2836                                 list_table(1);
2837                         else
2838                                 x_list_table(0);
2839                         break;
2840                 case 'q':
2841                         if (ENABLE_FEATURE_CLEAN_UP)
2842                                 close_dev_fd();
2843                         bb_putchar('\n');
2844                         exit(EXIT_SUCCESS);
2845                 case 'r':
2846                         return;
2847                 case 's':
2848                         user_sectors = g_sectors = read_int(1, g_sectors, 63, 0, "Number of sectors");
2849                         if (dos_compatible_flag) {
2850                                 sector_offset = g_sectors;
2851                                 puts("Warning: setting sector offset for DOS "
2852                                         "compatibility");
2853                         }
2854                         update_units();
2855                         break;
2856                 case 'v':
2857                         verify();
2858                         break;
2859                 case 'w':
2860                         write_table();  /* does not return */
2861                         break;
2862                 case 'y':
2863                         if (LABEL_IS_SUN)
2864                                 sun_set_pcylcount();
2865                         break;
2866                 default:
2867                         xmenu();
2868                 }
2869         }
2870 }
2871 #endif /* ADVANCED mode */
2872
2873 static int
2874 is_ide_cdrom_or_tape(const char *device)
2875 {
2876         FILE *procf;
2877         char buf[100];
2878         struct stat statbuf;
2879         int is_ide = 0;
2880
2881         /* No device was given explicitly, and we are trying some
2882            likely things.  But opening /dev/hdc may produce errors like
2883            "hdc: tray open or drive not ready"
2884            if it happens to be a CD-ROM drive. It even happens that
2885            the process hangs on the attempt to read a music CD.
2886            So try to be careful. This only works since 2.1.73. */
2887
2888         if (!is_prefixed_with(device, "/dev/hd"))
2889                 return 0;
2890
2891         snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
2892         procf = fopen_for_read(buf);
2893         if (procf != NULL && fgets(buf, sizeof(buf), procf))
2894                 is_ide = (is_prefixed_with(buf, "cdrom") ||
2895                           is_prefixed_with(buf, "tape"));
2896         else
2897                 /* Now when this proc file does not exist, skip the
2898                    device when it is read-only. */
2899                 if (stat(device, &statbuf) == 0)
2900                         is_ide = ((statbuf.st_mode & 0222) == 0);
2901
2902         if (procf)
2903                 fclose(procf);
2904         return is_ide;
2905 }
2906
2907
2908 static void
2909 open_list_and_close(const char *device, int user_specified)
2910 {
2911         int gb;
2912
2913         disk_device = device;
2914         if (setjmp(listingbuf))
2915                 return;
2916         if (!user_specified)
2917                 if (is_ide_cdrom_or_tape(device))
2918                         return;
2919
2920         /* Open disk_device, save file descriptor to dev_fd */
2921         errno = 0;
2922         gb = get_boot(TRY_ONLY);
2923         if (gb > 0) {   /* I/O error */
2924                 /* Ignore other errors, since we try IDE
2925                    and SCSI hard disks which may not be
2926                    installed on the system. */
2927                 if (user_specified || errno == EACCES)
2928                         bb_perror_msg("can't open '%s'", device);
2929                 return;
2930         }
2931
2932         if (gb < 0) { /* no DOS signature */
2933                 list_disk_geometry();
2934                 if (LABEL_IS_AIX)
2935                         goto ret;
2936 #if ENABLE_FEATURE_OSF_LABEL
2937                 if (bsd_trydev(device) < 0)
2938 #endif
2939                         printf("Disk %s doesn't contain a valid "
2940                                 "partition table\n", device);
2941         } else {
2942                 list_table(0);
2943 #if ENABLE_FEATURE_FDISK_WRITABLE
2944                 if (!LABEL_IS_SUN && g_partitions > 4) {
2945                         delete_partition(ext_index);
2946                 }
2947 #endif
2948         }
2949  ret:
2950         close_dev_fd();
2951 }
2952
2953 /* Is it a whole disk? The digit check is still useful
2954    for Xen devices for example. */
2955 static int is_whole_disk(const char *disk)
2956 {
2957         unsigned len;
2958         int fd = open(disk, O_RDONLY);
2959
2960         if (fd != -1) {
2961                 struct hd_geometry geometry;
2962                 int err = ioctl(fd, HDIO_GETGEO, &geometry);
2963                 close(fd);
2964                 if (!err)
2965                         return (geometry.start == 0);
2966         }
2967
2968         /* Treat "nameN" as a partition name, not whole disk */
2969         /* note: mmcblk0 should work from the geometry check above */
2970         len = strlen(disk);
2971         if (len != 0 && isdigit(disk[len - 1]))
2972                 return 0;
2973
2974         return 1;
2975 }
2976
2977 /* for fdisk -l: try all things in /proc/partitions
2978    that look like a partition name (do not end in a digit) */
2979 static void
2980 list_devs_in_proc_partititons(void)
2981 {
2982         FILE *procpt;
2983         char line[100], ptname[100], devname[120];
2984         int ma, mi, sz;
2985
2986         procpt = fopen_or_warn("/proc/partitions", "r");
2987
2988         while (fgets(line, sizeof(line), procpt)) {
2989                 if (sscanf(line, " %u %u %u %[^\n ]",
2990                                 &ma, &mi, &sz, ptname) != 4)
2991                         continue;
2992
2993                 sprintf(devname, "/dev/%s", ptname);
2994                 if (is_whole_disk(devname))
2995                         open_list_and_close(devname, 0);
2996         }
2997 #if ENABLE_FEATURE_CLEAN_UP
2998         fclose(procpt);
2999 #endif
3000 }
3001
3002 #if ENABLE_FEATURE_FDISK_WRITABLE
3003 static void
3004 unknown_command(int c)
3005 {
3006         printf("%c: unknown command\n", c);
3007 }
3008 #endif
3009
3010 int fdisk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
3011 int fdisk_main(int argc UNUSED_PARAM, char **argv)
3012 {
3013         unsigned opt;
3014         /*
3015          *  fdisk -v
3016          *  fdisk -l [-b sectorsize] [-u] device ...
3017          *  fdisk -s [partition] ...
3018          *  fdisk [-b sectorsize] [-u] device
3019          *
3020          * Options -C, -H, -S set the geometry.
3021          */
3022         INIT_G();
3023
3024         close_dev_fd(); /* needed: fd 3 must not stay closed */
3025
3026         opt = getopt32(argv, "b:+C:+H:+lS:+u" IF_FEATURE_FDISK_BLKSIZE("s"),
3027                                 &sector_size, &user_cylinders, &user_heads, &user_sectors);
3028         argv += optind;
3029         if (opt & OPT_b) {
3030                 /* Ugly: this sector size is really per device,
3031                  * so cannot be combined with multiple disks,
3032                  * and the same goes for the C/H/S options.
3033                  */
3034                 if (sector_size < 512
3035                  || sector_size > 0x10000
3036                  || (sector_size & (sector_size-1)) /* not power of 2 */
3037                 ) {
3038                         bb_show_usage();
3039                 }
3040                 sector_offset = 2;
3041                 user_set_sector_size = 1;
3042         }
3043         if (user_heads <= 0 || user_heads >= 256)
3044                 user_heads = 0;
3045         if (user_sectors <= 0 || user_sectors >= 64)
3046                 user_sectors = 0;
3047         if (opt & OPT_u)
3048                 display_in_cyl_units = 0; // -u
3049
3050 #if ENABLE_FEATURE_FDISK_WRITABLE
3051         if (opt & OPT_l) {
3052                 nowarn = 1;
3053 #endif
3054                 if (*argv) {
3055                         listing = 1;
3056                         do {
3057                                 open_list_and_close(*argv, 1);
3058                         } while (*++argv);
3059                 } else {
3060                         /* we don't have device names, */
3061                         /* use /proc/partitions instead */
3062                         list_devs_in_proc_partititons();
3063                 }
3064                 return 0;
3065 #if ENABLE_FEATURE_FDISK_WRITABLE
3066         }
3067 #endif
3068
3069 #if ENABLE_FEATURE_FDISK_BLKSIZE
3070         if (opt & OPT_s) {
3071                 int j;
3072
3073                 nowarn = 1;
3074                 if (!argv[0])
3075                         bb_show_usage();
3076                 for (j = 0; argv[j]; j++) {
3077                         unsigned long long size;
3078                         fd = xopen(argv[j], O_RDONLY);
3079                         size = bb_BLKGETSIZE_sectors(fd) / 2;
3080                         close(fd);
3081                         if (argv[1])
3082                                 printf("%llu\n", size);
3083                         else
3084                                 printf("%s: %llu\n", argv[j], size);
3085                 }
3086                 return 0;
3087         }
3088 #endif
3089
3090 #if ENABLE_FEATURE_FDISK_WRITABLE
3091         if (!argv[0] || argv[1])
3092                 bb_show_usage();
3093
3094         disk_device = argv[0];
3095         get_boot(OPEN_MAIN);
3096
3097         if (LABEL_IS_OSF) {
3098                 /* OSF label, and no DOS label */
3099                 printf("Detected an OSF/1 disklabel on %s, entering "
3100                         "disklabel mode\n", disk_device);
3101                 bsd_select();
3102                 /*Why do we do this?  It seems to be counter-intuitive*/
3103                 current_label_type = LABEL_DOS;
3104                 /* If we return we may want to make an empty DOS label? */
3105         }
3106
3107         while (1) {
3108                 int c;
3109                 bb_putchar('\n');
3110                 c = 0x20 | read_nonempty("Command (m for help): ");
3111                 switch (c) {
3112                 case 'a':
3113                         if (LABEL_IS_DOS)
3114                                 toggle_active(get_partition(1, g_partitions));
3115                         else if (LABEL_IS_SUN)
3116                                 toggle_sunflags(get_partition(1, g_partitions),
3117                                                 0x01);
3118                         else if (LABEL_IS_SGI)
3119                                 sgi_set_bootpartition(
3120                                         get_partition(1, g_partitions));
3121                         else
3122                                 unknown_command(c);
3123                         break;
3124                 case 'b':
3125                         if (LABEL_IS_SGI) {
3126                                 printf("\nThe current boot file is: %s\n",
3127                                         sgi_get_bootfile());
3128                                 if (read_maybe_empty("Please enter the name of the "
3129                                                 "new boot file: ") == '\n')
3130                                         puts("Boot file unchanged");
3131                                 else
3132                                         sgi_set_bootfile(line_ptr);
3133                         }
3134 #if ENABLE_FEATURE_OSF_LABEL
3135                         else
3136                                 bsd_select();
3137 #endif
3138                         break;
3139                 case 'c':
3140                         if (LABEL_IS_DOS)
3141                                 toggle_dos_compatibility_flag();
3142                         else if (LABEL_IS_SUN)
3143                                 toggle_sunflags(get_partition(1, g_partitions),
3144                                                 0x10);
3145                         else if (LABEL_IS_SGI)
3146                                 sgi_set_swappartition(
3147                                                 get_partition(1, g_partitions));
3148                         else
3149                                 unknown_command(c);
3150                         break;
3151                 case 'd':
3152                         {
3153                                 int j;
3154                         /* If sgi_label then don't use get_existing_partition,
3155                            let the user select a partition, since
3156                            get_existing_partition() only works for Linux-like
3157                            partition tables */
3158                                 if (!LABEL_IS_SGI) {
3159                                         j = get_existing_partition(1, g_partitions);
3160                                 } else {
3161                                         j = get_partition(1, g_partitions);
3162                                 }
3163                                 if (j >= 0)
3164                                         delete_partition(j);
3165                         }
3166                         break;
3167                 case 'i':
3168                         if (LABEL_IS_SGI)
3169                                 create_sgiinfo();
3170                         else
3171                                 unknown_command(c);
3172                 case 'l':
3173                         list_types(get_sys_types());
3174                         break;
3175                 case 'm':
3176                         menu();
3177                         break;
3178                 case 'n':
3179                         new_partition();
3180                         break;
3181                 case 'o':
3182                         create_doslabel();
3183                         break;
3184                 case 'p':
3185                         list_table(0);
3186                         break;
3187                 case 'q':
3188                         if (ENABLE_FEATURE_CLEAN_UP)
3189                                 close_dev_fd();
3190                         bb_putchar('\n');
3191                         return 0;
3192                 case 's':
3193 #if ENABLE_FEATURE_SUN_LABEL
3194                         create_sunlabel();
3195 #endif
3196                         break;
3197                 case 't':
3198                         change_sysid();
3199                         break;
3200                 case 'u':
3201                         change_units();
3202                         break;
3203                 case 'v':
3204                         verify();
3205                         break;
3206                 case 'w':
3207                         write_table();  /* does not return */
3208                         break;
3209 #if ENABLE_FEATURE_FDISK_ADVANCED
3210                 case 'x':
3211                         if (LABEL_IS_SGI) {
3212                                 puts("\n\tSorry, no experts menu for SGI "
3213                                         "partition tables available\n");
3214                         } else
3215                                 xselect();
3216                         break;
3217 #endif
3218                 default:
3219                         unknown_command(c);
3220                         menu();
3221                 }
3222         }
3223         return 0;
3224 #endif /* FEATURE_FDISK_WRITABLE */
3225 }