Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/util-linux/fdisk.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/util-linux/fdisk.c (modified) (129 diffs)

branches/2.2.9/mindi-busybox/util-linux/fdisk.c

@@ -5 +5 @@
  * Copyright (C) 2001,2002 Vladimir Oleynik <dzo@simtreas.ru> (initial bb port)
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
 #ifndef _LARGEFILE64_SOURCE
 /* For lseek64 */
-#define _LARGEFILE64_SOURCE
+# define _LARGEFILE64_SOURCE
 #endif
 #include <assert.h>             /* assert */
+#include <sys/mount.h>
+#if !defined(BLKSSZGET)
+# define BLKSSZGET _IO(0x12, 104)
+#endif
+#if !defined(BLKGETSIZE64)
+# define BLKGETSIZE64 _IOR(0x12,114,size_t)
+#endif
 #include "libbb.h"
+
+#if BB_LITTLE_ENDIAN
+# define inline_if_little_endian ALWAYS_INLINE
+#else
+# define inline_if_little_endian /* nothing */
+#endif
+
 
 /* Looks like someone forgot to add this to config system */
 #ifndef ENABLE_FEATURE_FDISK_BLKSIZE
 # define ENABLE_FEATURE_FDISK_BLKSIZE 0
-# define USE_FEATURE_FDISK_BLKSIZE(a)
-#endif
-
-#define DEFAULT_SECTOR_SIZE     512
-#define MAX_SECTOR_SIZE 2048
-#define SECTOR_SIZE     512     /* still used in osf/sgi/sun code */
-#define MAXIMUM_PARTS   60
-
-#define ACTIVE_FLAG     0x80
-
-#define EXTENDED        0x05
-#define WIN98_EXTENDED  0x0f
-#define LINUX_PARTITION 0x81
-#define LINUX_SWAP      0x82
-#define LINUX_NATIVE    0x83
-#define LINUX_EXTENDED  0x85
-#define LINUX_LVM       0x8e
-#define LINUX_RAID      0xfd
-
-/* Used for sector numbers. Today's disk sizes make it necessary */
+# define IF_FEATURE_FDISK_BLKSIZE(a)
+#endif
+
+#define DEFAULT_SECTOR_SIZE      512
+#define DEFAULT_SECTOR_SIZE_STR "512"
+#define MAX_SECTOR_SIZE         2048
+#define SECTOR_SIZE              512 /* still used in osf/sgi/sun code */
+#define MAXIMUM_PARTS             60
+
+#define ACTIVE_FLAG             0x80
+
+#define EXTENDED                0x05
+#define WIN98_EXTENDED          0x0f
+#define LINUX_PARTITION         0x81
+#define LINUX_SWAP              0x82
+#define LINUX_NATIVE            0x83
+#define LINUX_EXTENDED          0x85
+#define LINUX_LVM               0x8e
+#define LINUX_RAID              0xfd
+
+
+enum {
+    OPT_b = 1 << 0,
+    OPT_C = 1 << 1,
+    OPT_H = 1 << 2,
+    OPT_l = 1 << 3,
+    OPT_S = 1 << 4,
+    OPT_u = 1 << 5,
+    OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
+};
+
+
 typedef unsigned long long ullong;
+/* Used for sector numbers. Partition formats we know
+ * do not support more than 2^32 sectors
+ */
+typedef uint32_t sector_t;
+#if UINT_MAX == 4294967295
+# define SECT_FMT ""
+#elif ULONG_MAX == 4294967295
+# define SECT_FMT "l"
+#else
+# error Cant detect sizeof(uint32_t)
+#endif
 
 struct hd_geometry {
@@ -55 +92 @@
 
 static const char msg_part_already_defined[] ALIGN1 =
-"Partition %d is already defined, delete it before re-adding\n";
-
-
-static unsigned sector_size = DEFAULT_SECTOR_SIZE;
-static unsigned user_set_sector_size;
-static unsigned sector_offset = 1;
-
-#if ENABLE_FEATURE_OSF_LABEL
-static int possibly_osf_label;
-#endif
-
-static unsigned heads, sectors, cylinders;
-static void update_units(void);
+"Partition %u is already defined, delete it before re-adding\n";
 
 
@@ -75 +100 @@
     unsigned char sector;           /* starting sector */
     unsigned char cyl;              /* starting cylinder */
-    unsigned char sys_ind;          /* What partition type */
+    unsigned char sys_ind;          /* what partition type */
     unsigned char end_head;         /* end head */
     unsigned char end_sector;       /* end sector */
@@ -81 +106 @@
     unsigned char start4[4];        /* starting sector counting from 0 */
     unsigned char size4[4];         /* nr of sectors in partition */
-} ATTRIBUTE_PACKED;
-
-static const char unable_to_open[] ALIGN1 = "cannot open %s";
-static const char unable_to_read[] ALIGN1 = "cannot read from %s";
-static const char unable_to_seek[] ALIGN1 = "cannot seek on %s";
-static const char unable_to_write[] ALIGN1 = "cannot write to %s";
-static const char ioctl_error[] ALIGN1 = "BLKGETSIZE ioctl failed on %s";
-static void fdisk_fatal(const char *why) ATTRIBUTE_NORETURN;
-
-enum label_type {
-    label_dos, label_sun, label_sgi, label_aix, label_osf
-};
-
-#define LABEL_IS_DOS    (label_dos == current_label_type)
-
-#if ENABLE_FEATURE_SUN_LABEL
-#define LABEL_IS_SUN    (label_sun == current_label_type)
-#define STATIC_SUN static
-#else
-#define LABEL_IS_SUN    0
-#define STATIC_SUN extern
-#endif
-
-#if ENABLE_FEATURE_SGI_LABEL
-#define LABEL_IS_SGI    (label_sgi == current_label_type)
-#define STATIC_SGI static
-#else
-#define LABEL_IS_SGI    0
-#define STATIC_SGI extern
-#endif
-
-#if ENABLE_FEATURE_AIX_LABEL
-#define LABEL_IS_AIX    (label_aix == current_label_type)
-#define STATIC_AIX static
-#else
-#define LABEL_IS_AIX    0
-#define STATIC_AIX extern
-#endif
-
-#if ENABLE_FEATURE_OSF_LABEL
-#define LABEL_IS_OSF    (label_osf == current_label_type)
-#define STATIC_OSF static
-#else
-#define LABEL_IS_OSF    0
-#define STATIC_OSF extern
-#endif
-
-enum action { fdisk, require, try_only, create_empty_dos, create_empty_sun };
-
-static enum label_type current_label_type;
-
-static const char *disk_device;
-static int fd;                  /* the disk */
-static int partitions = 4;      /* maximum partition + 1 */
-static int display_in_cyl_units = 1;
-static unsigned units_per_sector = 1;
-#if ENABLE_FEATURE_FDISK_WRITABLE
-static void change_units(void);
-static void reread_partition_table(int leave);
-static void delete_partition(int i);
-static int get_partition(int warn, int max);
-static void list_types(const char *const *sys);
-static unsigned read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg);
-#endif
-static const char *partition_type(unsigned char type);
-static void get_geometry(void);
-static int get_boot(enum action what);
-
-#define PLURAL   0
-#define SINGULAR 1
-
-static unsigned get_start_sect(const struct partition *p);
-static unsigned get_nr_sects(const struct partition *p);
+} PACKED;
 
 /*
@@ -166 +119 @@
     struct partition *part_table;   /* points into sectorbuffer */
     struct partition *ext_pointer;  /* points into sectorbuffer */
-    ullong offset;          /* disk sector number */
-    char *sectorbuffer;     /* disk sector contents */
+    sector_t offset_from_dev_start; /* disk sector number */
+    char *sectorbuffer;             /* disk sector contents */
 #if ENABLE_FEATURE_FDISK_WRITABLE
-    char changed;           /* boolean */
+    char changed;                   /* boolean */
 #endif
 };
+
+#define unable_to_open "can't open '%s'"
+#define unable_to_read "can't read from %s"
+#define unable_to_seek "can't seek on %s"
+
+enum label_type {
+    LABEL_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF, LABEL_GPT
+};
+
+#define LABEL_IS_DOS    (LABEL_DOS == current_label_type)
+
+#if ENABLE_FEATURE_SUN_LABEL
+#define LABEL_IS_SUN    (LABEL_SUN == current_label_type)
+#define STATIC_SUN static
+#else
+#define LABEL_IS_SUN    0
+#define STATIC_SUN extern
+#endif
+
+#if ENABLE_FEATURE_SGI_LABEL
+#define LABEL_IS_SGI    (LABEL_SGI == current_label_type)
+#define STATIC_SGI static
+#else
+#define LABEL_IS_SGI    0
+#define STATIC_SGI extern
+#endif
+
+#if ENABLE_FEATURE_AIX_LABEL
+#define LABEL_IS_AIX    (LABEL_AIX == current_label_type)
+#define STATIC_AIX static
+#else
+#define LABEL_IS_AIX    0
+#define STATIC_AIX extern
+#endif
+
+#if ENABLE_FEATURE_OSF_LABEL
+#define LABEL_IS_OSF    (LABEL_OSF == current_label_type)
+#define STATIC_OSF static
+#else
+#define LABEL_IS_OSF    0
+#define STATIC_OSF extern
+#endif
+
+#if ENABLE_FEATURE_GPT_LABEL
+#define LABEL_IS_GPT    (LABEL_GPT == current_label_type)
+#define STATIC_GPT static
+#else
+#define LABEL_IS_GPT    0
+#define STATIC_GPT extern
+#endif
+
+enum action { OPEN_MAIN, TRY_ONLY, CREATE_EMPTY_DOS, CREATE_EMPTY_SUN };
+
+static void update_units(void);
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static void change_units(void);
+static void reread_partition_table(int leave);
+static void delete_partition(int i);
+static unsigned get_partition(int warn, unsigned max);
+static void list_types(const char *const *sys);
+static sector_t read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg);
+#endif
+static const char *partition_type(unsigned char type);
+static void get_geometry(void);
+static void read_pte(struct pte *pe, sector_t offset);
+#if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
+static int get_boot(enum action what);
+#else
+static int get_boot(void);
+#endif
+
+#define PLURAL   0
+#define SINGULAR 1
+
+static sector_t get_start_sect(const struct partition *p);
+static sector_t get_nr_sects(const struct partition *p);
 
 /* DOS partition types */
@@ -278 +307 @@
 };
 
+enum {
+    dev_fd = 3                  /* the disk */
+};
 
 /* Globals */
-
 struct globals {
     char *line_ptr;
+
+    const char *disk_device;
+    int g_partitions; // = 4;       /* maximum partition + 1 */
+    unsigned units_per_sector; // = 1;
+    unsigned sector_size; // = DEFAULT_SECTOR_SIZE;
+    unsigned user_set_sector_size;
+    unsigned sector_offset; // = 1;
+    unsigned g_heads, g_sectors, g_cylinders;
+    smallint /* enum label_type */ current_label_type;
+    smallint display_in_cyl_units; // = 1;
+#if ENABLE_FEATURE_OSF_LABEL
+    smallint possibly_osf_label;
+#endif
+
+    smallint listing;               /* no aborts for fdisk -l */
+    smallint dos_compatible_flag; // = 1;
+#if ENABLE_FEATURE_FDISK_WRITABLE
+    //int dos_changed;
+    smallint nowarn;                /* no warnings for fdisk -l/-s */
+#endif
+    int ext_index;                  /* the prime extended partition */
+    unsigned user_cylinders, user_heads, user_sectors;
+    unsigned pt_heads, pt_sectors;
+    unsigned kern_heads, kern_sectors;
+    sector_t extended_offset;       /* offset of link pointers */
+    sector_t total_number_of_sectors;
+
+    jmp_buf listingbuf;
     char line_buffer[80];
     char partname_buffer[80];
-    jmp_buf listingbuf;
     /* Raw disk label. For DOS-type partition tables the MBR,
      * with descriptions of the primary partitions. */
@@ -292 +350 @@
     struct pte ptes[MAXIMUM_PARTS];
 };
-/* bb_common_bufsiz1 is too small for this on 64 bit CPUs */
 #define G (*ptr_to_globals)
-
-#define line_ptr        (G.line_ptr)
-#define listingbuf      (G.listingbuf)
-#define line_buffer     (G.line_buffer)
+#define line_ptr             (G.line_ptr            )
+#define disk_device          (G.disk_device         )
+#define g_partitions         (G.g_partitions        )
+#define units_per_sector     (G.units_per_sector    )
+#define sector_size          (G.sector_size         )
+#define user_set_sector_size (G.user_set_sector_size)
+#define sector_offset        (G.sector_offset       )
+#define g_heads              (G.g_heads             )
+#define g_sectors            (G.g_sectors           )
+#define g_cylinders          (G.g_cylinders         )
+#define current_label_type   (G.current_label_type  )
+#define display_in_cyl_units (G.display_in_cyl_units)
+#define possibly_osf_label   (G.possibly_osf_label  )
+#define listing                 (G.listing                )
+#define dos_compatible_flag     (G.dos_compatible_flag    )
+#define nowarn                  (G.nowarn                 )
+#define ext_index               (G.ext_index              )
+#define user_cylinders          (G.user_cylinders         )
+#define user_heads              (G.user_heads             )
+#define user_sectors            (G.user_sectors           )
+#define pt_heads                (G.pt_heads               )
+#define pt_sectors              (G.pt_sectors             )
+#define kern_heads              (G.kern_heads             )
+#define kern_sectors            (G.kern_sectors           )
+#define extended_offset         (G.extended_offset        )
+#define total_number_of_sectors (G.total_number_of_sectors)
+#define listingbuf      (G.listingbuf     )
+#define line_buffer     (G.line_buffer    )
 #define partname_buffer (G.partname_buffer)
-#define MBRbuffer       (G.MBRbuffer)
-#define ptes            (G.ptes)
-
-
-/* Code */
+#define MBRbuffer       (G.MBRbuffer      )
+#define ptes            (G.ptes           )
+#define INIT_G() do { \
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+    sector_size = DEFAULT_SECTOR_SIZE; \
+    sector_offset = 1; \
+    g_partitions = 4; \
+    display_in_cyl_units = 1; \
+    units_per_sector = 1; \
+    dos_compatible_flag = 1; \
+} while (0)
+
+
+/* TODO: move to libbb? */
+/* TODO: return unsigned long long, FEATURE_FDISK_BLKSIZE _can_ handle
+ * disks > 2^32 sectors
+ */
+static sector_t bb_BLKGETSIZE_sectors(int fd)
+{
+    uint64_t v64;
+    unsigned long longsectors;
+
+    if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
+        /* Got bytes, convert to 512 byte sectors */
+        v64 >>= 9;
+        if (v64 != (sector_t)v64) {
+ ret_trunc:
+            /* Not only DOS, but all other partition tables
+             * we support can't record more than 32 bit
+             * sector counts or offsets
+             */
+            bb_error_msg("device has more than 2^32 sectors, can't use all of them");
+            v64 = (uint32_t)-1L;
+        }
+        return v64;
+    }
+    /* Needs temp of type long */
+    if (ioctl(fd, BLKGETSIZE, &longsectors)) {
+        /* Perhaps this is a disk image */
+        off_t sz = lseek(fd, 0, SEEK_END);
+        longsectors = 0;
+        if (sz > 0)
+            longsectors = (uoff_t)sz / sector_size;
+        lseek(fd, 0, SEEK_SET);
+    }
+    if (sizeof(long) > sizeof(sector_t)
+     && longsectors != (sector_t)longsectors
+    ) {
+        goto ret_trunc;
+    }
+    return longsectors;
+}
+
 
 #define IS_EXTENDED(i) \
@@ -322 +451 @@
     (sector(s) - 1 + sectors * ((h) + heads * cylinder(s,c)))
 
-#define set_hsc(h,s,c,sector) \
-    do { \
-        s = sector % sectors + 1;  \
-        sector /= sectors;         \
-        h = sector % heads;        \
-        sector /= heads;           \
-        c = sector & 0xff;         \
-        s |= (sector >> 2) & 0xc0; \
-    } while (0)
-
-#if ENABLE_FEATURE_FDISK_WRITABLE
-/* read line; return 0 or first printable char */
-static int
-read_line(const char *prompt)
-{
-    int sz;
-
-    sz = read_line_input(prompt, line_buffer, sizeof(line_buffer), NULL);
-    if (sz <= 0)
-        exit(0); /* Ctrl-D or Ctrl-C */
-
-    if (line_buffer[sz-1] == '\n')
-        line_buffer[--sz] = '\0';
-
-    line_ptr = line_buffer;
-    while (*line_ptr && !isgraph(*line_ptr))
-        line_ptr++;
-    return *line_ptr;
-}
-#endif
+static void
+close_dev_fd(void)
+{
+    /* Not really closing, but making sure it is open, and to harmless place */
+    xmove_fd(xopen(bb_dev_null, O_RDONLY), dev_fd);
+}
 
 /*
- * return partition name - uses static storage
+ * Return partition name - uses static storage
  */
 static const char *
@@ -384 +489 @@
     if (lth) {
         snprintf(bufp, bufsiz, "%*.*s%s%-2u",
-             lth-wp-2, w, dev, p, pno);
+            lth-wp-2, w, dev, p, pno);
     } else {
         snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
@@ -390 +495 @@
     return bufp;
 }
-
-#if ENABLE_FEATURE_FDISK_WRITABLE
-static void
-set_all_unchanged(void)
-{
-    int i;
-
-    for (i = 0; i < MAXIMUM_PARTS; i++)
-        ptes[i].changed = 0;
-}
-
-static ALWAYS_INLINE void
-set_changed(int i)
-{
-    ptes[i].changed = 1;
-}
-#endif /* FEATURE_FDISK_WRITABLE */
 
 static ALWAYS_INLINE struct partition *
@@ -428 +516 @@
 }
 
+static void fdisk_fatal(const char *why)
+{
+    if (listing) {
+        close_dev_fd();
+        longjmp(listingbuf, 1);
+    }
+    bb_error_msg_and_die(why, disk_device);
+}
+
+static void
+seek_sector(sector_t secno)
+{
+#if ENABLE_FDISK_SUPPORT_LARGE_DISKS
+    off64_t off = (off64_t)secno * sector_size;
+    if (lseek64(dev_fd, off, SEEK_SET) == (off64_t) -1)
+        fdisk_fatal(unable_to_seek);
+#else
+    uint64_t off = (uint64_t)secno * sector_size;
+    if (off > MAXINT(off_t)
+     || lseek(dev_fd, (off_t)off, SEEK_SET) == (off_t) -1
+    ) {
+        fdisk_fatal(unable_to_seek);
+    }
+#endif
+}
+
 #if ENABLE_FEATURE_FDISK_WRITABLE
+/* Read line; return 0 or first printable char */
+static int
+read_line(const char *prompt)
+{
+    int sz;
+
+    sz = read_line_input(prompt, line_buffer, sizeof(line_buffer), NULL);
+    if (sz <= 0)
+        exit(EXIT_SUCCESS); /* Ctrl-D or Ctrl-C */
+
+    if (line_buffer[sz-1] == '\n')
+        line_buffer[--sz] = '\0';
+
+    line_ptr = line_buffer;
+    while (*line_ptr != '\0' && (unsigned char)*line_ptr <= ' ')
+        line_ptr++;
+    return *line_ptr;
+}
+
+static void
+set_all_unchanged(void)
+{
+    int i;
+
+    for (i = 0; i < MAXIMUM_PARTS; i++)
+        ptes[i].changed = 0;
+}
+
+static ALWAYS_INLINE void
+set_changed(int i)
+{
+    ptes[i].changed = 1;
+}
+
 static ALWAYS_INLINE void
 write_part_table_flag(char *b)
@@ -439 +587 @@
 read_nonempty(const char *mesg)
 {
-    while (!read_line(mesg)) /* repeat */;
+    while (!read_line(mesg))
+        continue;
     return *line_ptr;
 }
@@ -460 +609 @@
     while (1) {
         read_nonempty("Hex code (type L to list codes): ");
-        if (*line_ptr == 'l' || *line_ptr == 'L') {
+        if ((line_ptr[0] | 0x20) == 'l') {
             list_types(sys);
             continue;
         }
         v = bb_strtoul(line_ptr, NULL, 16);
-        if (v > 0xff)
-            /* Bad input also triggers this */
-            continue;
-        return v;
-    }
+        if (v <= 0xff)
+            return v;
+    }
+}
+
+static void
+write_sector(sector_t secno, const void *buf)
+{
+    seek_sector(secno);
+    xwrite(dev_fd, buf, sector_size);
 }
 #endif /* FEATURE_FDISK_WRITABLE */
 
+
 #include "fdisk_aix.c"
 
-typedef struct {
+struct sun_partition {
     unsigned char info[128];   /* Informative text string */
     unsigned char spare0[14];
@@ -501 +656 @@
     unsigned short magic;      /* Magic number */
     unsigned short csum;       /* Label xor'd checksum */
-} sun_partition;
+} FIX_ALIASING;
+typedef struct sun_partition sun_partition;
 #define sunlabel ((sun_partition *)MBRbuffer)
 STATIC_OSF void bsd_select(void);
 STATIC_OSF void xbsd_print_disklabel(int);
 #include "fdisk_osf.c"
+
+STATIC_GPT void gpt_list_table(int xtra);
+#include "fdisk_gpt.c"
 
 #if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL
@@ -561 +720 @@
 #include "fdisk_sun.c"
 
+
+static inline_if_little_endian unsigned
+read4_little_endian(const unsigned char *cp)
+{
+    uint32_t v;
+    move_from_unaligned32(v, cp);
+    return SWAP_LE32(v);
+}
+
+static sector_t
+get_start_sect(const struct partition *p)
+{
+    return read4_little_endian(p->start4);
+}
+
+static sector_t
+get_nr_sects(const struct partition *p)
+{
+    return read4_little_endian(p->size4);
+}
+
 #if ENABLE_FEATURE_FDISK_WRITABLE
 /* start_sect and nr_sects are stored little endian on all machines */
 /* moreover, they are not aligned correctly */
-static void
+static inline_if_little_endian void
 store4_little_endian(unsigned char *cp, unsigned val)
 {
-    cp[0] = val;
-    cp[1] = val >> 8;
-    cp[2] = val >> 16;
-    cp[3] = val >> 24;
-}
-#endif /* FEATURE_FDISK_WRITABLE */
-
-static unsigned
-read4_little_endian(const unsigned char *cp)
-{
-    return cp[0] + (cp[1] << 8) + (cp[2] << 16) + (cp[3] << 24);
-}
-
-#if ENABLE_FEATURE_FDISK_WRITABLE
+    uint32_t v = SWAP_LE32(val);
+    move_to_unaligned32(cp, v);
+}
+
 static void
 set_start_sect(struct partition *p, unsigned start_sect)
@@ -586 +756 @@
     store4_little_endian(p->start4, start_sect);
 }
-#endif
-
-static unsigned
-get_start_sect(const struct partition *p)
-{
-    return read4_little_endian(p->start4);
-}
-
-#if ENABLE_FEATURE_FDISK_WRITABLE
+
 static void
 set_nr_sects(struct partition *p, unsigned nr_sects)
@@ -602 +764 @@
 #endif
 
-static unsigned
-get_nr_sects(const struct partition *p)
-{
-    return read4_little_endian(p->size4);
-}
-
-/* normally O_RDWR, -l option gives O_RDONLY */
-static int type_open = O_RDWR;
-
-static int ext_index;               /* the prime extended partition */
-static int listing;                 /* no aborts for fdisk -l */
-static int dos_compatible_flag = ~0;
-#if ENABLE_FEATURE_FDISK_WRITABLE
-static int dos_changed;
-static int nowarn;            /* no warnings for fdisk -l/-s */
-#endif
-
-static unsigned user_cylinders, user_heads, user_sectors;
-static unsigned pt_heads, pt_sectors;
-static unsigned kern_heads, kern_sectors;
-
-static ullong extended_offset;            /* offset of link pointers */
-static ullong total_number_of_sectors;
-
-static void fdisk_fatal(const char *why)
-{
-    if (listing) {
-        close(fd);
-        longjmp(listingbuf, 1);
-    }
-    bb_error_msg_and_die(why, disk_device);
-}
-
-static void
-seek_sector(ullong secno)
-{
-    secno *= sector_size;
-#if ENABLE_FDISK_SUPPORT_LARGE_DISKS
-    if (lseek64(fd, (off64_t)secno, SEEK_SET) == (off64_t) -1)
-        fdisk_fatal(unable_to_seek);
-#else
-    if (secno > MAXINT(off_t)
-     || lseek(fd, (off_t)secno, SEEK_SET) == (off_t) -1
-    ) {
-        fdisk_fatal(unable_to_seek);
-    }
-#endif
-}
-
-#if ENABLE_FEATURE_FDISK_WRITABLE
-static void
-write_sector(ullong secno, char *buf)
-{
-    seek_sector(secno);
-    if (write(fd, buf, sector_size) != sector_size)
-        fdisk_fatal(unable_to_write);
-}
-#endif
-
 /* Allocate a buffer and read a partition table sector */
 static void
-read_pte(struct pte *pe, ullong offset)
-{
-    pe->offset = offset;
-    pe->sectorbuffer = xmalloc(sector_size);
+read_pte(struct pte *pe, sector_t offset)
+{
+    pe->offset_from_dev_start = offset;
+    pe->sectorbuffer = xzalloc(sector_size);
     seek_sector(offset);
-    if (read(fd, pe->sectorbuffer, sector_size) != sector_size)
+    /* xread would make us abort - bad for fdisk -l */
+    if (full_read(dev_fd, pe->sectorbuffer, sector_size) != sector_size)
         fdisk_fatal(unable_to_read);
 #if ENABLE_FEATURE_FDISK_WRITABLE
@@ -676 +780 @@
 }
 
-static unsigned
-get_partition_start(const struct pte *pe)
-{
-    return pe->offset + get_start_sect(pe->part_table);
+static sector_t
+get_partition_start_from_dev_start(const struct pte *pe)
+{
+    return pe->offset_from_dev_start + get_start_sect(pe->part_table);
 }
 
@@ -689 +793 @@
  * for "is probably nondos partition".
  */
+#ifdef UNUSED
 static int
 is_dos_partition(int t)
@@ -698 +803 @@
         t == 0xc1 || t == 0xc4 || t == 0xc6);
 }
+#endif
 
 static void
@@ -738 +844 @@
     } else if (LABEL_IS_AIX) {
         puts("o\tcreate a new empty DOS partition table");
+        puts("q\tquit without saving changes");
+        puts("s\tcreate a new empty Sun disklabel");  /* sun */
+    } else if (LABEL_IS_GPT) {
+        puts("o\tcreate a new empty DOS partition table");
+        puts("p\tprint the partition table");
         puts("q\tquit without saving changes");
         puts("s\tcreate a new empty Sun disklabel");  /* sun */
@@ -840 +951 @@
 #else
 #define get_sys_types() i386_sys_types
-#endif /* FEATURE_FDISK_WRITABLE */
+#endif
 
 static const char *
@@ -855 +966 @@
 }
 
+static int
+is_cleared_partition(const struct partition *p)
+{
+    /* We consider partition "cleared" only if it has only zeros */
+    const char *cp = (const char *)p;
+    int cnt = sizeof(*p);
+    char bits = 0;
+    while (--cnt >= 0)
+        bits |= *cp++;
+    return (bits == 0);
+}
+
+static void
+clear_partition(struct partition *p)
+{
+    if (p)
+        memset(p, 0, sizeof(*p));
+}
 
 #if ENABLE_FEATURE_FDISK_WRITABLE
@@ -874 +1003 @@
     int i;
 
-    for (size = 0; sys[size]; size++) /* */;
+    for (size = 0; sys[size]; size++)
+        continue;
 
     done = 0;
@@ -893 +1023 @@
         }
     } while (done < last[0]);
-    putchar('\n');
-}
-#endif /* FEATURE_FDISK_WRITABLE */
-
-static int
-is_cleared_partition(const struct partition *p)
-{
-    return !(!p || p->boot_ind || p->head || p->sector || p->cyl ||
-         p->sys_ind || p->end_head || p->end_sector || p->end_cyl ||
-         get_start_sect(p) || get_nr_sects(p));
-}
-
-static void
-clear_partition(struct partition *p)
-{
-    if (!p)
-        return;
-    memset(p, 0, sizeof(struct partition));
-}
-
-#if ENABLE_FEATURE_FDISK_WRITABLE
-static void
-set_partition(int i, int doext, ullong start, ullong stop, int sysid)
+    bb_putchar('\n');
+}
+
+#define set_hsc(h, s, c, sector) do \
+{ \
+    s = sector % g_sectors + 1;  \
+    sector /= g_sectors;         \
+    h = sector % g_heads;        \
+    sector /= g_heads;           \
+    c = sector & 0xff;           \
+    s |= (sector >> 2) & 0xc0;   \
+} while (0)
+
+static void set_hsc_start_end(struct partition *p, sector_t start, sector_t stop)
+{
+    if (dos_compatible_flag && (start / (g_sectors * g_heads) > 1023))
+        start = g_heads * g_sectors * 1024 - 1;
+    set_hsc(p->head, p->sector, p->cyl, start);
+
+    if (dos_compatible_flag && (stop / (g_sectors * g_heads) > 1023))
+        stop = g_heads * g_sectors * 1024 - 1;
+    set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
+}
+
+static void
+set_partition(int i, int doext, sector_t start, sector_t stop, int sysid)
 {
     struct partition *p;
-    ullong offset;
+    sector_t offset;
 
     if (doext) {
@@ -925 +1058 @@
     } else {
         p = ptes[i].part_table;
-        offset = ptes[i].offset;
+        offset = ptes[i].offset_from_dev_start;
     }
     p->boot_ind = 0;
@@ -931 +1064 @@
     set_start_sect(p, start - offset);
     set_nr_sects(p, stop - start + 1);
-    if (dos_compatible_flag && (start/(sectors*heads) > 1023))
-        start = heads*sectors*1024 - 1;
-    set_hsc(p->head, p->sector, p->cyl, start);
-    if (dos_compatible_flag && (stop/(sectors*heads) > 1023))
-        stop = heads*sectors*1024 - 1;
-    set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
+    set_hsc_start_end(p, start, stop);
     ptes[i].changed = 1;
 }
@@ -944 +1072 @@
 warn_geometry(void)
 {
-    if (heads && sectors && cylinders)
+    if (g_heads && g_sectors && g_cylinders)
         return 0;
 
     printf("Unknown value(s) for:");
-    if (!heads)
+    if (!g_heads)
         printf(" heads");
-    if (!sectors)
+    if (!g_sectors)
         printf(" sectors");
-    if (!cylinders)
+    if (!g_cylinders)
         printf(" cylinders");
     printf(
@@ -965 +1093 @@
 update_units(void)
 {
-    int cyl_units = heads * sectors;
+    int cyl_units = g_heads * g_sectors;
 
     if (display_in_cyl_units && cyl_units)
@@ -977 +1105 @@
 warn_cylinders(void)
 {
-    if (LABEL_IS_DOS && cylinders > 1024 && !nowarn)
+    if (LABEL_IS_DOS && g_cylinders > 1024 && !nowarn)
         printf("\n"
-"The number of cylinders for this disk is set to %d.\n"
+"The number of cylinders for this disk is set to %u.\n"
 "There is nothing wrong with that, but this is larger than 1024,\n"
 "and could in certain setups cause problems with:\n"
@@ -985 +1113 @@
 "2) booting and partitioning software from other OSs\n"
 "   (e.g., DOS FDISK, OS/2 FDISK)\n",
-            cylinders);
+            g_cylinders);
 }
 #endif
@@ -1007 +1135 @@
 
     while (IS_EXTENDED(p->sys_ind)) {
-        struct pte *pe = &ptes[partitions];
-
-        if (partitions >= MAXIMUM_PARTS) {
+        struct pte *pe = &ptes[g_partitions];
+
+        if (g_partitions >= MAXIMUM_PARTS) {
             /* This is not a Linux restriction, but
                this program uses arrays of size MAXIMUM_PARTS.
                Do not try to 'improve' this test. */
-            struct pte *pre = &ptes[partitions-1];
+            struct pte *pre = &ptes[g_partitions - 1];
 #if ENABLE_FEATURE_FDISK_WRITABLE
-            printf("Warning: deleting partitions after %d\n",
-                partitions);
+            printf("Warning: deleting partitions after %u\n",
+                g_partitions);
             pre->changed = 1;
 #endif
@@ -1034 +1162 @@
                     printf("Warning: extra link "
                         "pointer in partition table"
-                        " %d\n", partitions + 1);
+                        " %u\n", g_partitions + 1);
                 else
                     pe->ext_pointer = p;
@@ -1041 +1169 @@
                     printf("Warning: ignoring extra "
                           "data in partition table"
-                          " %d\n", partitions + 1);
+                          " %u\n", g_partitions + 1);
                 else
                     pe->part_table = p;
@@ -1062 +1190 @@
 
         p = pe->ext_pointer;
-        partitions++;
+        g_partitions++;
     }
 
@@ -1068 +1196 @@
     /* remove empty links */
  remove:
-    for (i = 4; i < partitions; i++) {
+    for (i = 4; i < g_partitions; i++) {
         struct pte *pe = &ptes[i];
 
         if (!get_nr_sects(pe->part_table)
-         && (partitions > 5 || ptes[4].part_table->sys_ind)
+         && (g_partitions > 5 || ptes[4].part_table->sys_ind)
         ) {
-            printf("Omitting empty partition (%d)\n", i+1);
+            printf("Omitting empty partition (%u)\n", i+1);
             delete_partition(i);
             goto remove;    /* numbering changed */
@@ -1086 +1214 @@
 create_doslabel(void)
 {
-    int i;
-
     printf(msg_building_new_label, "DOS disklabel");
 
-    current_label_type = label_dos;
-
+    current_label_type = LABEL_DOS;
 #if ENABLE_FEATURE_OSF_LABEL
     possibly_osf_label = 0;
 #endif
-    partitions = 4;
-
-    for (i = 510-64; i < 510; i++)
-        MBRbuffer[i] = 0;
+    g_partitions = 4;
+
+    memset(&MBRbuffer[510 - 4*16], 0, 4*16);
     write_part_table_flag(MBRbuffer);
     extended_offset = 0;
     set_all_unchanged();
     set_changed(0);
-    get_boot(create_empty_dos);
-}
-#endif /* FEATURE_FDISK_WRITABLE */
+    get_boot(CREATE_EMPTY_DOS);
+}
+#endif
 
 static void
@@ -1112 +1236 @@
     if (!user_set_sector_size) {
         int arg;
-        if (ioctl(fd, BLKSSZGET, &arg) == 0)
+        if (ioctl(dev_fd, BLKSSZGET, &arg) == 0)
             sector_size = arg;
         if (sector_size != DEFAULT_SECTOR_SIZE)
-            printf("Note: sector size is %d (not %d)\n",
-                   sector_size, DEFAULT_SECTOR_SIZE);
+            printf("Note: sector size is %u "
+                "(not " DEFAULT_SECTOR_SIZE_STR ")\n",
+                sector_size);
     }
 }
@@ -1125 +1250 @@
     struct hd_geometry geometry;
 
-    if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
+    if (!ioctl(dev_fd, HDIO_GETGEO, &geometry)) {
         kern_heads = geometry.heads;
         kern_sectors = geometry.sectors;
@@ -1169 +1294 @@
 {
     int sec_fac;
-    uint64_t v64;
 
     get_sectorsize();
@@ -1176 +1300 @@
     guess_device_type();
 #endif
-    heads = cylinders = sectors = 0;
+    g_heads = g_cylinders = g_sectors = 0;
     kern_heads = kern_sectors = 0;
     pt_heads = pt_sectors = 0;
@@ -1183 +1307 @@
     get_partition_table_geometry();
 
-    heads = user_heads ? user_heads :
+    g_heads = user_heads ? user_heads :
         pt_heads ? pt_heads :
         kern_heads ? kern_heads : 255;
-    sectors = user_sectors ? user_sectors :
+    g_sectors = user_sectors ? user_sectors :
         pt_sectors ? pt_sectors :
         kern_sectors ? kern_sectors : 63;
-    if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
-        /* got bytes, convert to 512 byte sectors */
-        total_number_of_sectors = (v64 >> 9);
-    } else {
-        unsigned long longsectors; /* need temp of type long */
-        if (ioctl(fd, BLKGETSIZE, &longsectors))
-            longsectors = 0;
-        total_number_of_sectors = longsectors;
-    }
+    total_number_of_sectors = bb_BLKGETSIZE_sectors(dev_fd);
 
     sector_offset = 1;
     if (dos_compatible_flag)
-        sector_offset = sectors;
-
-    cylinders = total_number_of_sectors / (heads * sectors * sec_fac);
-    if (!cylinders)
-        cylinders = user_cylinders;
+        sector_offset = g_sectors;
+
+    g_cylinders = total_number_of_sectors / (g_heads * g_sectors * sec_fac);
+    if (!g_cylinders)
+        g_cylinders = user_cylinders;
 }
 
 /*
- * Read MBR.  Returns:
+ * Opens disk_device and optionally reads MBR.
+ *    If what == OPEN_MAIN:
+ *      Open device, read MBR.  Abort program on short read.  Create empty
+ *      disklabel if the on-disk structure is invalid (WRITABLE mode).
+ *    If what == TRY_ONLY:
+ *      Open device, read MBR.  Return an error if anything is out of place.
+ *      Do not create an empty disklabel.  This is used for the "list"
+ *      operations: "fdisk -l /dev/sda" and "fdisk -l" (all devices).
+ *    If what == CREATE_EMPTY_*:
+ *      This means that get_boot() was called recursively from create_*label().
+ *      Do not re-open the device; just set up the ptes array and print
+ *      geometry warnings.
+ *
+ * Returns:
  *   -1: no 0xaa55 flag present (possibly entire disk BSD)
  *    0: found or created label
  *    1: I/O error
  */
-static int
-get_boot(enum action what)
-{
-    int i;
-
-    partitions = 4;
-
+#if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
+static int get_boot(enum action what)
+#else
+static int get_boot(void)
+#define get_boot(what) get_boot()
+#endif
+{
+    int i, fd;
+
+    g_partitions = 4;
     for (i = 0; i < 4; i++) {
         struct pte *pe = &ptes[i];
-
         pe->part_table = pt_offset(MBRbuffer, i);
         pe->ext_pointer = NULL;
-        pe->offset = 0;
+        pe->offset_from_dev_start = 0;
         pe->sectorbuffer = MBRbuffer;
 #if ENABLE_FEATURE_FDISK_WRITABLE
-        pe->changed = (what == create_empty_dos);
-#endif
-    }
-
-#if ENABLE_FEATURE_SUN_LABEL
-    if (what == create_empty_sun && check_sun_label())
-        return 0;
-#endif
-
-    memset(MBRbuffer, 0, 512);
+        pe->changed = (what == CREATE_EMPTY_DOS);
+#endif
+    }
 
 #if ENABLE_FEATURE_FDISK_WRITABLE
-    if (what == create_empty_dos)
-        goto got_dos_table;             /* skip reading disk */
-
-    fd = open(disk_device, type_open);
+// ALERT! highly idiotic design!
+// We end up here when we call get_boot() recursively
+// via get_boot() [table is bad] -> create_doslabel() -> get_boot(CREATE_EMPTY_DOS).
+// or get_boot() [table is bad] -> create_sunlabel() -> get_boot(CREATE_EMPTY_SUN).
+// (just factor out re-init of ptes[0,1,2,3] in a separate fn instead?)
+// So skip opening device _again_...
+    if (what == CREATE_EMPTY_DOS  IF_FEATURE_SUN_LABEL(|| what == CREATE_EMPTY_SUN))
+        goto created_table;
+
+    fd = open(disk_device, (option_mask32 & OPT_l) ? O_RDONLY : O_RDWR);
+
     if (fd < 0) {
         fd = open(disk_device, O_RDONLY);
         if (fd < 0) {
-            if (what == try_only)
+            if (what == TRY_ONLY)
                 return 1;
             fdisk_fatal(unable_to_open);
-        } else
-            printf("You will not be able to write "
-                "the partition table\n");
-    }
-
-    if (512 != read(fd, MBRbuffer, 512)) {
-        if (what == try_only)
+        }
+        printf("'%s' is opened for read only\n", disk_device);
+    }
+    xmove_fd(fd, dev_fd);
+    if (512 != full_read(dev_fd, MBRbuffer, 512)) {
+        if (what == TRY_ONLY) {
+            close_dev_fd();
             return 1;
+        }
         fdisk_fatal(unable_to_read);
     }
@@ -1265 +1397 @@
     if (fd < 0)
         return 1;
-    if (512 != read(fd, MBRbuffer, 512))
+    if (512 != full_read(fd, MBRbuffer, 512)) {
+        close(fd);
         return 1;
+    }
+    xmove_fd(fd, dev_fd);
 #endif
 
     get_geometry();
-
     update_units();
 
@@ -1277 +1411 @@
         return 0;
 #endif
-
 #if ENABLE_FEATURE_SGI_LABEL
     if (check_sgi_label())
         return 0;
 #endif
-
 #if ENABLE_FEATURE_AIX_LABEL
     if (check_aix_label())
         return 0;
 #endif
-
+#if ENABLE_FEATURE_GPT_LABEL
+    if (check_gpt_label())
+        return 0;
+#endif
 #if ENABLE_FEATURE_OSF_LABEL
     if (check_osf_label()) {
         possibly_osf_label = 1;
         if (!valid_part_table_flag(MBRbuffer)) {
-            current_label_type = label_osf;
+            current_label_type = LABEL_OSF;
             return 0;
         }
@@ -1300 +1435 @@
 #endif
 
-#if ENABLE_FEATURE_FDISK_WRITABLE
- got_dos_table:
-#endif
-
-    if (!valid_part_table_flag(MBRbuffer)) {
 #if !ENABLE_FEATURE_FDISK_WRITABLE
+    if (!valid_part_table_flag(MBRbuffer))
         return -1;
 #else
-        switch (what) {
-        case fdisk:
+    if (!valid_part_table_flag(MBRbuffer)) {
+        if (what == OPEN_MAIN) {
             printf("Device contains neither a valid DOS "
-                  "partition table, nor Sun, SGI or OSF "
+                  "partition table, nor Sun, SGI, OSF or GPT "
                   "disklabel\n");
 #ifdef __sparc__
-#if ENABLE_FEATURE_SUN_LABEL
-            create_sunlabel();
-#endif
+            IF_FEATURE_SUN_LABEL(create_sunlabel();)
 #else
             create_doslabel();
 #endif
             return 0;
-        case try_only:
-            return -1;
-        case create_empty_dos:
-#if ENABLE_FEATURE_SUN_LABEL
-        case create_empty_sun:
-#endif
-            break;
-        default:
-            bb_error_msg_and_die("internal error");
-        }
+        }
+        /* TRY_ONLY: */
+        return -1;
+    }
+ created_table:
 #endif /* FEATURE_FDISK_WRITABLE */
-    }
-
-#if ENABLE_FEATURE_FDISK_WRITABLE
-    warn_cylinders();
-#endif
+
+
+    IF_FEATURE_FDISK_WRITABLE(warn_cylinders();)
     warn_geometry();
 
     for (i = 0; i < 4; i++) {
-        struct pte *pe = &ptes[i];
-
-        if (IS_EXTENDED(pe->part_table->sys_ind)) {
-            if (partitions != 4)
+        if (IS_EXTENDED(ptes[i].part_table->sys_ind)) {
+            if (g_partitions != 4)
                 printf("Ignoring extra extended "
-                    "partition %d\n", i + 1);
+                    "partition %u\n", i + 1);
             else
                 read_extended(i);
@@ -1351 +1471 @@
     }
 
-    for (i = 3; i < partitions; i++) {
+    for (i = 3; i < g_partitions; i++) {
         struct pte *pe = &ptes[i];
-
         if (!valid_part_table_flag(pe->sectorbuffer)) {
             printf("Warning: invalid flag 0x%02x,0x%02x of partition "
-                "table %d will be corrected by w(rite)\n",
+                "table %u will be corrected by w(rite)\n",
                 pe->sectorbuffer[510],
                 pe->sectorbuffer[511],
                 i + 1);
-#if ENABLE_FEATURE_FDISK_WRITABLE
-            pe->changed = 1;
-#endif
+            IF_FEATURE_FDISK_WRITABLE(pe->changed = 1;)
         }
     }
@@ -1377 +1494 @@
  * There is no default if DFLT is not between LOW and HIGH.
  */
-static unsigned
-read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg)
-{
-    unsigned i;
+static sector_t
+read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg)
+{
+    sector_t value;
     int default_ok = 1;
     const char *fmt = "%s (%u-%u, default %u): ";
@@ -1403 +1520 @@
             int absolute = 0;
 
-            i = atoi(line_ptr + 1);
-
+            value = atoi(line_ptr + 1);
+
+            /* (1) if 2nd char is digit, use_default = 0.
+             * (2) move line_ptr to first non-digit. */
             while (isdigit(*++line_ptr))
                 use_default = 0;
@@ -1412 +1531 @@
             case 'C':
                 if (!display_in_cyl_units)
-                    i *= heads * sectors;
+                    value *= g_heads * g_sectors;
                 break;
             case 'K':
@@ -1435 +1554 @@
                 unsigned long unit;
 
-                bytes = (ullong) i * absolute;
+                bytes = (ullong) value * absolute;
                 unit = sector_size * units_per_sector;
                 bytes += unit/2; /* round */
                 bytes /= unit;
-                i = bytes;
+                value = bytes;
             }
             if (minus)
-                i = -i;
-            i += base;
+                value = -value;
+            value += base;
         } else {
-            i = atoi(line_ptr);
+            value = atoi(line_ptr);
             while (isdigit(*line_ptr)) {
                 line_ptr++;
@@ -1452 +1571 @@
         }
         if (use_default) {
-            i = dflt;
-            printf("Using default value %u\n", i);
-        }
-        if (i >= low && i <= high)
+            value = dflt;
+            printf("Using default value %u\n", value);
+        }
+        if (value >= low && value <= high)
             break;
         printf("Value is out of range\n");
     }
-    return i;
-}
-
-static int
-get_partition(int warn, int max)
+    return value;
+}
+
+static unsigned
+get_partition(int warn, unsigned max)
 {
     struct pte *pe;
-    int i;
+    unsigned i;
 
     i = read_int(1, 0, max, 0, "Partition number") - 1;
@@ -1476 +1595 @@
          || (LABEL_IS_SGI && !sgi_get_num_sectors(i))
         ) {
-            printf("Warning: partition %d has empty type\n", i+1);
+            printf("Warning: partition %u has empty type\n", i+1);
         }
     }
@@ -1483 +1602 @@
 
 static int
-get_existing_partition(int warn, int max)
+get_existing_partition(int warn, unsigned max)
 {
     int pno = -1;
-    int i;
+    unsigned i;
 
     for (i = 0; i < max; i++) {
@@ -1499 +1618 @@
     }
     if (pno >= 0) {
-        printf("Selected partition %d\n", pno+1);
+        printf("Selected partition %u\n", pno+1);
         return pno;
     }
@@ -1510 +1629 @@
 
 static int
-get_nonexisting_partition(int warn, int max)
+get_nonexisting_partition(int warn, unsigned max)
 {
     int pno = -1;
-    int i;
+    unsigned i;
 
     for (i = 0; i < max; i++) {
@@ -1526 +1645 @@
     }
     if (pno >= 0) {
-        printf("Selected partition %d\n", pno+1);
+        printf("Selected partition %u\n", pno+1);
         return pno;
     }
@@ -1553 +1672 @@
 
     if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
-        printf("WARNING: Partition %d is an extended partition\n", i + 1);
+        printf("WARNING: Partition %u is an extended partition\n", i + 1);
     p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
     pe->changed = 1;
@@ -1561 +1680 @@
 toggle_dos_compatibility_flag(void)
 {
-    dos_compatible_flag = ~dos_compatible_flag;
+    dos_compatible_flag = 1 - dos_compatible_flag;
     if (dos_compatible_flag) {
-        sector_offset = sectors;
+        sector_offset = g_sectors;
         printf("DOS Compatibility flag is set\n");
     } else {
@@ -1597 +1716 @@
     if (i < 4) {
         if (IS_EXTENDED(p->sys_ind) && i == ext_index) {
-            partitions = 4;
+            g_partitions = 4;
             ptes[ext_index].ext_pointer = NULL;
             extended_offset = 0;
@@ -1607 +1726 @@
     if (!q->sys_ind && i > 4) {
         /* the last one in the chain - just delete */
-        --partitions;
+        --g_partitions;
         --i;
         clear_partition(ptes[i].ext_pointer);
@@ -1620 +1739 @@
             set_nr_sects(p, get_nr_sects(q));
             ptes[i-1].changed = 1;
-        } else if (partitions > 5) {    /* 5 will be moved to 4 */
+        } else if (g_partitions > 5) {    /* 5 will be moved to 4 */
             /* the first logical in a longer chain */
             pe = &ptes[5];
@@ -1626 +1745 @@
             if (pe->part_table) /* prevent SEGFAULT */
                 set_start_sect(pe->part_table,
-                           get_partition_start(pe) -
-                           extended_offset);
-            pe->offset = extended_offset;
+                        get_partition_start_from_dev_start(pe) -
+                        extended_offset);
+            pe->offset_from_dev_start = extended_offset;
             pe->changed = 1;
         }
 
-        if (partitions > 5) {
-            partitions--;
-            while (i < partitions) {
+        if (g_partitions > 5) {
+            g_partitions--;
+            while (i < g_partitions) {
                 ptes[i] = ptes[i+1];
                 i++;
             }
-        } else
+        } else {
             /* the only logical: clear only */
             clear_partition(ptes[i].part_table);
+        }
     }
 }
@@ -1654 +1774 @@
        only works for Linux like partition tables. */
     if (!LABEL_IS_SGI) {
-        i = get_existing_partition(0, partitions);
+        i = get_existing_partition(0, g_partitions);
     } else {
-        i = get_partition(0, partitions);
+        i = get_partition(0, g_partitions);
     }
     if (i == -1)
@@ -1666 +1786 @@
        the reverse change must be allowed, too */
     if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) {
-        printf("Partition %d does not exist yet!\n", i + 1);
+        printf("Partition %u does not exist yet!\n", i + 1);
         return;
     }
@@ -1717 +1837 @@
                 p->sys_ind = sys;
 
-            printf("Changed system type of partition %d "
+            printf("Changed system type of partition %u "
                 "to %x (%s)\n", i + 1, sys,
                 partition_type(sys));
             ptes[i].changed = 1;
-            if (is_dos_partition(origsys) ||
-                is_dos_partition(sys))
-                dos_changed = 1;
+            //if (is_dos_partition(origsys) || is_dos_partition(sys))
+            //  dos_changed = 1;
             break;
         }
@@ -1739 +1858 @@
 linear2chs(unsigned ls, unsigned *c, unsigned *h, unsigned *s)
 {
-    int spc = heads * sectors;
+    int spc = g_heads * g_sectors;
 
     *c = ls / spc;
     ls = ls % spc;
-    *h = ls / sectors;
-    *s = ls % sectors + 1;  /* sectors count from 1 */
+    *h = ls / g_sectors;
+    *s = ls % g_sectors + 1;  /* sectors count from 1 */
 }
 
@@ -1755 +1874 @@
     unsigned lec, leh, les;          /* logical ending c, h, s */
 
-    if (!heads || !sectors || (partition >= 4))
+    if (!g_heads || !g_sectors || (partition >= 4))
         return;         /* do not check extended partitions */
 
@@ -1775 +1894 @@
 
 /* Same physical / logical beginning? */
-    if (cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
-        printf("Partition %d has different physical/logical "
+    if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
+        printf("Partition %u has different physical/logical "
             "beginnings (non-Linux?):\n", partition + 1);
-        printf("     phys=(%d, %d, %d) ", pbc, pbh, pbs);
-        printf("logical=(%d, %d, %d)\n",lbc, lbh, lbs);
+        printf("     phys=(%u, %u, %u) ", pbc, pbh, pbs);
+        printf("logical=(%u, %u, %u)\n", lbc, lbh, lbs);
     }
 
 /* Same physical / logical ending? */
-    if (cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
-        printf("Partition %d has different physical/logical "
+    if (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
+        printf("Partition %u has different physical/logical "
             "endings:\n", partition + 1);
-        printf("     phys=(%d, %d, %d) ", pec, peh, pes);
-        printf("logical=(%d, %d, %d)\n", lec, leh, les);
+        printf("     phys=(%u, %u, %u) ", pec, peh, pes);
+        printf("logical=(%u, %u, %u)\n", lec, leh, les);
     }
 
 /* Ending on cylinder boundary? */
-    if (peh != (heads - 1) || pes != sectors) {
-        printf("Partition %i does not end on cylinder boundary\n",
+    if (peh != (g_heads - 1) || pes != g_sectors) {
+        printf("Partition %u does not end on cylinder boundary\n",
             partition + 1);
     }
@@ -1800 +1919 @@
 list_disk_geometry(void)
 {
-    long long bytes = (total_number_of_sectors << 9);
-    long megabytes = bytes/1000000;
+    ullong bytes = ((ullong)total_number_of_sectors << 9);
+    long megabytes = bytes / 1000000;
 
     if (megabytes < 10000)
-        printf("\nDisk %s: %ld MB, %lld bytes\n",
-               disk_device, megabytes, bytes);
+        printf("\nDisk %s: %lu MB, %llu bytes\n",
+            disk_device, megabytes, bytes);
     else
-        printf("\nDisk %s: %ld.%ld GB, %lld bytes\n",
-               disk_device, megabytes/1000, (megabytes/100)%10, bytes);
-    printf("%d heads, %d sectors/track, %d cylinders",
-           heads, sectors, cylinders);
+        printf("\nDisk %s: %lu.%lu GB, %llu bytes\n",
+            disk_device, megabytes/1000, (megabytes/100)%10, bytes);
+    printf("%u heads, %u sectors/track, %u cylinders",
+           g_heads, g_sectors, g_cylinders);
     if (units_per_sector == 1)
-        printf(", total %llu sectors",
-               total_number_of_sectors / (sector_size/512));
-    printf("\nUnits = %s of %d * %d = %d bytes\n\n",
-           str_units(PLURAL),
-           units_per_sector, sector_size, units_per_sector * sector_size);
+        printf(", total %"SECT_FMT"u sectors",
+            total_number_of_sectors / (sector_size/512));
+    printf("\nUnits = %s of %u * %u = %u bytes\n\n",
+        str_units(PLURAL),
+        units_per_sector, sector_size, units_per_sector * sector_size);
 }
 
@@ -1829 +1948 @@
     const struct pte *pe;
     const struct partition *p;
-    ullong last_p_start_pos = 0, p_start_pos;
-    int i, last_i = 0;
-
-    for (i = 0; i < partitions; i++) {
+    sector_t last_p_start_pos = 0, p_start_pos;
+    unsigned i, last_i = 0;
+
+    for (i = 0; i < g_partitions; i++) {
         if (i == 4) {
             last_i = 4;
@@ -1838 +1957 @@
         }
         pe = &ptes[i];
-        if ((p = pe->part_table)->sys_ind) {
-            p_start_pos = get_partition_start(pe);
+        p = pe->part_table;
+        if (p->sys_ind) {
+            p_start_pos = get_partition_start_from_dev_start(pe);
 
             if (last_p_start_pos > p_start_pos) {
@@ -1877 +1997 @@
     /* (Its sector is the global extended_offset.) */
  stage1:
-    for (j = 5; j < partitions-1; j++) {
-        oj = ptes[j].offset;
-        ojj = ptes[j+1].offset;
+    for (j = 5; j < g_partitions - 1; j++) {
+        oj = ptes[j].offset_from_dev_start;
+        ojj = ptes[j+1].offset_from_dev_start;
         if (oj > ojj) {
-            ptes[j].offset = ojj;
-            ptes[j+1].offset = oj;
+            ptes[j].offset_from_dev_start = ojj;
+            ptes[j+1].offset_from_dev_start = oj;
             pj = ptes[j].part_table;
             set_start_sect(pj, get_start_sect(pj)+oj-ojj);
@@ -1897 +2017 @@
     /* Stage 2: sort starting sectors */
  stage2:
-    for (j = 4; j < partitions-1; j++) {
+    for (j = 4; j < g_partitions - 1; j++) {
         pj = ptes[j].part_table;
         pjj = ptes[j+1].part_table;
         sj = get_start_sect(pj);
         sjj = get_start_sect(pjj);
-        oj = ptes[j].offset;
-        ojj = ptes[j+1].offset;
+        oj = ptes[j].offset_from_dev_start;
+        ojj = ptes[j+1].offset_from_dev_start;
         if (oj+sj > ojj+sjj) {
             tmp = *pj;
@@ -1915 +2035 @@
 
     /* Probably something was changed */
-    for (j = 4; j < partitions; j++)
+    for (j = 4; j < g_partitions; j++)
         ptes[j].changed = 1;
 }
@@ -1956 +2076 @@
 
     printf("Done.\n");
-
 }
 #endif
@@ -1970 +2089 @@
         return;
     }
-    if (LABEL_IS_SUN) {
+    if (LABEL_IS_SGI) {
         sgi_list_table(xtra);
+        return;
+    }
+    if (LABEL_IS_GPT) {
+        gpt_list_table(xtra);
         return;
     }
@@ -1995 +2118 @@
            w+1, "Device");
 
-    for (i = 0; i < partitions; i++) {
+    for (i = 0; i < g_partitions; i++) {
         const struct pte *pe = &ptes[i];
-        ullong psects;
-        ullong pblocks;
+        sector_t psects;
+        sector_t pblocks;
         unsigned podd;
 
@@ -2016 +2139 @@
             pblocks *= (sector_size / 1024);
 
-        printf("%s  %c %11llu %11llu %11llu%c %2x %s\n",
+        printf("%s  %c %11"SECT_FMT"u %11"SECT_FMT"u %11"SECT_FMT"u%c %2x %s\n",
             partname(disk_device, i+1, w+2),
             !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */
                 ? '*' : '?',
-            (ullong) cround(get_partition_start(pe)),           /* start */
-            (ullong) cround(get_partition_start(pe) + psects    /* end */
+            cround(get_partition_start_from_dev_start(pe)),           /* start */
+            cround(get_partition_start_from_dev_start(pe) + psects    /* end */
                 - (psects ? 1 : 0)),
-            (ullong) pblocks, podd ? '+' : ' ', /* odd flag on end */
+            pblocks, podd ? '+' : ' ', /* odd flag on end */
             p->sys_ind,                                     /* type id */
             partition_type(p->sys_ind));                    /* type name */
@@ -2031 +2154 @@
 
     /* Is partition table in disk order? It need not be, but... */
-    /* partition table entries are not checked for correct order if this
-       is a sgi, sun or aix labeled disk... */
+    /* partition table entries are not checked for correct order
+     * if this is a sgi, sun or aix labeled disk... */
     if (LABEL_IS_DOS && wrong_p_order(NULL)) {
         /* FIXME */
@@ -2047 +2170 @@
     int i;
 
-    printf("\nDisk %s: %d heads, %d sectors, %d cylinders\n\n",
-        disk_device, heads, sectors, cylinders);
+    printf("\nDisk %s: %u heads, %u sectors, %u cylinders\n\n",
+        disk_device, g_heads, g_sectors, g_cylinders);
     printf("Nr AF  Hd Sec  Cyl  Hd Sec  Cyl      Start       Size ID\n");
-    for (i = 0; i < partitions; i++) {
+    for (i = 0; i < g_partitions; i++) {
         pe = &ptes[i];
         p = (extend ? pe->ext_pointer : pe->part_table);
         if (p != NULL) {
-            printf("%2d %02x%4d%4d%5d%4d%4d%5d%11u%11u %02x\n",
+            printf("%2u %02x%4u%4u%5u%4u%4u%5u%11"SECT_FMT"u%11"SECT_FMT"u %02x\n",
                 i + 1, p->boot_ind, p->head,
                 sector(p->sector),
@@ -2060 +2183 @@
                 sector(p->end_sector),
                 cylinder(p->end_sector, p->end_cyl),
-                get_start_sect(p), get_nr_sects(p), p->sys_ind);
+                get_start_sect(p), get_nr_sects(p),
+                p->sys_ind);
             if (p->sys_ind)
                 check_consistency(p, i);
@@ -2070 +2194 @@
 #if ENABLE_FEATURE_FDISK_WRITABLE
 static void
-fill_bounds(ullong *first, ullong *last)
-{
-    int i;
+fill_bounds(sector_t *first, sector_t *last)
+{
+    unsigned i;
     const struct pte *pe = &ptes[0];
     const struct partition *p;
 
-    for (i = 0; i < partitions; pe++,i++) {
+    for (i = 0; i < g_partitions; pe++,i++) {
         p = pe->part_table;
         if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) {
@@ -2082 +2206 @@
             last[i] = 0;
         } else {
-            first[i] = get_partition_start(pe);
+            first[i] = get_partition_start_from_dev_start(pe);
             last[i] = first[i] + get_nr_sects(p) - 1;
         }
@@ -2089 +2213 @@
 
 static void
-check(int n, unsigned h, unsigned s, unsigned c, ullong start)
-{
-    ullong total, real_s, real_c;
+check(int n, unsigned h, unsigned s, unsigned c, sector_t start)
+{
+    sector_t total, real_s, real_c;
 
     real_s = sector(s) - 1;
     real_c = cylinder(s, c);
-    total = (real_c * sectors + real_s) * heads + h;
+    total = (real_c * g_sectors + real_s) * g_heads + h;
     if (!total)
-        printf("Partition %d contains sector 0\n", n);
-    if (h >= heads)
-        printf("Partition %d: head %d greater than maximum %d\n",
-            n, h + 1, heads);
-    if (real_s >= sectors)
-        printf("Partition %d: sector %d greater than "
-            "maximum %d\n", n, s, sectors);
-    if (real_c >= cylinders)
-        printf("Partition %d: cylinder %llu greater than "
-            "maximum %d\n", n, real_c + 1, cylinders);
-    if (cylinders <= 1024 && start != total)
-        printf("Partition %d: previous sectors %llu disagrees with "
-            "total %llu\n", n, start, total);
+        printf("Partition %u contains sector 0\n", n);
+    if (h >= g_heads)
+        printf("Partition %u: head %u greater than maximum %u\n",
+            n, h + 1, g_heads);
+    if (real_s >= g_sectors)
+        printf("Partition %u: sector %u greater than "
+            "maximum %u\n", n, s, g_sectors);
+    if (real_c >= g_cylinders)
+        printf("Partition %u: cylinder %"SECT_FMT"u greater than "
+            "maximum %u\n", n, real_c + 1, g_cylinders);
+    if (g_cylinders <= 1024 && start != total)
+        printf("Partition %u: previous sectors %"SECT_FMT"u disagrees with "
+            "total %"SECT_FMT"u\n", n, start, total);
 }
 
@@ -2116 +2240 @@
 {
     int i, j;
-    unsigned total = 1;
-    ullong first[partitions], last[partitions];
+    sector_t total = 1;
+    sector_t first[g_partitions], last[g_partitions];
     struct partition *p;
 
@@ -2133 +2257 @@
 
     fill_bounds(first, last);
-    for (i = 0; i < partitions; i++) {
+    for (i = 0; i < g_partitions; i++) {
         struct pte *pe = &ptes[i];
 
@@ -2139 +2263 @@
         if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
             check_consistency(p, i);
-            if (get_partition_start(pe) < first[i])
+            if (get_partition_start_from_dev_start(pe) < first[i])
                 printf("Warning: bad start-of-data in "
-                    "partition %d\n", i + 1);
+                    "partition %u\n", i + 1);
             check(i + 1, p->end_head, p->end_sector, p->end_cyl,
                 last[i]);
@@ -2148 +2272 @@
                 if ((first[i] >= first[j] && first[i] <= last[j])
                  || ((last[i] <= last[j] && last[i] >= first[j]))) {
-                    printf("Warning: partition %d overlaps "
-                        "partition %d\n", j + 1, i + 1);
+                    printf("Warning: partition %u overlaps "
+                        "partition %u\n", j + 1, i + 1);
                     total += first[i] >= first[j] ?
                         first[i] : first[j];
@@ -2161 +2285 @@
     if (extended_offset) {
         struct pte *pex = &ptes[ext_index];
-        ullong e_last = get_start_sect(pex->part_table) +
+        sector_t e_last = get_start_sect(pex->part_table) +
             get_nr_sects(pex->part_table) - 1;
 
-        for (i = 4; i < partitions; i++) {
+        for (i = 4; i < g_partitions; i++) {
             total++;
             p = ptes[i].part_table;
             if (!p->sys_ind) {
-                if (i != 4 || i + 1 < partitions)
-                    printf("Warning: partition %d "
+                if (i != 4 || i + 1 < g_partitions)
+                    printf("Warning: partition %u "
                         "is empty\n", i + 1);
             } else if (first[i] < extended_offset || last[i] > e_last) {
-                printf("Logical partition %d not entirely in "
-                    "partition %d\n", i + 1, ext_index + 1);
+                printf("Logical partition %u not entirely in "
+                    "partition %u\n", i + 1, ext_index + 1);
             }
         }
     }
 
-    if (total > heads * sectors * cylinders)
-        printf("Total allocated sectors %d greater than the maximum "
-            "%d\n", total, heads * sectors * cylinders);
+    if (total > g_heads * g_sectors * g_cylinders)
+        printf("Total allocated sectors %u greater than the maximum "
+            "%u\n", total, g_heads * g_sectors * g_cylinders);
     else {
-        total = heads * sectors * cylinders - total;
+        total = g_heads * g_sectors * g_cylinders - total;
         if (total != 0)
-            printf("%d unallocated sectors\n", total);
+            printf("%"SECT_FMT"u unallocated sectors\n", total);
     }
 }
@@ -2195 +2319 @@
     struct partition *p = ptes[n].part_table;
     struct partition *q = ptes[ext_index].part_table;
-    ullong limit, temp;
-    ullong start, stop = 0;
-    ullong first[partitions], last[partitions];
+    sector_t limit, temp;
+    sector_t start, stop = 0;
+    sector_t first[g_partitions], last[g_partitions];
 
     if (p && p->sys_ind) {
@@ -2207 +2331 @@
         start = sector_offset;
         if (display_in_cyl_units || !total_number_of_sectors)
-            limit = (ullong) heads * sectors * cylinders - 1;
+            limit = (sector_t) g_heads * g_sectors * g_cylinders - 1;
         else
             limit = total_number_of_sectors - 1;
@@ -2220 +2344 @@
     }
     if (display_in_cyl_units)
-        for (i = 0; i < partitions; i++)
+        for (i = 0; i < g_partitions; i++)
             first[i] = (cround(first[i]) - 1) * units_per_sector;
 
@@ -2226 +2350 @@
     do {
         temp = start;
-        for (i = 0; i < partitions; i++) {
+        for (i = 0; i < g_partitions; i++) {
             int lastplusoff;
 
-            if (start == ptes[i].offset)
+            if (start == ptes[i].offset_from_dev_start)
                 start += sector_offset;
             lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
@@ -2238 +2362 @@
             break;
         if (start >= temp+units_per_sector && num_read) {
-            printf("Sector %lld is already allocated\n", temp);
+            printf("Sector %"SECT_FMT"u is already allocated\n", temp);
             temp = start;
             num_read = 0;
         }
         if (!num_read && start == temp) {
-            ullong saved_start;
+            sector_t saved_start;
 
             saved_start = start;
-            start = read_int(cround(saved_start), cround(saved_start), cround(limit),
-                     0, mesg);
+            start = read_int(cround(saved_start), cround(saved_start), cround(limit), 0, mesg);
             if (display_in_cyl_units) {
                 start = (start - 1) * units_per_sector;
-                if (start < saved_start) start = saved_start;
+                if (start < saved_start)
+                    start = saved_start;
             }
             num_read = 1;
@@ -2258 +2382 @@
         struct pte *pe = &ptes[n];
 
-        pe->offset = start - sector_offset;
-        if (pe->offset == extended_offset) { /* must be corrected */
-            pe->offset++;
+        pe->offset_from_dev_start = start - sector_offset;
+        if (pe->offset_from_dev_start == extended_offset) { /* must be corrected */
+            pe->offset_from_dev_start++;
             if (sector_offset == 1)
                 start++;
@@ -2266 +2390 @@
     }
 
-    for (i = 0; i < partitions; i++) {
+    for (i = 0; i < g_partitions; i++) {
         struct pte *pe = &ptes[i];
 
-        if (start < pe->offset && limit >= pe->offset)
-            limit = pe->offset - 1;
+        if (start < pe->offset_from_dev_start && limit >= pe->offset_from_dev_start)
+            limit = pe->offset_from_dev_start - 1;
         if (start < first[i] && limit >= first[i])
             limit = first[i] - 1;
@@ -2277 +2401 @@
         printf("No free sectors available\n");
         if (n > 4)
-            partitions--;
+            g_partitions--;
         return;
     }
@@ -2286 +2410 @@
              "Last %s or +size or +sizeM or +sizeK",
              str_units(SINGULAR));
-        stop = read_int(cround(start), cround(limit), cround(limit),
-                cround(start), mesg);
+        stop = read_int(cround(start), cround(limit), cround(limit), cround(start), mesg);
         if (display_in_cyl_units) {
             stop = stop * units_per_sector - 1;
@@ -2297 +2420 @@
     set_partition(n, 0, start, stop, sys);
     if (n > 4)
-        set_partition(n - 1, 1, ptes[n].offset, stop, EXTENDED);
+        set_partition(n - 1, 1, ptes[n].offset_from_dev_start, stop, EXTENDED);
 
     if (IS_EXTENDED(sys)) {
@@ -2305 +2428 @@
         ext_index = n;
         pen->ext_pointer = p;
-        pe4->offset = extended_offset = start;
+        pe4->offset_from_dev_start = extended_offset = start;
         pe4->sectorbuffer = xzalloc(sector_size);
         pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
         pe4->ext_pointer = pe4->part_table + 1;
         pe4->changed = 1;
-        partitions = 5;
+        g_partitions = 5;
     }
 }
@@ -2317 +2440 @@
 add_logical(void)
 {
-    if (partitions > 5 || ptes[4].part_table->sys_ind) {
-        struct pte *pe = &ptes[partitions];
+    if (g_partitions > 5 || ptes[4].part_table->sys_ind) {
+        struct pte *pe = &ptes[g_partitions];
 
         pe->sectorbuffer = xzalloc(sector_size);
         pe->part_table = pt_offset(pe->sectorbuffer, 0);
         pe->ext_pointer = pe->part_table + 1;
-        pe->offset = 0;
+        pe->offset_from_dev_start = 0;
         pe->changed = 1;
-        partitions++;
-    }
-    add_partition(partitions - 1, LINUX_NATIVE);
+        g_partitions++;
+    }
+    add_partition(g_partitions - 1, LINUX_NATIVE);
 }
 
@@ -2339 +2462 @@
 
     if (LABEL_IS_SUN) {
-        add_sun_partition(get_partition(0, partitions), LINUX_NATIVE);
+        add_sun_partition(get_partition(0, g_partitions), LINUX_NATIVE);
         return;
     }
     if (LABEL_IS_SGI) {
-        sgi_add_partition(get_partition(0, partitions), LINUX_NATIVE);
+        sgi_add_partition(get_partition(0, g_partitions), LINUX_NATIVE);
         return;
     }
@@ -2356 +2479 @@
         free_primary += !ptes[i].part_table->sys_ind;
 
-    if (!free_primary && partitions >= MAXIMUM_PARTS) {
+    if (!free_primary && g_partitions >= MAXIMUM_PARTS) {
         printf("The maximum number of partitions has been created\n");
         return;
@@ -2377 +2500 @@
         while (1) {
             c = read_nonempty(line);
-            if (c == 'p' || c == 'P') {
+            if ((c | 0x20) == 'p') {
                 i = get_nonexisting_partition(0, 4);
                 if (i >= 0)
@@ -2408 +2531 @@
             if (ptes[i].changed)
                 ptes[3].changed = 1;
-        for (i = 3; i < partitions; i++) {
+        for (i = 3; i < g_partitions; i++) {
             struct pte *pe = &ptes[i];
 
             if (pe->changed) {
                 write_part_table_flag(pe->sectorbuffer);
-                write_sector(pe->offset, pe->sectorbuffer);
+                write_sector(pe->offset_from_dev_start, pe->sectorbuffer);
             }
         }
@@ -2443 +2566 @@
     sync();
     /* sleep(2); Huh? */
-    i = ioctl_or_perror(fd, BLKRRPART, NULL,
+    i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
             "WARNING: rereading partition table "
             "failed, kernel still uses old table");
@@ -2456 +2579 @@
     if (leave) {
         if (ENABLE_FEATURE_CLEAN_UP)
-            close(fd);
+            close_dev_fd();
         exit(i != 0);
     }
@@ -2474 +2597 @@
         printf(" %02X", (unsigned char) pbuffer[i]);
         if (l == MAX_PER_LINE - 1) {
-            puts("");
+            bb_putchar('\n');
             l = -1;
         }
     }
     if (l > 0)
-        puts("");
-    puts("");
+        bb_putchar('\n');
+    bb_putchar('\n');
 }
 
@@ -2492 +2615 @@
         print_buffer(MBRbuffer);
     else {
-        for (i = 3; i < partitions; i++)
+        for (i = 3; i < g_partitions; i++)
             print_buffer(ptes[i].sectorbuffer);
     }
@@ -2498 +2621 @@
 
 static void
-move_begin(int i)
+move_begin(unsigned i)
 {
     struct pte *pe = &ptes[i];
     struct partition *p = pe->part_table;
-    ullong new, first;
+    sector_t new, first, nr_sects;
 
     if (warn_geometry())
         return;
-    if (!p->sys_ind || !get_nr_sects(p) || IS_EXTENDED(p->sys_ind)) {
-        printf("Partition %d has no data area\n", i + 1);
+    nr_sects = get_nr_sects(p);
+    if (!p->sys_ind || !nr_sects || IS_EXTENDED(p->sys_ind)) {
+        printf("Partition %u has no data area\n", i + 1);
         return;
     }
-    first = get_partition_start(pe);
-    new = read_int(first, first, first + get_nr_sects(p) - 1, first,
-               "New beginning of data") - pe->offset;
-
-    if (new != get_nr_sects(p)) {
-        first = get_nr_sects(p) + get_start_sect(p) - new;
-        set_nr_sects(p, first);
-        set_start_sect(p, new);
+    first = get_partition_start_from_dev_start(pe); /* == pe->offset_from_dev_start + get_start_sect(p) */
+    new = read_int(0 /*was:first*/, first, first + nr_sects - 1, first, "New beginning of data");
+    if (new != first) {
+        sector_t new_relative = new - pe->offset_from_dev_start;
+        nr_sects += (get_start_sect(p) - new_relative);
+        set_start_sect(p, new_relative);
+        set_nr_sects(p, nr_sects);
+        read_nonempty("Recalculate C/H/S values? (Y/N): ");
+        if ((line_ptr[0] | 0x20) == 'y')
+            set_hsc_start_end(p, new, new + nr_sects - 1);
         pe->changed = 1;
     }
@@ -2528 +2654 @@
 
     while (1) {
-        putchar('\n');
-        c = tolower(read_nonempty("Expert command (m for help): "));
+        bb_putchar('\n');
+        c = 0x20 | read_nonempty("Expert command (m for help): ");
         switch (c) {
         case 'a':
@@ -2537 +2663 @@
         case 'b':
             if (LABEL_IS_DOS)
-                move_begin(get_partition(0, partitions));
+                move_begin(get_partition(0, g_partitions));
             break;
         case 'c':
-            user_cylinders = cylinders =
-                read_int(1, cylinders, 1048576, 0,
+            user_cylinders = g_cylinders =
+                read_int(1, g_cylinders, 1048576, 0,
                     "Number of cylinders");
             if (LABEL_IS_SUN)
-                sun_set_ncyl(cylinders);
+                sun_set_ncyl(g_cylinders);
             if (LABEL_IS_DOS)
                 warn_cylinders();
@@ -2569 +2695 @@
             break;
         case 'h':
-            user_heads = heads = read_int(1, heads, 256, 0,
-                    "Number of heads");
+            user_heads = g_heads = read_int(1, g_heads, 256, 0, "Number of heads");
             update_units();
             break;
@@ -2588 +2713 @@
             break;
         case 'q':
-            close(fd);
-            puts("");
-            exit(0);
+            if (ENABLE_FEATURE_CLEAN_UP)
+                close_dev_fd();
+            bb_putchar('\n');
+            exit(EXIT_SUCCESS);
         case 'r':
             return;
         case 's':
-            user_sectors = sectors = read_int(1, sectors, 63, 0,
-                       "Number of sectors");
+            user_sectors = g_sectors = read_int(1, g_sectors, 63, 0, "Number of sectors");
             if (dos_compatible_flag) {
-                sector_offset = sectors;
+                sector_offset = g_sectors;
                 printf("Warning: setting sector offset for DOS "
                     "compatiblity\n");
@@ -2639 +2764 @@
 
     snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
-    procf = fopen(buf, "r");
+    procf = fopen_for_read(buf);
     if (procf != NULL && fgets(buf, sizeof(buf), procf))
         is_ide = (!strncmp(buf, "cdrom", 5) ||
@@ -2656 +2781 @@
 
 static void
-trydev(const char *device, int user_specified)
+open_list_and_close(const char *device, int user_specified)
 {
     int gb;
@@ -2666 +2791 @@
         if (is_ide_cdrom_or_tape(device))
             return;
-    fd = open(disk_device, type_open);
-    if (fd >= 0) {
-        gb = get_boot(try_only);
-        if (gb > 0) {   /* I/O error */
-            close(fd);
-        } else if (gb < 0) { /* no DOS signature */
-            list_disk_geometry();
-            if (LABEL_IS_AIX) {
-                return;
-            }
-#if ENABLE_FEATURE_OSF_LABEL
-            if (bsd_trydev(device) < 0)
-#endif
-                printf("Disk %s doesn't contain a valid "
-                    "partition table\n", device);
-            close(fd);
-        } else {
-            close(fd);
-            list_table(0);
-#if ENABLE_FEATURE_FDISK_WRITABLE
-            if (!LABEL_IS_SUN && partitions > 4){
-                delete_partition(ext_index);
-            }
-#endif
-        }
-    } else {
+
+    /* Open disk_device, save file descriptor to dev_fd */
+    errno = 0;
+    gb = get_boot(TRY_ONLY);
+    if (gb > 0) {   /* I/O error */
         /* Ignore other errors, since we try IDE
            and SCSI hard disks which may not be
            installed on the system. */
-        if (errno == EACCES) {
-            printf("Cannot open %s\n", device);
-            return;
-        }
-    }
+        if (user_specified || errno == EACCES)
+            bb_perror_msg("can't open '%s'", device);
+        return;
+    }
+
+    if (gb < 0) { /* no DOS signature */
+        list_disk_geometry();
+        if (LABEL_IS_AIX)
+            goto ret;
+#if ENABLE_FEATURE_OSF_LABEL
+        if (bsd_trydev(device) < 0)
+#endif
+            printf("Disk %s doesn't contain a valid "
+                "partition table\n", device);
+    } else {
+        list_table(0);
+#if ENABLE_FEATURE_FDISK_WRITABLE
+        if (!LABEL_IS_SUN && g_partitions > 4) {
+            delete_partition(ext_index);
+        }
+#endif
+    }
+ ret:
+    close_dev_fd();
 }
 
@@ -2705 +2828 @@
    that look like a partition name (do not end in a digit) */
 static void
-tryprocpt(void)
+list_devs_in_proc_partititons(void)
 {
     FILE *procpt;
@@ -2714 +2837 @@
 
     while (fgets(line, sizeof(line), procpt)) {
-        if (sscanf(line, " %d %d %d %[^\n ]",
+        if (sscanf(line, " %u %u %u %[^\n ]",
                 &ma, &mi, &sz, ptname) != 4)
             continue;
-        for (s = ptname; *s; s++);
-        if (isdigit(s[-1]))
+        for (s = ptname; *s; s++)
+            continue;
+        /* note: excluding '0': e.g. mmcblk0 is not a partition name! */
+        if (s[-1] >= '1' && s[-1] <= '9')
             continue;
         sprintf(devname, "/dev/%s", ptname);
-        trydev(devname, 0);
+        open_list_and_close(devname, 0);
     }
 #if ENABLE_FEATURE_CLEAN_UP
@@ -2736 +2861 @@
 #endif
 
-int fdisk_main(int argc, char **argv);
-int fdisk_main(int argc, char **argv)
-{
-    char *str_b, *str_C, *str_H, *str_S;
+int fdisk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int fdisk_main(int argc UNUSED_PARAM, char **argv)
+{
     unsigned opt;
     /*
@@ -2749 +2873 @@
      * Options -C, -H, -S set the geometry.
      */
-    enum {
-        OPT_b = 1 << 0,
-        OPT_C = 1 << 1,
-        OPT_H = 1 << 2,
-        OPT_l = 1 << 3,
-        OPT_S = 1 << 4,
-        OPT_u = 1 << 5,
-        OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
-    };
-
-    PTR_TO_GLOBALS = xzalloc(sizeof(G));
-
-    opt = getopt32(argv, "b:C:H:lS:u" USE_FEATURE_FDISK_BLKSIZE("s"),
-                &str_b, &str_C, &str_H, &str_S);
-    argc -= optind;
+    INIT_G();
+
+    close_dev_fd(); /* needed: fd 3 must not stay closed */
+
+    opt_complementary = "b+:C+:H+:S+"; /* numeric params */
+    opt = getopt32(argv, "b:C:H:lS:u" IF_FEATURE_FDISK_BLKSIZE("s"),
+                &sector_size, &user_cylinders, &user_heads, &user_sectors);
     argv += optind;
-    if (opt & OPT_b) { // -b
+    if (opt & OPT_b) {
         /* Ugly: this sector size is really per device,
-           so cannot be combined with multiple disks,
-           and the same goes for the C/H/S options.
-        */
-        sector_size = xatoi_u(str_b);
-        if (sector_size != 512 && sector_size != 1024 &&
-            sector_size != 2048)
+         * so cannot be combined with multiple disks,
+         * and the same goes for the C/H/S options.
+         */
+        if (sector_size < 512
+         || sector_size > 0x10000
+         || (sector_size & (sector_size-1)) /* not power of 2 */
+        ) {
             bb_show_usage();
+        }
         sector_offset = 2;
         user_set_sector_size = 1;
     }
-    if (opt & OPT_C) user_cylinders = xatoi_u(str_C); // -C
-    if (opt & OPT_H) { // -H
-        user_heads = xatoi_u(str_H);
-        if (user_heads <= 0 || user_heads >= 256)
-            user_heads = 0;
-    }
-    //if (opt & OPT_l) // -l
-    if (opt & OPT_S) { // -S
-        user_sectors = xatoi_u(str_S);
-        if (user_sectors <= 0 || user_sectors >= 64)
-            user_sectors = 0;
-    }
-    if (opt & OPT_u) display_in_cyl_units = 0; // -u
-    //if (opt & OPT_s) // -s
-
-    if (user_set_sector_size && argc != 1)
-        printf("Warning: the -b (set sector size) option should"
-             " be used with one specified device\n");
+    if (user_heads <= 0 || user_heads >= 256)
+        user_heads = 0;
+    if (user_sectors <= 0 || user_sectors >= 64)
+        user_sectors = 0;
+    if (opt & OPT_u)
+        display_in_cyl_units = 0; // -u
 
 #if ENABLE_FEATURE_FDISK_WRITABLE
@@ -2800 +2906 @@
         nowarn = 1;
 #endif
-        type_open = O_RDONLY;
-        if (argc > 0) {
-            int k;
-#if defined(__GNUC__)
-            /* avoid gcc warning:
-               variable `k' might be clobbered by `longjmp' */
-            (void)&k;
-#endif
+        if (*argv) {
             listing = 1;
-            for (k = 0; k < argc; k++)
-                trydev(argv[k], 1);
+            do {
+                open_list_and_close(*argv, 1);
+            } while (*++argv);
         } else {
-            /* we no longer have default device names */
-            /* but, we can use /proc/partitions instead */
-            tryprocpt();
+            /* we don't have device names, */
+            /* use /proc/partitions instead */
+            list_devs_in_proc_partititons();
         }
         return 0;
@@ -2823 +2923 @@
 #if ENABLE_FEATURE_FDISK_BLKSIZE
     if (opt & OPT_s) {
-        long size;
         int j;
 
         nowarn = 1;
-        type_open = O_RDONLY;
-
-        if (argc <= 0)
+        if (!argv[0])
             bb_show_usage();
-
-        for (j = 0; j < argc; j++) {
-            disk_device = argv[j];
-            fd = open(disk_device, type_open);
-            if (fd < 0)
-                fdisk_fatal(unable_to_open);
-            if (ioctl(fd, BLKGETSIZE, &size))
-                fdisk_fatal(ioctl_error);
+        for (j = 0; argv[j]; j++) {
+            unsigned long long size;
+            fd = xopen(argv[j], O_RDONLY);
+            size = bb_BLKGETSIZE_sectors(fd) / 2;
             close(fd);
-            if (argc == 1)
-                printf("%ld\n", size/2);
+            if (argv[1])
+                printf("%llu\n", size);
             else
-                printf("%s: %ld\n", argv[j], size/2);
+                printf("%s: %llu\n", argv[j], size);
         }
         return 0;
@@ -2850 +2943 @@
 
 #if ENABLE_FEATURE_FDISK_WRITABLE
-    if (argc != 1)
+    if (!argv[0] || argv[1])
         bb_show_usage();
 
     disk_device = argv[0];
-    get_boot(fdisk);
+    get_boot(OPEN_MAIN);
 
     if (LABEL_IS_OSF) {
@@ -2862 +2955 @@
         bsd_select();
         /*Why do we do this?  It seems to be counter-intuitive*/
-        current_label_type = label_dos;
+        current_label_type = LABEL_DOS;
         /* If we return we may want to make an empty DOS label? */
     }
@@ -2868 +2961 @@
     while (1) {
         int c;
-        putchar('\n');
-        c = tolower(read_nonempty("Command (m for help): "));
+        bb_putchar('\n');
+        c = 0x20 | read_nonempty("Command (m for help): ");
         switch (c) {
         case 'a':
             if (LABEL_IS_DOS)
-                toggle_active(get_partition(1, partitions));
+                toggle_active(get_partition(1, g_partitions));
             else if (LABEL_IS_SUN)
-                toggle_sunflags(get_partition(1, partitions),
+                toggle_sunflags(get_partition(1, g_partitions),
                         0x01);
             else if (LABEL_IS_SGI)
                 sgi_set_bootpartition(
-                    get_partition(1, partitions));
+                    get_partition(1, g_partitions));
             else
                 unknown_command(c);
@@ -2902 +2995 @@
                 toggle_dos_compatibility_flag();
             else if (LABEL_IS_SUN)
-                toggle_sunflags(get_partition(1, partitions),
+                toggle_sunflags(get_partition(1, g_partitions),
                         0x10);
             else if (LABEL_IS_SGI)
                 sgi_set_swappartition(
-                        get_partition(1, partitions));
+                        get_partition(1, g_partitions));
             else
                 unknown_command(c);
@@ -2918 +3011 @@
                partition tables */
                 if (!LABEL_IS_SGI) {
-                    j = get_existing_partition(1, partitions);
+                    j = get_existing_partition(1, g_partitions);
                 } else {
-                    j = get_partition(1, partitions);
+                    j = get_partition(1, g_partitions);
                 }
                 if (j >= 0)
@@ -2947 +3040 @@
             break;
         case 'q':
-            close(fd);
-            puts("");
+            if (ENABLE_FEATURE_CLEAN_UP)
+                close_dev_fd();
+            bb_putchar('\n');
             return 0;
         case 's':