X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=util-linux%2Ffdisk.c;h=4467525c739d7398552e6ed4a4f3329edcd28ecb;hb=5b2cc0aaee6985431d9bab1b49ceea7e1fa1d7af;hp=b1f0b65c636c9a57fc815344f83908c7a654bc1d;hpb=5415c856eaccd1bc5d064022770a288f43b2e94f;p=oweals%2Fbusybox.git

diff --git a/util-linux/fdisk.c b/util-linux/fdisk.c
index b1f0b65c6..4467525c7 100644
--- a/util-linux/fdisk.c
+++ b/util-linux/fdisk.c
@@ -4,20 +4,134 @@
  * Copyright (C) 1992  A. V. Le Blanc (LeBlanc@mcc.ac.uk)
  * 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.
  */
+//config:config FDISK
+//config:	bool "fdisk"
+//config:	default y
+//config:	select PLATFORM_LINUX
+//config:	help
+//config:	  The fdisk utility is used to divide hard disks into one or more
+//config:	  logical disks, which are generally called partitions. This utility
+//config:	  can be used to list and edit the set of partitions or BSD style
+//config:	  'disk slices' that are defined on a hard drive.
+//config:
+//config:config FDISK_SUPPORT_LARGE_DISKS
+//config:	bool "Support over 4GB disks"
+//config:	default y
+//config:	depends on FDISK
+//config:	depends on !LFS   # with LFS no special code is needed
+//config:
+//config:config FEATURE_FDISK_WRITABLE
+//config:	bool "Write support"
+//config:	default y
+//config:	depends on FDISK
+//config:	help
+//config:	  Enabling this option allows you to create or change a partition table
+//config:	  and write those changes out to disk. If you leave this option
+//config:	  disabled, you will only be able to view the partition table.
+//config:
+//config:config FEATURE_AIX_LABEL
+//config:	bool "Support AIX disklabels"
+//config:	default n
+//config:	depends on FDISK && FEATURE_FDISK_WRITABLE
+//config:	help
+//config:	  Enabling this option allows you to create or change AIX disklabels.
+//config:	  Most people can safely leave this option disabled.
+//config:
+//config:config FEATURE_SGI_LABEL
+//config:	bool "Support SGI disklabels"
+//config:	default n
+//config:	depends on FDISK && FEATURE_FDISK_WRITABLE
+//config:	help
+//config:	  Enabling this option allows you to create or change SGI disklabels.
+//config:	  Most people can safely leave this option disabled.
+//config:
+//config:config FEATURE_SUN_LABEL
+//config:	bool "Support SUN disklabels"
+//config:	default n
+//config:	depends on FDISK && FEATURE_FDISK_WRITABLE
+//config:	help
+//config:	  Enabling this option allows you to create or change SUN disklabels.
+//config:	  Most people can safely leave this option disabled.
+//config:
+//config:config FEATURE_OSF_LABEL
+//config:	bool "Support BSD disklabels"
+//config:	default n
+//config:	depends on FDISK && FEATURE_FDISK_WRITABLE
+//config:	help
+//config:	  Enabling this option allows you to create or change BSD disklabels
+//config:	  and define and edit BSD disk slices.
+//config:
+//config:config FEATURE_GPT_LABEL
+//config:	bool "Support GPT disklabels"
+//config:	default n
+//config:	depends on FDISK && FEATURE_FDISK_WRITABLE
+//config:	help
+//config:	  Enabling this option allows you to view GUID Partition Table
+//config:	  disklabels.
+//config:
+//config:config FEATURE_FDISK_ADVANCED
+//config:	bool "Support expert mode"
+//config:	default y
+//config:	depends on FDISK && FEATURE_FDISK_WRITABLE
+//config:	help
+//config:	  Enabling this option allows you to do terribly unsafe things like
+//config:	  define arbitrary drive geometry, move the beginning of data in a
+//config:	  partition, and similarly evil things. Unless you have a very good
+//config:	  reason you would be wise to leave this disabled.
+
+//applet:IF_FDISK(APPLET(fdisk, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_FDISK) += fdisk.o
+
+/* Looks like someone forgot to add this to config system */
+//usage:#ifndef ENABLE_FEATURE_FDISK_BLKSIZE
+//usage:# define ENABLE_FEATURE_FDISK_BLKSIZE 0
+//usage:# define IF_FEATURE_FDISK_BLKSIZE(a)
+//usage:#endif
+//usage:
+//usage:#define fdisk_trivial_usage
+//usage:       "[-ul" IF_FEATURE_FDISK_BLKSIZE("s") "] "
+//usage:       "[-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SSZ] DISK"
+//usage:#define fdisk_full_usage "\n\n"
+//usage:       "Change partition table\n"
+//usage:     "\n	-u		Start and End are in sectors (instead of cylinders)"
+//usage:     "\n	-l		Show partition table for each DISK, then exit"
+//usage:	IF_FEATURE_FDISK_BLKSIZE(
+//usage:     "\n	-s		Show partition sizes in kb for each DISK, then exit"
+//usage:	)
+//usage:     "\n	-b 2048		(for certain MO disks) use 2048-byte sectors"
+//usage:     "\n	-C CYLINDERS	Set number of cylinders/heads/sectors"
+//usage:     "\n	-H HEADS	Typically 255"
+//usage:     "\n	-S SECTORS	Typically 63"
 
 #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"
+#include "unicode.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)
+# define IF_FEATURE_FDISK_BLKSIZE(a)
 #endif
 
 #define DEFAULT_SECTOR_SIZE      512
@@ -49,8 +163,18 @@ enum {
 };
 
 
-/* Used for sector numbers. Today's disk sizes make it necessary */
 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 {
 	unsigned char heads;
@@ -61,13 +185,16 @@ struct hd_geometry {
 
 #define HDIO_GETGEO     0x0301  /* get device geometry */
 
+/* TODO: #if ENABLE_FEATURE_FDISK_WRITABLE */
+/* (currently fdisk_sun/sgi.c do not have proper WRITABLE #ifs) */
 static const char msg_building_new_label[] ALIGN1 =
 "Building a new %s. Changes will remain in memory only,\n"
 "until you decide to write them. After that the previous content\n"
 "won't be recoverable.\n\n";
 
 static const char msg_part_already_defined[] ALIGN1 =
-"Partition %d is already defined, delete it before re-adding\n";
+"Partition %u is already defined, delete it before re-adding\n";
+/* #endif */
 
 
 struct partition {
@@ -83,12 +210,30 @@ struct partition {
 	unsigned char size4[4];         /* nr of sectors in partition */
 } PACKED;
 
-static const char unable_to_open[] ALIGN1 = "can't open %s";
-static const char unable_to_read[] ALIGN1 = "can't read from %s";
-static const char unable_to_seek[] ALIGN1 = "can't seek on %s";
+/*
+ * per partition table entry data
+ *
+ * The four primary partitions have the same sectorbuffer (MBRbuffer)
+ * and have NULL ext_pointer.
+ * Each logical partition table entry has two pointers, one for the
+ * partition and one link to the next one.
+ */
+struct pte {
+	struct partition *part_table;   /* points into sectorbuffer */
+	struct partition *ext_pointer;  /* points into sectorbuffer */
+	sector_t offset_from_dev_start; /* disk sector number */
+	char *sectorbuffer;             /* disk sector contents */
+#if ENABLE_FEATURE_FDISK_WRITABLE
+	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_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF, LABEL_GPT
 };
 
 #define LABEL_IS_DOS	(LABEL_DOS == current_label_type)
@@ -125,6 +270,14 @@ enum label_type {
 #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);
@@ -132,12 +285,13 @@ static void update_units(void);
 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 unsigned get_partition(int warn, unsigned max);
 static void list_types(const char *const *sys);
-static unsigned read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg);
+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
@@ -147,26 +301,8 @@ static int get_boot(void);
 #define PLURAL   0
 #define SINGULAR 1
 
-static unsigned get_start_sect(const struct partition *p);
-static unsigned get_nr_sects(const struct partition *p);
-
-/*
- * per partition table entry data
- *
- * The four primary partitions have the same sectorbuffer (MBRbuffer)
- * and have NULL ext_pointer.
- * Each logical partition table entry has two pointers, one for the
- * partition and one link to the next one.
- */
-struct pte {
-	struct partition *part_table;   /* points into sectorbuffer */
-	struct partition *ext_pointer;  /* points into sectorbuffer */
-	ullong offset;          /* disk sector number */
-	char *sectorbuffer;     /* disk sector contents */
-#if ENABLE_FEATURE_FDISK_WRITABLE
-	char changed;           /* boolean */
-#endif
-};
+static sector_t get_start_sect(const struct partition *p);
+static sector_t get_nr_sects(const struct partition *p);
 
 /* DOS partition types */
 
@@ -304,12 +440,11 @@ struct globals {
 	unsigned user_cylinders, user_heads, user_sectors;
 	unsigned pt_heads, pt_sectors;
 	unsigned kern_heads, kern_sectors;
-	ullong extended_offset;         /* offset of link pointers */
-	ullong total_number_of_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];
 	/* Raw disk label. For DOS-type partition tables the MBR,
 	 * with descriptions of the primary partitions. */
 	char MBRbuffer[MAX_SECTOR_SIZE];
@@ -345,7 +480,6 @@ struct globals {
 #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           )
 #define INIT_G() do { \
@@ -360,18 +494,42 @@ struct globals {
 
 
 /* TODO: move to libbb? */
-static ullong bb_BLKGETSIZE_sectors(int fd)
+/* 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 */
-		return (v64 >> 9);
+		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))
+	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;
 }
 
@@ -390,19 +548,6 @@ static ullong bb_BLKGETSIZE_sectors(int fd)
 
 #define cylinder(s, c)  ((c) | (((s) & 0xc0) << 2))
 
-#define hsc2sector(h,s,c) \
-	(sector(s) - 1 + sectors * ((h) + heads * cylinder(s,c)))
-
-#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
 close_dev_fd(void)
 {
@@ -410,30 +555,7 @@ close_dev_fd(void)
 	xmove_fd(xopen(bb_dev_null, O_RDONLY), dev_fd);
 }
 
-#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 && !isgraph(*line_ptr))
-		line_ptr++;
-	return *line_ptr;
-}
-#endif
-
-/*
- * Return partition name - uses static storage
- */
+/* Return partition name */
 static const char *
 partname(const char *dev, int pno, int lth)
 {
@@ -442,8 +564,8 @@ partname(const char *dev, int pno, int lth)
 	int bufsiz;
 	char *bufp;
 
-	bufp = partname_buffer;
-	bufsiz = sizeof(partname_buffer);
+	bufp = auto_string(xzalloc(80));
+	bufsiz = 80;
 
 	w = strlen(dev);
 	p = "";
@@ -462,30 +584,13 @@ partname(const char *dev, int pno, int lth)
 
 	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);
 	}
 	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 *
 get_part_table(int i)
 {
@@ -506,7 +611,67 @@ valid_part_table_flag(const char *mbuffer)
 	return (mbuffer[510] == 0x55 && (uint8_t)mbuffer[511] == 0xaa);
 }
 
+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(NULL, prompt, line_buffer, sizeof(line_buffer), /*timeout*/ -1);
+	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)
 {
@@ -539,57 +704,28 @@ read_hex(const char *const *sys)
 	unsigned long v;
 	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;
-	}
-}
-#endif /* FEATURE_FDISK_WRITABLE */
-
-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(ullong secno)
-{
-	secno *= sector_size;
-#if ENABLE_FDISK_SUPPORT_LARGE_DISKS
-	if (lseek64(dev_fd, (off64_t)secno, SEEK_SET) == (off64_t) -1)
-		fdisk_fatal(unable_to_seek);
-#else
-	if (secno > MAXINT(off_t)
-	 || lseek(dev_fd, (off_t)secno, SEEK_SET) == (off_t) -1
-	) {
-		fdisk_fatal(unable_to_seek);
+		if (v <= 0xff)
+			return v;
 	}
-#endif
 }
 
-#if ENABLE_FEATURE_FDISK_WRITABLE
 static void
-write_sector(ullong secno, const void *buf)
+write_sector(sector_t secno, const void *buf)
 {
 	seek_sector(secno);
 	xwrite(dev_fd, buf, sector_size);
 }
-#endif
+#endif /* FEATURE_FDISK_WRITABLE */
 
 
 #include "fdisk_aix.c"
 
-typedef struct {
+struct sun_partition {
 	unsigned char info[128];   /* Informative text string */
 	unsigned char spare0[14];
 	struct sun_info {
@@ -615,12 +751,16 @@ typedef struct {
 	} partitions[8];
 	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
 static uint16_t
 fdisk_swap16(uint16_t x)
@@ -676,40 +816,42 @@ STATIC_SUN void sun_write_table(void);
 #include "fdisk_sun.c"
 
 
-#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
-store4_little_endian(unsigned char *cp, unsigned val)
+static inline_if_little_endian unsigned
+read4_little_endian(const unsigned char *cp)
 {
-	cp[0] = val;
-	cp[1] = val >> 8;
-	cp[2] = val >> 16;
-	cp[3] = val >> 24;
+	uint32_t v;
+	move_from_unaligned32(v, cp);
+	return SWAP_LE32(v);
 }
-#endif /* FEATURE_FDISK_WRITABLE */
 
-static unsigned
-read4_little_endian(const unsigned char *cp)
+static sector_t
+get_start_sect(const struct partition *p)
 {
-	return cp[0] + (cp[1] << 8) + (cp[2] << 16) + (cp[3] << 24);
+	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
-static void
-set_start_sect(struct partition *p, unsigned start_sect)
+/* start_sect and nr_sects are stored little endian on all machines */
+/* moreover, they are not aligned correctly */
+static inline_if_little_endian void
+store4_little_endian(unsigned char *cp, unsigned val)
 {
-	store4_little_endian(p->start4, start_sect);
+	uint32_t v = SWAP_LE32(val);
+	move_to_unaligned32(cp, v);
 }
-#endif
 
-static unsigned
-get_start_sect(const struct partition *p)
+static void
+set_start_sect(struct partition *p, unsigned start_sect)
 {
-	return read4_little_endian(p->start4);
+	store4_little_endian(p->start4, start_sect);
 }
 
-#if ENABLE_FEATURE_FDISK_WRITABLE
 static void
 set_nr_sects(struct partition *p, unsigned nr_sects)
 {
@@ -717,17 +859,11 @@ set_nr_sects(struct partition *p, unsigned nr_sects)
 }
 #endif
 
-static unsigned
-get_nr_sects(const struct partition *p)
-{
-	return read4_little_endian(p->size4);
-}
-
 /* Allocate a buffer and read a partition table sector */
 static void
-read_pte(struct pte *pe, ullong offset)
+read_pte(struct pte *pe, sector_t offset)
 {
-	pe->offset = offset;
+	pe->offset_from_dev_start = offset;
 	pe->sectorbuffer = xzalloc(sector_size);
 	seek_sector(offset);
 	/* xread would make us abort - bad for fdisk -l */
@@ -739,10 +875,10 @@ read_pte(struct pte *pe, ullong offset)
 	pe->part_table = pe->ext_pointer = NULL;
 }
 
-static unsigned
-get_partition_start(const struct pte *pe)
+static sector_t
+get_partition_start_from_dev_start(const struct pte *pe)
 {
-	return pe->offset + get_start_sect(pe->part_table);
+	return pe->offset_from_dev_start + get_start_sect(pe->part_table);
 }
 
 #if ENABLE_FEATURE_FDISK_WRITABLE
@@ -805,6 +941,11 @@ menu(void)
 		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 */
 	} else {
 		puts("a\ttoggle a bootable flag");
 		puts("b\tedit bsd disklabel");
@@ -905,7 +1046,7 @@ get_sys_types(void)
 }
 #else
 #define get_sys_types() i386_sys_types
-#endif /* FEATURE_FDISK_WRITABLE */
+#endif
 
 static const char *
 partition_type(unsigned char type)
@@ -920,6 +1061,24 @@ partition_type(unsigned char type)
 	return "Unknown";
 }
 
+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
 static int
@@ -961,48 +1120,46 @@ list_types(const char *const *sys)
 	} while (done < last[0]);
 	bb_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));
-}
+#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
-clear_partition(struct partition *p)
+static void set_hsc_start_end(struct partition *p, sector_t start, sector_t stop)
 {
-	if (!p)
-		return;
-	memset(p, 0, sizeof(struct partition));
+	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);
 }
 
-#if ENABLE_FEATURE_FDISK_WRITABLE
 static void
-set_partition(int i, int doext, ullong start, ullong stop, int sysid)
+set_partition(int i, int doext, sector_t start, sector_t stop, int sysid)
 {
 	struct partition *p;
-	ullong offset;
+	sector_t offset;
 
 	if (doext) {
 		p = ptes[i].ext_pointer;
 		offset = extended_offset;
 	} else {
 		p = ptes[i].part_table;
-		offset = ptes[i].offset;
+		offset = ptes[i].offset_from_dev_start;
 	}
 	p->boot_ind = 0;
 	p->sys_ind = sysid;
 	set_start_sect(p, start - offset);
 	set_nr_sects(p, stop - start + 1);
-	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);
+	set_hsc_start_end(p, start, stop);
 	ptes[i].changed = 1;
 }
 #endif
@@ -1020,11 +1177,11 @@ warn_geometry(void)
 		printf(" sectors");
 	if (!g_cylinders)
 		printf(" cylinders");
-	printf(
 #if ENABLE_FEATURE_FDISK_WRITABLE
-		" (settable in the extra functions menu)"
+	puts(" (settable in the extra functions menu)");
+#else
+	bb_putchar('\n');
 #endif
-		"\n");
 	return 1;
 }
 
@@ -1045,7 +1202,7 @@ warn_cylinders(void)
 {
 	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"
 "1) software that runs at boot time (e.g., old versions of LILO)\n"
@@ -1068,7 +1225,7 @@ read_extended(int ext)
 
 	p = pex->part_table;
 	if (!get_start_sect(p)) {
-		printf("Bad offset in primary extended partition\n");
+		puts("Bad offset in primary extended partition");
 		return;
 	}
 
@@ -1081,7 +1238,7 @@ read_extended(int ext)
 			   Do not try to 'improve' this test. */
 			struct pte *pre = &ptes[g_partitions - 1];
 #if ENABLE_FEATURE_FDISK_WRITABLE
-			printf("Warning: deleting partitions after %d\n",
+			printf("Warning: deleting partitions after %u\n",
 				g_partitions);
 			pre->changed = 1;
 #endif
@@ -1100,14 +1257,14 @@ read_extended(int ext)
 				if (pe->ext_pointer)
 					printf("Warning: extra link "
 						"pointer in partition table"
-						" %d\n", g_partitions + 1);
+						" %u\n", g_partitions + 1);
 				else
 					pe->ext_pointer = p;
 			} else if (p->sys_ind) {
 				if (pe->part_table)
 					printf("Warning: ignoring extra "
 						  "data in partition table"
-						  " %d\n", g_partitions + 1);
+						  " %u\n", g_partitions + 1);
 				else
 					pe->part_table = p;
 			}
@@ -1140,7 +1297,7 @@ read_extended(int ext)
 		if (!get_nr_sects(pe->part_table)
 		 && (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 */
 		}
@@ -1152,26 +1309,22 @@ read_extended(int ext)
 static void
 create_doslabel(void)
 {
-	int i;
-
 	printf(msg_building_new_label, "DOS disklabel");
 
 	current_label_type = LABEL_DOS;
-
 #if ENABLE_FEATURE_OSF_LABEL
 	possibly_osf_label = 0;
 #endif
 	g_partitions = 4;
 
-	for (i = 510-64; i < 510; i++)
-		MBRbuffer[i] = 0;
+	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 */
+#endif
 
 static void
 get_sectorsize(void)
@@ -1181,7 +1334,7 @@ get_sectorsize(void)
 		if (ioctl(dev_fd, BLKSSZGET, &arg) == 0)
 			sector_size = arg;
 		if (sector_size != DEFAULT_SECTOR_SIZE)
-			printf("Note: sector size is %d "
+			printf("Note: sector size is %u "
 				"(not " DEFAULT_SECTOR_SIZE_STR ")\n",
 				sector_size);
 	}
@@ -1268,7 +1421,18 @@ get_geometry(void)
 
 /*
  * Opens disk_device and optionally reads MBR.
- *    FIXME: document what each 'what' value will do!
+ *    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
@@ -1288,7 +1452,7 @@ static int get_boot(void)
 		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);
@@ -1302,7 +1466,7 @@ static int get_boot(void)
 // 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  USE_FEATURE_SUN_LABEL(|| what == CREATE_EMPTY_SUN))
+	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);
@@ -1350,6 +1514,10 @@ static int get_boot(void)
 	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;
@@ -1357,8 +1525,8 @@ static int get_boot(void)
 			current_label_type = LABEL_OSF;
 			return 0;
 		}
-		printf("This disk has both DOS and BSD magic.\n"
-			 "Give the 'b' command to go to BSD mode.\n");
+		puts("This disk has both DOS and BSD magic.\n"
+		     "Give the 'b' command to go to BSD mode.");
 	}
 #endif
 
@@ -1368,11 +1536,11 @@ static int get_boot(void)
 #else
 	if (!valid_part_table_flag(MBRbuffer)) {
 		if (what == OPEN_MAIN) {
-			printf("Device contains neither a valid DOS "
-				  "partition table, nor Sun, SGI or OSF "
-				  "disklabel\n");
+			puts("Device contains neither a valid DOS "
+			     "partition table, nor Sun, SGI, OSF or GPT "
+			     "disklabel");
 #ifdef __sparc__
-			USE_FEATURE_SUN_LABEL(create_sunlabel();)
+			IF_FEATURE_SUN_LABEL(create_sunlabel();)
 #else
 			create_doslabel();
 #endif
@@ -1385,14 +1553,14 @@ static int get_boot(void)
 #endif /* FEATURE_FDISK_WRITABLE */
 
 
-	USE_FEATURE_FDISK_WRITABLE(warn_cylinders();)
+	IF_FEATURE_FDISK_WRITABLE(warn_cylinders();)
 	warn_geometry();
 
 	for (i = 0; i < 4; i++) {
 		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);
 		}
@@ -1402,11 +1570,11 @@ static int get_boot(void)
 		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);
-			USE_FEATURE_FDISK_WRITABLE(pe->changed = 1;)
+			IF_FEATURE_FDISK_WRITABLE(pe->changed = 1;)
 		}
 	}
 
@@ -1421,10 +1589,10 @@ static int get_boot(void)
  *
  * 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)
+static sector_t
+read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg)
 {
-	unsigned i;
+	sector_t value;
 	int default_ok = 1;
 	const char *fmt = "%s (%u-%u, default %u): ";
 
@@ -1447,8 +1615,10 @@ read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *
 			int minus = (*line_ptr == '-');
 			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;
 
@@ -1456,7 +1626,7 @@ read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *
 			case 'c':
 			case 'C':
 				if (!display_in_cyl_units)
-					i *= g_heads * g_sectors;
+					value *= g_heads * g_sectors;
 				break;
 			case 'K':
 				absolute = 1024;
@@ -1479,38 +1649,38 @@ read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *
 				ullong bytes;
 				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++;
 				use_default = 0;
 			}
 		}
 		if (use_default) {
-			i = dflt;
-			printf("Using default value %u\n", i);
+			value = dflt;
+			printf("Using default value %u\n", value);
 		}
-		if (i >= low && i <= high)
+		if (value >= low && value <= high)
 			break;
-		printf("Value is out of range\n");
+		puts("Value is out of range");
 	}
-	return i;
+	return value;
 }
 
-static int
-get_partition(int warn, int max)
+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;
 	pe = &ptes[i];
@@ -1520,17 +1690,17 @@ get_partition(int warn, int max)
 		 || (LABEL_IS_SUN && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id))
 		 || (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);
 		}
 	}
 	return i;
 }
 
 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++) {
 		struct pte *pe = &ptes[i];
@@ -1543,10 +1713,10 @@ get_existing_partition(int warn, int max)
 		}
 	}
 	if (pno >= 0) {
-		printf("Selected partition %d\n", pno+1);
+		printf("Selected partition %u\n", pno+1);
 		return pno;
 	}
-	printf("No partition is defined yet!\n");
+	puts("No partition is defined yet!");
 	return -1;
 
  not_unique:
@@ -1554,10 +1724,10 @@ get_existing_partition(int warn, int max)
 }
 
 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++) {
 		struct pte *pe = &ptes[i];
@@ -1570,10 +1740,10 @@ get_nonexisting_partition(int warn, int max)
 		}
 	}
 	if (pno >= 0) {
-		printf("Selected partition %d\n", pno+1);
+		printf("Selected partition %u\n", pno+1);
 		return pno;
 	}
-	printf("All primary partitions have been defined already!\n");
+	puts("All primary partitions have been defined already!");
 	return -1;
 
  not_unique:
@@ -1597,7 +1767,7 @@ toggle_active(int i)
 	struct partition *p = pe->part_table;
 
 	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;
 }
@@ -1608,10 +1778,10 @@ toggle_dos_compatibility_flag(void)
 	dos_compatible_flag = 1 - dos_compatible_flag;
 	if (dos_compatible_flag) {
 		sector_offset = g_sectors;
-		printf("DOS Compatibility flag is set\n");
+		printf("DOS Compatibility flag is %sset\n", "");
 	} else {
 		sector_offset = 1;
-		printf("DOS Compatibility flag is not set\n");
+		printf("DOS Compatibility flag is %sset\n", "not ");
 	}
 }
 
@@ -1670,9 +1840,9 @@ delete_partition(int i)
 
 			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;
 		}
 
@@ -1682,9 +1852,10 @@ delete_partition(int i)
 				ptes[i] = ptes[i+1];
 				i++;
 			}
-		} else
+		} else {
 			/* the only logical: clear only */
 			clear_partition(ptes[i].part_table);
+		}
 	}
 }
 
@@ -1710,23 +1881,23 @@ change_sysid(void)
 	/* if changing types T to 0 is allowed, then
 	   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;
 	}
 	while (1) {
 		sys = read_hex(get_sys_types());
 
 		if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) {
-			printf("Type 0 means free space to many systems\n"
-				   "(but not to Linux). Having partitions of\n"
-				   "type 0 is probably unwise.\n");
+			puts("Type 0 means free space to many systems\n"
+				"(but not to Linux). Having partitions of\n"
+				"type 0 is probably unwise.");
 			/* break; */
 		}
 
 		if (!LABEL_IS_SUN && !LABEL_IS_SGI) {
 			if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {
-				printf("You cannot change a partition into"
-					   " an extended one or vice versa\n");
+				puts("You cannot change a partition into"
+					" an extended one or vice versa");
 				break;
 			}
 		}
@@ -1734,10 +1905,10 @@ change_sysid(void)
 		if (sys < 256) {
 #if ENABLE_FEATURE_SUN_LABEL
 			if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK)
-				printf("Consider leaving partition 3 "
-					   "as Whole disk (5),\n"
-					   "as SunOS/Solaris expects it and "
-					   "even Linux likes it\n\n");
+				puts("Consider leaving partition 3 "
+					"as Whole disk (5),\n"
+					"as SunOS/Solaris expects it and "
+					"even Linux likes it\n");
 #endif
 #if ENABLE_FEATURE_SGI_LABEL
 			if (LABEL_IS_SGI &&
@@ -1746,10 +1917,10 @@ change_sysid(void)
 					(i == 8 && sys != 0)
 				)
 			) {
-				printf("Consider leaving partition 9 "
-					   "as volume header (0),\nand "
-					   "partition 11 as entire volume (6)"
-					   "as IRIX expects it\n\n");
+				puts("Consider leaving partition 9 "
+					"as volume header (0),\nand "
+					"partition 11 as entire volume (6)"
+					"as IRIX expects it\n");
 			}
 #endif
 			if (sys == origsys)
@@ -1761,7 +1932,7 @@ change_sysid(void)
 			} else
 				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;
@@ -1802,14 +1973,14 @@ check_consistency(const struct partition *p, int partition)
 		return;         /* do not check extended partitions */
 
 /* physical beginning c, h, s */
-	pbc = (p->cyl & 0xff) | ((p->sector << 2) & 0x300);
+	pbc = cylinder(p->sector, p->cyl);
 	pbh = p->head;
-	pbs = p->sector & 0x3f;
+	pbs = sector(p->sector);
 
 /* physical ending c, h, s */
-	pec = (p->end_cyl & 0xff) | ((p->end_sector << 2) & 0x300);
+	pec = cylinder(p->end_sector, p->end_cyl);
 	peh = p->end_head;
-	pes = p->end_sector & 0x3f;
+	pes = sector(p->end_sector);
 
 /* compute logical beginning (c, h, s) */
 	linear2chs(get_start_sect(p), &lbc, &lbh, &lbs);
@@ -1819,23 +1990,23 @@ check_consistency(const struct partition *p, int partition)
 
 /* Same physical / logical beginning? */
 	if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
-		printf("Partition %d 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("Partition %u has different physical/logical "
+			"start (non-Linux?):\n", partition + 1);
+		printf("     phys=(%u,%u,%u) ", pbc, pbh, pbs);
+		printf("logical=(%u,%u,%u)\n", lbc, lbh, lbs);
 	}
 
 /* Same physical / logical ending? */
 	if (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
-		printf("Partition %d 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("Partition %u has different physical/logical "
+			"end:\n", partition + 1);
+		printf("     phys=(%u,%u,%u) ", pec, peh, pes);
+		printf("logical=(%u,%u,%u)\n", lec, leh, les);
 	}
 
 /* Ending on cylinder boundary? */
 	if (peh != (g_heads - 1) || pes != g_sectors) {
-		printf("Partition %i does not end on cylinder boundary\n",
+		printf("Partition %u does not end on cylinder boundary\n",
 			partition + 1);
 	}
 }
@@ -1843,23 +2014,24 @@ check_consistency(const struct partition *p, int partition)
 static void
 list_disk_geometry(void)
 {
-	long long bytes = (total_number_of_sectors << 9);
-	long megabytes = bytes/1000000;
+	ullong bytes = ((ullong)total_number_of_sectors << 9);
+	ullong xbytes = bytes / (1024*1024);
+	char x = 'M';
 
-	if (megabytes < 10000)
-		printf("\nDisk %s: %ld MB, %lld 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",
-		   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);
+	if (xbytes >= 10000) {
+		xbytes += 512; /* fdisk util-linux 2.28 does this */
+		xbytes /= 1024;
+		x = 'G';
+	}
+	printf("Disk %s: %llu %cB, %llu bytes, %"SECT_FMT"u sectors\n"
+		"%u cylinders, %u heads, %u sectors/track\n"
+		"Units: %s of %u * %u = %u bytes\n\n",
+		disk_device, xbytes, x,
+		bytes, total_number_of_sectors,
+		g_cylinders, g_heads, g_sectors,
+		str_units(PLURAL),
+		units_per_sector, sector_size, units_per_sector * sector_size
+	);
 }
 
 /*
@@ -1872,8 +2044,8 @@ wrong_p_order(int *prev)
 {
 	const struct pte *pe;
 	const struct partition *p;
-	ullong last_p_start_pos = 0, p_start_pos;
-	int i, last_i = 0;
+	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) {
@@ -1883,7 +2055,7 @@ wrong_p_order(int *prev)
 		pe = &ptes[i];
 		p = pe->part_table;
 		if (p->sys_ind) {
-			p_start_pos = get_partition_start(pe);
+			p_start_pos = get_partition_start_from_dev_start(pe);
 
 			if (last_p_start_pos > p_start_pos) {
 				if (prev)
@@ -1922,11 +2094,11 @@ fix_chain_of_logicals(void)
 	/* (Its sector is the global extended_offset.) */
  stage1:
 	for (j = 5; j < g_partitions - 1; j++) {
-		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 > 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);
 			pjj = ptes[j+1].part_table;
@@ -1946,8 +2118,8 @@ fix_chain_of_logicals(void)
 		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;
 			*pj = *pjj;
@@ -1971,7 +2143,7 @@ fix_partition_table_order(void)
 	int i,k;
 
 	if (!wrong_p_order(NULL)) {
-		printf("Ordering is already correct\n\n");
+		puts("Ordering is already correct\n");
 		return;
 	}
 
@@ -1999,25 +2171,35 @@ fix_partition_table_order(void)
 	if (i)
 		fix_chain_of_logicals();
 
-	printf("Done.\n");
-
+	puts("Done");
 }
 #endif
 
+static const char *
+chs_string11(unsigned cyl, unsigned head, unsigned sect)
+{
+	char *buf = auto_string(xzalloc(sizeof(int)*3 * 3));
+	sprintf(buf, "%u,%u,%u", cylinder(sect,cyl), head, sector(sect));
+	return buf;
+}
+
 static void
 list_table(int xtra)
 {
-	const struct partition *p;
 	int i, w;
 
 	if (LABEL_IS_SUN) {
 		sun_list_table(xtra);
 		return;
 	}
-	if (LABEL_IS_SUN) {
+	if (LABEL_IS_SGI) {
 		sgi_list_table(xtra);
 		return;
 	}
+	if (LABEL_IS_GPT) {
+		gpt_list_table(xtra);
+		return;
+	}
 
 	list_disk_geometry();
 
@@ -2027,59 +2209,71 @@ list_table(int xtra)
 	}
 
 	/* Heuristic: we list partition 3 of /dev/foo as /dev/foo3,
-	   but if the device name ends in a digit, say /dev/foo1,
-	   then the partition is called /dev/foo1p3. */
+	 * but if the device name ends in a digit, say /dev/foo1,
+	 * then the partition is called /dev/foo1p3.
+	 */
 	w = strlen(disk_device);
 	if (w && isdigit(disk_device[w-1]))
 		w++;
-	if (w < 5)
-		w = 5;
+	if (w < 7)
+		w = 7;
 
-	//            1 12345678901 12345678901 12345678901  12
-	printf("%*s Boot      Start         End      Blocks  Id System\n",
-		   w+1, "Device");
+	printf("%-*s Boot StartCHS    EndCHS        StartLBA     EndLBA    Sectors  Size Id Type\n",
+		   w-1, "Device");
 
 	for (i = 0; i < g_partitions; i++) {
+		const struct partition *p;
 		const struct pte *pe = &ptes[i];
-		ullong psects;
-		ullong pblocks;
-		unsigned podd;
+		char boot4[4];
+		char numstr6[6];
+		sector_t start_sect;
+		sector_t end_sect;
+		sector_t nr_sects;
 
 		p = pe->part_table;
 		if (!p || is_cleared_partition(p))
 			continue;
 
-		psects = get_nr_sects(p);
-		pblocks = psects;
-		podd = 0;
-
-		if (sector_size < 1024) {
-			pblocks /= (1024 / sector_size);
-			podd = psects % (1024 / sector_size);
+		sprintf(boot4, "%02x", p->boot_ind);
+		if ((p->boot_ind & 0x7f) == 0) {
+			/* 0x80 shown as '*', 0x00 is ' ' */
+			boot4[0] = p->boot_ind ? '*' : ' ';
+			boot4[1] = ' ';
 		}
-		if (sector_size > 1024)
-			pblocks *= (sector_size / 1024);
 
-		printf("%s  %c %11llu %11llu %11llu%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 */
-				- (psects ? 1 : 0)),
-			(ullong) pblocks, podd ? '+' : ' ', /* odd flag on end */
-			p->sys_ind,                                     /* type id */
-			partition_type(p->sys_ind));                    /* type name */
+		start_sect = get_partition_start_from_dev_start(pe);
+		end_sect = start_sect;
+		nr_sects = get_nr_sects(p);
+		if (nr_sects != 0)
+			end_sect += nr_sects - 1;
+
+		smart_ulltoa5((ullong)nr_sects * sector_size,
+			numstr6, " KMGTPEZY")[0] = '\0';
 
+#define SFMT SECT_FMT
+		//      Boot StartCHS    EndCHS        StartLBA     EndLBA    Sectors  Size Id Type
+		printf("%s%s %-11s"/**/" %-11s"/**/" %10"SFMT"u %10"SFMT"u %10"SFMT"u %s %2x %s\n",
+			partname(disk_device, i+1, w+2),
+			boot4,
+			chs_string11(p->cyl, p->head, p->sector),
+			chs_string11(p->end_cyl, p->end_head, p->end_sector),
+			start_sect,
+			end_sect,
+			nr_sects,
+			numstr6,
+			p->sys_ind,
+			partition_type(p->sys_ind)
+		);
+#undef SFMT
 		check_consistency(p, i);
 	}
 
 	/* 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 */
-		printf("\nPartition table entries are not in disk order\n");
+		puts("\nPartition table entries are not in disk order");
 	}
 }
 
@@ -2091,20 +2285,25 @@ x_list_table(int extend)
 	const struct partition *p;
 	int i;
 
-	printf("\nDisk %s: %d heads, %d sectors, %d cylinders\n\n",
+	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");
+	puts("Nr AF  Hd Sec  Cyl  Hd Sec  Cyl      Start       Size ID");
 	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",
-				i + 1, p->boot_ind, p->head,
+			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),
-				cylinder(p->sector, p->cyl), p->end_head,
+				cylinder(p->sector, p->cyl),
+				p->end_head,
 				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);
 		}
@@ -2114,9 +2313,9 @@ x_list_table(int extend)
 
 #if ENABLE_FEATURE_FDISK_WRITABLE
 static void
-fill_bounds(ullong *first, ullong *last)
+fill_bounds(sector_t *first, sector_t *last)
 {
-	int i;
+	unsigned i;
 	const struct pte *pe = &ptes[0];
 	const struct partition *p;
 
@@ -2126,42 +2325,43 @@ fill_bounds(ullong *first, ullong *last)
 			first[i] = 0xffffffff;
 			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;
 		}
 	}
 }
 
 static void
-check(int n, unsigned h, unsigned s, unsigned c, ullong start)
+check(int n, unsigned h, unsigned s, unsigned c, sector_t start)
 {
-	ullong total, real_s, real_c;
+	sector_t total, real_s, real_c;
 
 	real_s = sector(s) - 1;
 	real_c = cylinder(s, c);
 	total = (real_c * g_sectors + real_s) * g_heads + h;
 	if (!total)
-		printf("Partition %d contains sector 0\n", n);
+		printf("Partition %u contains sector 0\n", n);
 	if (h >= g_heads)
-		printf("Partition %d: head %d greater than maximum %d\n",
+		printf("Partition %u: head %u greater than maximum %u\n",
 			n, h + 1, g_heads);
 	if (real_s >= g_sectors)
-		printf("Partition %d: sector %d greater than "
-			"maximum %d\n", n, s, g_sectors);
+		printf("Partition %u: sector %u greater than "
+			"maximum %u\n", n, s, g_sectors);
 	if (real_c >= g_cylinders)
-		printf("Partition %d: cylinder %llu greater than "
-			"maximum %d\n", n, real_c + 1, 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 %d: previous sectors %llu disagrees with "
-			"total %llu\n", n, start, total);
+		printf("Partition %u: previous sectors %"SECT_FMT"u disagrees with "
+			"total %"SECT_FMT"u\n", n, start, total);
 }
 
 static void
 verify(void)
 {
 	int i, j;
-	unsigned total = 1;
-	ullong first[g_partitions], last[g_partitions];
+	sector_t total = 1;
+	sector_t chs_size;
+	sector_t first[g_partitions], last[g_partitions];
 	struct partition *p;
 
 	if (warn_geometry())
@@ -2183,17 +2383,17 @@ verify(void)
 		p = pe->part_table;
 		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]);
 			total += last[i] + 1 - first[i];
 			for (j = 0; j < i; j++) {
 				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];
 					total -= last[i] <= last[j] ?
@@ -2205,7 +2405,7 @@ verify(void)
 
 	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 < g_partitions; i++) {
@@ -2213,22 +2413,25 @@ verify(void)
 			p = ptes[i].part_table;
 			if (!p->sys_ind) {
 				if (i != 4 || i + 1 < g_partitions)
-					printf("Warning: partition %d "
+					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 > g_heads * g_sectors * g_cylinders)
-		printf("Total allocated sectors %d greater than the maximum "
-			"%d\n", total, g_heads * g_sectors * g_cylinders);
+	chs_size = (sector_t)g_heads * g_sectors * g_cylinders;
+	if (total > chs_size)
+		printf("Total allocated sectors %u"
+			" greater than CHS size %"SECT_FMT"u\n",
+			total, chs_size
+		);
 	else {
-		total = g_heads * g_sectors * g_cylinders - total;
+		total = chs_size - total;
 		if (total != 0)
-			printf("%d unallocated sectors\n", total);
+			printf("%"SECT_FMT"u unallocated sectors\n", total);
 	}
 }
 
@@ -2239,9 +2442,9 @@ add_partition(int n, int sys)
 	int i, num_read = 0;
 	struct partition *p = ptes[n].part_table;
 	struct partition *q = ptes[ext_index].part_table;
-	ullong limit, temp;
-	ullong start, stop = 0;
-	ullong first[g_partitions], last[g_partitions];
+	sector_t limit, temp;
+	sector_t start, stop = 0;
+	sector_t first[g_partitions], last[g_partitions];
 
 	if (p && p->sys_ind) {
 		printf(msg_part_already_defined, n + 1);
@@ -2251,7 +2454,7 @@ add_partition(int n, int sys)
 	if (n < 4) {
 		start = sector_offset;
 		if (display_in_cyl_units || !total_number_of_sectors)
-			limit = (ullong) g_heads * g_sectors * g_cylinders - 1;
+			limit = (sector_t) g_heads * g_sectors * g_cylinders - 1;
 		else
 			limit = total_number_of_sectors - 1;
 		if (extended_offset) {
@@ -2273,7 +2476,7 @@ add_partition(int n, int sys)
 		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);
 			if (start >= first[i] && start <= lastplusoff)
@@ -2282,19 +2485,19 @@ add_partition(int n, int sys)
 		if (start > limit)
 			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;
 		}
@@ -2302,9 +2505,9 @@ add_partition(int n, int sys)
 	if (n > 4) {                    /* NOT for fifth partition */
 		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++;
 		}
@@ -2313,13 +2516,13 @@ add_partition(int n, int sys)
 	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;
 	}
 	if (start > limit) {
-		printf("No free sectors available\n");
+		puts("No free sectors available");
 		if (n > 4)
 			g_partitions--;
 		return;
@@ -2330,8 +2533,7 @@ add_partition(int n, int sys)
 		snprintf(mesg, sizeof(mesg),
 			 "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;
 			if (stop >limit)
@@ -2341,7 +2543,7 @@ add_partition(int n, int sys)
 
 	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)) {
 		struct pte *pe4 = &ptes[4];
@@ -2349,7 +2551,7 @@ add_partition(int n, int sys)
 
 		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;
@@ -2367,7 +2569,7 @@ add_logical(void)
 		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;
 		g_partitions++;
 	}
@@ -2391,9 +2593,9 @@ new_partition(void)
 		return;
 	}
 	if (LABEL_IS_AIX) {
-		printf("Sorry - this fdisk cannot handle AIX disk labels.\n"
+		puts("Sorry - this fdisk cannot handle AIX disk labels.\n"
 "If you want to add DOS-type partitions, create a new empty DOS partition\n"
-"table first (use 'o'). This will destroy the present disk contents.\n");
+"table first (use 'o'). This will destroy the present disk contents.");
 		return;
 	}
 
@@ -2401,7 +2603,7 @@ new_partition(void)
 		free_primary += !ptes[i].part_table->sys_ind;
 
 	if (!free_primary && g_partitions >= MAXIMUM_PARTS) {
-		printf("The maximum number of partitions has been created\n");
+		puts("The maximum number of partitions has been created");
 		return;
 	}
 
@@ -2409,8 +2611,8 @@ new_partition(void)
 		if (extended_offset)
 			add_logical();
 		else
-			printf("You must delete some partition and add "
-				 "an extended partition first\n");
+			puts("You must delete some partition and add "
+				 "an extended partition first");
 	} else {
 		char c, line[80];
 		snprintf(line, sizeof(line),
@@ -2421,7 +2623,7 @@ new_partition(void)
 			"l   logical (5 or over)" : "e   extended"));
 		while (1) {
 			c = read_nonempty(line);
-			if (c == 'p' || c == 'P') {
+			if ((c | 0x20) == 'p') {
 				i = get_nonexisting_partition(0, 4);
 				if (i >= 0)
 					add_partition(i, LINUX_NATIVE);
@@ -2443,6 +2645,35 @@ new_partition(void)
 	}
 }
 
+static void
+reread_partition_table(int leave)
+{
+	int i;
+
+	puts("Calling ioctl() to re-read partition table");
+	sync();
+	/* Users with slow external USB disks on a 320MHz ARM system (year 2011)
+	 * report that sleep is needed, otherwise BLKRRPART may fail with -EIO:
+	 */
+	sleep(1);
+	i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
+			"WARNING: rereading partition table "
+			"failed, kernel still uses old table");
+#if 0
+	if (dos_changed)
+		puts(
+		"\nWARNING: If you have created or modified any DOS 6.x\n"
+		"partitions, please see the fdisk manual page for additional\n"
+		"information");
+#endif
+
+	if (leave) {
+		if (ENABLE_FEATURE_CLEAN_UP)
+			close_dev_fd();
+		exit(i != 0);
+	}
+}
+
 static void
 write_table(void)
 {
@@ -2454,56 +2685,28 @@ write_table(void)
 				ptes[3].changed = 1;
 		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);
 			}
 		}
 	}
 	else if (LABEL_IS_SGI) {
-		/* no test on change? the printf below might be mistaken */
+		/* no test on change? the "altered" msg below might be mistaken */
 		sgi_write_table();
 	}
 	else if (LABEL_IS_SUN) {
-		int needw = 0;
-
-		for (i = 0; i < 8; i++)
-			if (ptes[i].changed)
-				needw = 1;
-		if (needw)
-			sun_write_table();
+		for (i = 0; i < 8; i++) {
+			if (ptes[i].changed) {
+				sun_write_table();
+				break;
+			}
+		}
 	}
 
-	printf("The partition table has been altered!\n\n");
+	puts("The partition table has been altered.");
 	reread_partition_table(1);
 }
-
-static void
-reread_partition_table(int leave)
-{
-	int i;
-
-	printf("Calling ioctl() to re-read partition table\n");
-	sync();
-	/* sleep(2); Huh? */
-	i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
-			"WARNING: rereading partition table "
-			"failed, kernel still uses old table");
-#if 0
-	if (dos_changed)
-		printf(
-		"\nWARNING: If you have created or modified any DOS 6.x\n"
-		"partitions, please see the fdisk manual page for additional\n"
-		"information\n");
-#endif
-
-	if (leave) {
-		if (ENABLE_FEATURE_CLEAN_UP)
-			close_dev_fd();
-		exit(i != 0);
-	}
-}
 #endif /* FEATURE_FDISK_WRITABLE */
 
 #if ENABLE_FEATURE_FDISK_ADVANCED
@@ -2542,26 +2745,29 @@ print_raw(void)
 }
 
 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;
 	}
 }
@@ -2573,7 +2779,7 @@ xselect(void)
 
 	while (1) {
 		bb_putchar('\n');
-		c = tolower(read_nonempty("Expert command (m for help): "));
+		c = 0x20 | read_nonempty("Expert command (m for help): ");
 		switch (c) {
 		case 'a':
 			if (LABEL_IS_SUN)
@@ -2613,8 +2819,7 @@ xselect(void)
 #endif
 			break;
 		case 'h':
-			user_heads = g_heads = read_int(1, g_heads, 256, 0,
-					"Number of heads");
+			user_heads = g_heads = read_int(1, g_heads, 256, 0, "Number of heads");
 			update_units();
 			break;
 		case 'i':
@@ -2639,12 +2844,11 @@ xselect(void)
 		case 'r':
 			return;
 		case 's':
-			user_sectors = g_sectors = read_int(1, g_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 = g_sectors;
-				printf("Warning: setting sector offset for DOS "
-					"compatiblity\n");
+				puts("Warning: setting sector offset for DOS "
+					"compatiblity");
 			}
 			update_units();
 			break;
@@ -2680,14 +2884,14 @@ is_ide_cdrom_or_tape(const char *device)
 	   the process hangs on the attempt to read a music CD.
 	   So try to be careful. This only works since 2.1.73. */
 
-	if (strncmp("/dev/hd", device, 7))
+	if (!is_prefixed_with(device, "/dev/hd"))
 		return 0;
 
 	snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
 	procf = fopen_for_read(buf);
 	if (procf != NULL && fgets(buf, sizeof(buf), procf))
-		is_ide = (!strncmp(buf, "cdrom", 5) ||
-			  !strncmp(buf, "tape", 4));
+		is_ide = (is_prefixed_with(buf, "cdrom") ||
+			  is_prefixed_with(buf, "tape"));
 	else
 		/* Now when this proc file does not exist, skip the
 		   device when it is read-only. */
@@ -2745,27 +2949,49 @@ open_list_and_close(const char *device, int user_specified)
 	close_dev_fd();
 }
 
+/* Is it a whole disk? The digit check is still useful
+   for Xen devices for example. */
+static int is_whole_disk(const char *disk)
+{
+	unsigned len;
+	int fd = open(disk, O_RDONLY);
+
+	if (fd != -1) {
+		struct hd_geometry geometry;
+		int err = ioctl(fd, HDIO_GETGEO, &geometry);
+		close(fd);
+		if (!err)
+			return (geometry.start == 0);
+	}
+
+	/* Treat "nameN" as a partition name, not whole disk */
+	/* note: mmcblk0 should work from the geometry check above */
+	len = strlen(disk);
+	if (len != 0 && isdigit(disk[len - 1]))
+		return 0;
+
+	return 1;
+}
+
 /* for fdisk -l: try all things in /proc/partitions
    that look like a partition name (do not end in a digit) */
 static void
 list_devs_in_proc_partititons(void)
 {
 	FILE *procpt;
-	char line[100], ptname[100], devname[120], *s;
+	char line[100], ptname[100], devname[120];
 	int ma, mi, sz;
 
 	procpt = fopen_or_warn("/proc/partitions", "r");
 
 	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++)
-			continue;
-		if (isdigit(s[-1]))
-			continue;
+
 		sprintf(devname, "/dev/%s", ptname);
-		open_list_and_close(devname, 0);
+		if (is_whole_disk(devname))
+			open_list_and_close(devname, 0);
 	}
 #if ENABLE_FEATURE_CLEAN_UP
 	fclose(procpt);
@@ -2781,7 +3007,7 @@ unknown_command(int c)
 #endif
 
 int fdisk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-int fdisk_main(int argc, char **argv)
+int fdisk_main(int argc UNUSED_PARAM, char **argv)
 {
 	unsigned opt;
 	/*
@@ -2796,19 +3022,20 @@ int fdisk_main(int argc, char **argv)
 
 	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" USE_FEATURE_FDISK_BLKSIZE("s"),
+	opt = getopt32(argv, "b:+C:+H:+lS:+u" IF_FEATURE_FDISK_BLKSIZE("s"),
 				&sector_size, &user_cylinders, &user_heads, &user_sectors);
-	argc -= optind;
 	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.
-		*/
-		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;
 	}
@@ -2843,24 +3070,24 @@ int fdisk_main(int argc, char **argv)
 		int j;
 
 		nowarn = 1;
-		if (argc <= 0)
+		if (!argv[0])
 			bb_show_usage();
-		for (j = 0; j < argc; j++) {
+		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("%lld\n", size);
+			if (argv[1])
+				printf("%llu\n", size);
 			else
-				printf("%s: %lld\n", argv[j], size);
+				printf("%s: %llu\n", argv[j], size);
 		}
 		return 0;
 	}
 #endif
 
 #if ENABLE_FEATURE_FDISK_WRITABLE
-	if (argc != 1)
+	if (!argv[0] || argv[1])
 		bb_show_usage();
 
 	disk_device = argv[0];
@@ -2879,7 +3106,7 @@ int fdisk_main(int argc, char **argv)
 	while (1) {
 		int c;
 		bb_putchar('\n');
-		c = tolower(read_nonempty("Command (m for help): "));
+		c = 0x20 | read_nonempty("Command (m for help): ");
 		switch (c) {
 		case 'a':
 			if (LABEL_IS_DOS)
@@ -2898,8 +3125,8 @@ int fdisk_main(int argc, char **argv)
 				printf("\nThe current boot file is: %s\n",
 					sgi_get_bootfile());
 				if (read_maybe_empty("Please enter the name of the "
-						   "new boot file: ") == '\n')
-					printf("Boot file unchanged\n");
+						"new boot file: ") == '\n')
+					puts("Boot file unchanged");
 				else
 					sgi_set_bootfile(line_ptr);
 			}
@@ -2976,13 +3203,13 @@ int fdisk_main(int argc, char **argv)
 			verify();
 			break;
 		case 'w':
-			write_table();          /* does not return */
+			write_table();  /* does not return */
 			break;
 #if ENABLE_FEATURE_FDISK_ADVANCED
 		case 'x':
 			if (LABEL_IS_SGI) {
-				printf("\n\tSorry, no experts menu for SGI "
-					"partition tables available\n\n");
+				puts("\n\tSorry, no experts menu for SGI "
+					"partition tables available\n");
 			} else
 				xselect();
 			break;