fdisk: add a warning and truncate disks with >= 2^32 sectors

As a result, for sectors we can use uint32_t instead of long long,
and on 32 bits it has drastic effects:

function                                             old     new   delta
get_geometry                                         619     646     +27
set_sun_partition                                    148     150      +2
get_partition                                        134     135      +1
xbsd_write_bootstrap                                 382     381      -1
xbsd_readlabel                                       247     246      -1
bsd_select                                          1674    1672      -2
sun_other_endian                                       4       1      -3
scsi_disk                                              4       1      -3
floppy                                                 4       1      -3
fdisk_main                                          3735    3732      -3
read_maybe_empty                                      43      37      -6
create_doslabel                                      111     104      -7
read_line                                             97      88      -9
add_logical                                          117     107     -10
write_table                                          599     588     -11
new_partition                                       1684    1670     -14
list_disk_geometry                                   229     215     -14
wrong_p_order                                        130     110     -20
xselect                                             3142    3114     -28
seek_sector                                           71      40     -31
get_boot                                            1576    1533     -43
fill_bounds                                          174     128     -46
delete_partition                                     603     551     -52
list_table                                          1401    1232    -169
set_partition                                        459     286    -173
verify                                              1840    1495    -345
add_partition                                       2486    1270   -1216
------------------------------------------------------------------------------
(add/remove: 0/0 grow/shrink: 3/24 up/down: 30/-2210)       Total: -2180 bytes
   text    data     bss     dec     hex filename
 848812     460    7116  856388   d1144 busybox_old
 846620     460    7108  854188   d08ac busybox_unstripped

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

5 files changed, 246 insertions, 211 deletions

diff --git a/util-linux/fdisk.c b/util-linux/fdisk.c
index 441640831..e50ee77d1 100644
--- a/util-linux/fdisk.c
+++ b/util-linux/fdisk.c
@@ -53,8 +53,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;
@@ -71,7 +81,7 @@ static const char msg_building_new_label[] ALIGN1 =
 "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";
 
 
 struct partition {
@@ -136,9 +146,9 @@ 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);
@@ -151,8 +161,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);
+static sector_t get_start_sect(const struct partition *p);
+static sector_t get_nr_sects(const struct partition *p);
 
 /*
  * per partition table entry data
@@ -165,8 +175,8 @@ static unsigned get_nr_sects(const struct partition *p);
 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 */
+	sector_t offset;                /* disk sector number */
+	char *sectorbuffer;             /* disk sector contents */
 #if ENABLE_FEATURE_FDISK_WRITABLE
 	char changed;           /* boolean */
 #endif
@@ -308,8 +318,8 @@ 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];
@@ -364,18 +374,36 @@ 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))
 		longsectors = 0;
+	if (sizeof(long) > sizeof(sector_t)
+	 && longsectors != (sector_t)longsectors
+	) {
+		goto ret_trunc;
+	}
 	return longsectors;
 }
 
@@ -566,15 +594,16 @@ static void fdisk_fatal(const char *why)
 }
 
 static void
-seek_sector(ullong secno)
+seek_sector(sector_t secno)
 {
-	secno *= sector_size;
 #if ENABLE_FDISK_SUPPORT_LARGE_DISKS
-	if (lseek64(dev_fd, (off64_t)secno, SEEK_SET) == (off64_t) -1)
+	off64_t off = (off64_t)secno * sector_size;
+	if (lseek64(dev_fd, off, 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
+	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);
 	}
@@ -583,7 +612,7 @@ seek_sector(ullong secno)
 
 #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);
@@ -707,7 +736,7 @@ set_start_sect(struct partition *p, unsigned start_sect)
 }
 #endif
 
-static unsigned
+static sector_t
 get_start_sect(const struct partition *p)
 {
 	return read4_little_endian(p->start4);
@@ -721,7 +750,7 @@ set_nr_sects(struct partition *p, unsigned nr_sects)
 }
 #endif
 
-static unsigned
+static sector_t
 get_nr_sects(const struct partition *p)
 {
 	return read4_little_endian(p->size4);
@@ -729,7 +758,7 @@ get_nr_sects(const struct partition *p)
 
 /* 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->sectorbuffer = xzalloc(sector_size);
@@ -743,7 +772,7 @@ read_pte(struct pte *pe, ullong offset)
 	pe->part_table = pe->ext_pointer = NULL;
 }
 
-static unsigned
+static sector_t
 get_partition_start(const struct pte *pe)
 {
 	return pe->offset + get_start_sect(pe->part_table);
@@ -985,10 +1014,10 @@ clear_partition(struct partition *p)
 
 #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;
@@ -1049,7 +1078,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"
@@ -1085,7 +1114,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
@@ -1104,14 +1133,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;
 			}
@@ -1144,7 +1173,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 */
 		}
@@ -1185,7 +1214,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);
 	}
@@ -1396,7 +1425,7 @@ static int get_boot(void)
 		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);
 		}
@@ -1406,7 +1435,7 @@ 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);
@@ -1425,10 +1454,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): ";
 
@@ -1451,8 +1480,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;
 
@@ -1460,7 +1491,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;
@@ -1483,38 +1514,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");
 	}
-	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];
@@ -1524,17 +1555,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];
@@ -1547,7 +1578,7 @@ 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");
@@ -1558,10 +1589,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];
@@ -1574,7 +1605,7 @@ 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");
@@ -1601,7 +1632,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;
 }
@@ -1674,8 +1705,8 @@ delete_partition(int i)
 
 			if (pe->part_table) /* prevent SEGFAULT */
 				set_start_sect(pe->part_table,
-						   get_partition_start(pe) -
-						   extended_offset);
+						get_partition_start(pe) -
+						extended_offset);
 			pe->offset = extended_offset;
 			pe->changed = 1;
 		}
@@ -1714,7 +1745,7 @@ 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) {
@@ -1765,7 +1796,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;
@@ -1823,23 +1854,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 "
+		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 (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
-		printf("Partition %d has different physical/logical "
+		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 != (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);
 	}
 }
@@ -1847,23 +1878,23 @@ 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);
+	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",
+		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);
 }
 
 /*
@@ -1876,8 +1907,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) {
@@ -2045,8 +2076,8 @@ list_table(int xtra)
 
 	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;
 
 		p = pe->part_table;
@@ -2064,14 +2095,14 @@ list_table(int xtra)
 		if (sector_size > 1024)
 			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(pe)),           /* start */
+			cround(get_partition_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 */
 
@@ -2079,8 +2110,8 @@ list_table(int xtra)
 	}
 
 	/* 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");
@@ -2095,20 +2126,21 @@ 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");
 	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),
 				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);
 		}
@@ -2118,9 +2150,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;
 
@@ -2137,35 +2169,35 @@ fill_bounds(ullong *first, ullong *last)
 }
 
 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 first[g_partitions], last[g_partitions];
 	struct partition *p;
 
 	if (warn_geometry())
@@ -2189,15 +2221,15 @@ verify(void)
 			check_consistency(p, i);
 			if (get_partition_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] ?
@@ -2209,7 +2241,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++) {
@@ -2217,22 +2249,22 @@ 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);
+		printf("Total allocated sectors %u greater than the maximum "
+			"%u\n", total, g_heads * g_sectors * g_cylinders);
 	else {
 		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);
 	}
 }
 
@@ -2243,9 +2275,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);
@@ -2255,7 +2287,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) {
@@ -2286,19 +2318,20 @@ 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);
 			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;
 		}
@@ -2546,16 +2579,16 @@ 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;
 
 	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);
+		printf("Partition %u has no data area\n", i + 1);
 		return;
 	}
 	first = get_partition_start(pe);
@@ -2761,7 +2794,7 @@ list_devs_in_proc_partititons(void)
 	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++)
@@ -2855,9 +2888,9 @@ int fdisk_main(int argc, char **argv)
 			size = bb_BLKGETSIZE_sectors(fd) / 2;
 			close(fd);
 			if (argc == 1)
-				printf("%lld\n", size);
+				printf("%llu\n", size);
 			else
-				printf("%s: %lld\n", argv[j], size);
+				printf("%s: %llu\n", argv[j], size);
 		}
 		return 0;
 	}
diff --git a/util-linux/fdisk_aix.c b/util-linux/fdisk_aix.c
index 2c0d2a6ac..2a0ab1744 100644
--- a/util-linux/fdisk_aix.c
+++ b/util-linux/fdisk_aix.c
@@ -54,8 +54,9 @@ aix_info(void)
 static int
 check_aix_label(void)
 {
-	if (aixlabel->magic != AIX_LABEL_MAGIC &&
-		aixlabel->magic != AIX_LABEL_MAGIC_SWAPPED) {
+	if (aixlabel->magic != AIX_LABEL_MAGIC
+	 && aixlabel->magic != AIX_LABEL_MAGIC_SWAPPED
+	) {
 		current_label_type = 0;
 		aix_other_endian = 0;
 		return 0;
diff --git a/util-linux/fdisk_osf.c b/util-linux/fdisk_osf.c
index aeccc6913..09a68da83 100644
--- a/util-linux/fdisk_osf.c
+++ b/util-linux/fdisk_osf.c
@@ -65,8 +65,8 @@ struct xbsd_disklabel {
 	int16_t    d_type;                 /* drive type */
 	int16_t    d_subtype;              /* controller/d_type specific */
 	char       d_typename[16];         /* type name, e.g. "eagle" */
-	char       d_packname[16];                 /* pack identifier */
-			/* disk geometry: */
+	char       d_packname[16];         /* pack identifier */
+	/* disk geometry: */
 	uint32_t   d_secsize;              /* # of bytes per sector */
 	uint32_t   d_nsectors;             /* # of data sectors per track */
 	uint32_t   d_ntracks;              /* # of tracks per cylinder */
@@ -87,7 +87,7 @@ struct xbsd_disklabel {
 	 */
 	uint32_t   d_acylinders;           /* # of alt. cylinders per unit */
 
-			/* hardware characteristics: */
+	/* hardware characteristics: */
 	/*
 	 * d_interleave, d_trackskew and d_cylskew describe perturbations
 	 * in the media format used to compensate for a slow controller.
@@ -117,11 +117,11 @@ struct xbsd_disklabel {
 	uint32_t   d_spare[NSPARE];        /* reserved for future use */
 	uint32_t   d_magic2;               /* the magic number (again) */
 	uint16_t   d_checksum;             /* xor of data incl. partitions */
-			/* filesystem and partition information: */
+	/* filesystem and partition information: */
 	uint16_t   d_npartitions;          /* number of partitions in following */
 	uint32_t   d_bbsize;               /* size of boot area at sn0, bytes */
 	uint32_t   d_sbsize;               /* max size of fs superblock, bytes */
-	struct xbsd_partition    {      /* the partition table */
+	struct xbsd_partition { /* the partition table */
 		uint32_t   p_size;         /* number of sectors in partition */
 		uint32_t   p_offset;       /* starting sector */
 		uint32_t   p_fsize;        /* filesystem basic fragment size */
@@ -367,7 +367,7 @@ bsd_select(void)
 					partname(disk_device, t+1, 0));
 				return;
 			}
-				printf("Reading disklabel of %s at sector %d\n",
+				printf("Reading disklabel of %s at sector %u\n",
 					partname(disk_device, t+1, 0), ss + BSD_LABELSECTOR);
 			if (xbsd_readlabel(xbsd_part) == 0)
 				if (xbsd_create_disklabel() == 0)
@@ -510,7 +510,7 @@ xbsd_print_disklabel(int show_all)
 		if ((unsigned) lp->d_type < ARRAY_SIZE(xbsd_dktypenames)-1)
 			printf("type: %s\n", xbsd_dktypenames[lp->d_type]);
 		else
-			printf("type: %d\n", lp->d_type);
+			printf("type: %u\n", lp->d_type);
 		printf("disk: %.*s\n", (int) sizeof(lp->d_typename), lp->d_typename);
 		printf("label: %.*s\n", (int) sizeof(lp->d_packname), lp->d_packname);
 		printf("flags: ");
@@ -518,18 +518,18 @@ xbsd_print_disklabel(int show_all)
 		bb_putchar('\n');
 		/* On various machines the fields of *lp are short/int/long */
 		/* In order to avoid problems, we cast them all to long. */
-		printf("bytes/sector: %ld\n", (long) lp->d_secsize);
-		printf("sectors/track: %ld\n", (long) lp->d_nsectors);
-		printf("tracks/cylinder: %ld\n", (long) lp->d_ntracks);
-		printf("sectors/cylinder: %ld\n", (long) lp->d_secpercyl);
-		printf("cylinders: %ld\n", (long) lp->d_ncylinders);
-		printf("rpm: %d\n", lp->d_rpm);
-		printf("interleave: %d\n", lp->d_interleave);
-		printf("trackskew: %d\n", lp->d_trackskew);
-		printf("cylinderskew: %d\n", lp->d_cylskew);
-		printf("headswitch: %ld\t\t# milliseconds\n",
+		printf("bytes/sector: %lu\n", (long) lp->d_secsize);
+		printf("sectors/track: %lu\n", (long) lp->d_nsectors);
+		printf("tracks/cylinder: %lu\n", (long) lp->d_ntracks);
+		printf("sectors/cylinder: %lu\n", (long) lp->d_secpercyl);
+		printf("cylinders: %lu\n", (long) lp->d_ncylinders);
+		printf("rpm: %u\n", lp->d_rpm);
+		printf("interleave: %u\n", lp->d_interleave);
+		printf("trackskew: %u\n", lp->d_trackskew);
+		printf("cylinderskew: %u\n", lp->d_cylskew);
+		printf("headswitch: %lu\t\t# milliseconds\n",
 			(long) lp->d_headswitch);
-		printf("track-to-track seek: %ld\t# milliseconds\n",
+		printf("track-to-track seek: %lu\t# milliseconds\n",
 			(long) lp->d_trkseek);
 		printf("drivedata: ");
 		for (i = NDDATA - 1; i >= 0; i--)
@@ -538,25 +538,25 @@ xbsd_print_disklabel(int show_all)
 		if (i < 0)
 			i = 0;
 		for (j = 0; j <= i; j++)
-			printf("%ld ", (long) lp->d_drivedata[j]);
+			printf("%lu ", (long) lp->d_drivedata[j]);
 	}
-	printf("\n%d partitions:\n", lp->d_npartitions);
+	printf("\n%u partitions:\n", lp->d_npartitions);
 	printf("#       start       end      size     fstype   [fsize bsize   cpg]\n");
 	pp = lp->d_partitions;
 	for (i = 0; i < lp->d_npartitions; i++, pp++) {
 		if (pp->p_size) {
 			if (display_in_cyl_units && lp->d_secpercyl) {
-				printf("  %c: %8ld%c %8ld%c %8ld%c  ",
+				printf("  %c: %8lu%c %8lu%c %8lu%c  ",
 					'a' + i,
-					(long) pp->p_offset / lp->d_secpercyl + 1,
+					(unsigned long) pp->p_offset / lp->d_secpercyl + 1,
 					(pp->p_offset % lp->d_secpercyl) ? '*' : ' ',
-					(long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl,
+					(unsigned long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl,
 					((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ',
 					(long) pp->p_size / lp->d_secpercyl,
 					(pp->p_size % lp->d_secpercyl) ? '*' : ' '
 				);
 			} else {
-				printf("  %c: %8ld  %8ld  %8ld   ",
+				printf("  %c: %8lu  %8lu  %8lu   ",
 					'a' + i,
 					(long) pp->p_offset,
 					(long) pp->p_offset + pp->p_size - 1,
@@ -571,11 +571,11 @@ xbsd_print_disklabel(int show_all)
 
 			switch (pp->p_fstype) {
 			case BSD_FS_UNUSED:
-				printf("    %5ld %5ld %5.5s ",
+				printf("    %5lu %5lu %5.5s ",
 					(long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, "");
 				break;
 			case BSD_FS_BSDFFS:
-				printf("    %5ld %5ld %5d ",
+				printf("    %5lu %5lu %5u ",
 					(long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, pp->p_cpg);
 				break;
 			default:
@@ -637,7 +637,7 @@ xbsd_create_disklabel(void)
 static int
 edit_int(int def, const char *mesg)
 {
-	mesg = xasprintf("%s (%d): ", mesg, def);
+	mesg = xasprintf("%s (%u): ", mesg, def);
 	do {
 		if (!read_line(mesg))
 			goto ret;
@@ -950,7 +950,7 @@ xbsd_readlabel(struct partition *p)
 	}
 
 	if (d->d_npartitions > BSD_MAXPARTITIONS)
-		printf("Warning: too many partitions (%d, maximum is %d)\n",
+		printf("Warning: too many partitions (%u, maximum is %u)\n",
 			d->d_npartitions, BSD_MAXPARTITIONS);
 	return 1;
 }
diff --git a/util-linux/fdisk_sgi.c b/util-linux/fdisk_sgi.c
index 51cf30c98..0e3cff50c 100644
--- a/util-linux/fdisk_sgi.c
+++ b/util-linux/fdisk_sgi.c
@@ -36,7 +36,7 @@ struct device_parameter { /* 48 bytes */
 	unsigned short nsect;   /* sectors/tracks in cyl 0 or vol 0 */
 	unsigned short bytes;
 	unsigned short ilfact;
-	unsigned int   flags;           /* controller flags */
+	unsigned int   flags;   /* controller flags */
 	unsigned int   datarate;
 	unsigned int   retries_on_error;
 	unsigned int   ms_per_word;
@@ -70,7 +70,7 @@ typedef struct {
 		unsigned int  vol_file_start;   /* number of logical block */
 		unsigned int  vol_file_size;    /* number of bytes */
 	} directory[15];
-	struct sgi_partinfo {                  /* 16 * 12 bytes */
+	struct sgi_partinfo {                   /* 16 * 12 bytes */
 		unsigned int num_sectors;       /* number of blocks */
 		unsigned int start_sector;      /* must be cylinder aligned */
 		unsigned int id;
@@ -291,11 +291,11 @@ sgi_list_table(int xtra)
 	int kpi = 0;                /* kernel partition ID */
 
 	if (xtra) {
-		printf("\nDisk %s (SGI disk label): %d heads, %d sectors\n"
-			"%d cylinders, %d physical cylinders\n"
-			"%d extra sects/cyl, interleave %d:1\n"
+		printf("\nDisk %s (SGI disk label): %u heads, %u sectors\n"
+			"%u cylinders, %u physical cylinders\n"
+			"%u extra sects/cyl, interleave %u:1\n"
 			"%s\n"
-			"Units = %s of %d * 512 bytes\n\n",
+			"Units = %s of %u * 512 bytes\n\n",
 			disk_device, g_heads, g_sectors, g_cylinders,
 			SGI_SSWAP16(sgiparam.pcylcount),
 			SGI_SSWAP16(sgiparam.sparecyl),
@@ -304,8 +304,8 @@ sgi_list_table(int xtra)
 			str_units(PLURAL), units_per_sector);
 	} else {
 		printf("\nDisk %s (SGI disk label): "
-			"%d heads, %d sectors, %d cylinders\n"
-			"Units = %s of %d * 512 bytes\n\n",
+			"%u heads, %u sectors, %u cylinders\n"
+			"Units = %s of %u * 512 bytes\n\n",
 			disk_device, g_heads, g_sectors, g_cylinders,
 			str_units(PLURAL), units_per_sector );
 	}
@@ -324,7 +324,7 @@ sgi_list_table(int xtra)
 			uint32_t len = sgi_get_num_sectors(i);
 			kpi++;              /* only count nonempty partitions */
 			printf(
-			"%2d: %s %4s %9ld %9ld %9ld  %2x  %s\n",
+			"%2u: %s %4s %9lu %9lu %9lu  %2x  %s\n",
 /* fdisk part number */	i+1,
 /* device */            partname(disk_device, kpi, w+3),
 /* flags */             (sgi_get_swappartition() == i) ? "swap" :
@@ -345,7 +345,7 @@ sgi_list_table(int xtra)
 			uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size);
 			unsigned char *name = sgilabel->directory[i].vol_file_name;
 
-			printf("%2d: %-10s sector%5u size%8u\n",
+			printf("%2u: %-10s sector%5u size%8u\n",
 				i, (char*)name, (unsigned int) start, (unsigned int) len);
 		}
 	}
@@ -507,19 +507,19 @@ verify_sgi(int verbose)
 		if ((sgi_get_start_sector(Index[0]) != 0) && verbose)
 			printf("The entire disk partition should start "
 				"at block 0,\n"
-				"not at diskblock %d\n",
+				"not at diskblock %u\n",
 				sgi_get_start_sector(Index[0]));
 		if (SGI_DEBUG)      /* I do not understand how some disks fulfil it */
 			if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose)
-				printf("The entire disk partition is only %d diskblock large,\n"
-					"but the disk is %d diskblocks long\n",
+				printf("The entire disk partition is only %u diskblock large,\n"
+					"but the disk is %u diskblocks long\n",
 					sgi_get_num_sectors(Index[0]), lastblock);
 			lastblock = sgi_get_num_sectors(Index[0]);
 	} else {
 		if (verbose)
 			printf("One Partition (#11) should cover the entire disk\n");
 		if (SGI_DEBUG > 2)
-			printf("sysid=%d\tpartition=%d\n",
+			printf("sysid=%u\tpartition=%u\n",
 				sgi_get_sysid(Index[0]), Index[0]+1);
 	}
 	for (i = 1, start = 0; i < sortcount; i++) {
@@ -528,20 +528,20 @@ verify_sgi(int verbose)
 		if ((sgi_get_start_sector(Index[i]) % cylsize) != 0) {
 			if (SGI_DEBUG)      /* I do not understand how some disks fulfil it */
 				if (verbose)
-					printf("Partition %d does not start on cylinder boundary\n",
+					printf("Partition %u does not start on cylinder boundary\n",
 						Index[i]+1);
 		}
 		if (sgi_get_num_sectors(Index[i]) % cylsize != 0) {
 			if (SGI_DEBUG)      /* I do not understand how some disks fulfil it */
 				if (verbose)
-					printf("Partition %d does not end on cylinder boundary\n",
+					printf("Partition %u does not end on cylinder boundary\n",
 						Index[i]+1);
 		}
 		/* We cannot handle several "entire disk" entries. */
 		if (sgi_get_sysid(Index[i]) == SGI_ENTIRE_DISK) continue;
 		if (start > sgi_get_start_sector(Index[i])) {
 			if (verbose)
-				printf("Partitions %d and %d overlap by %d sectors\n",
+				printf("Partitions %u and %u overlap by %u sectors\n",
 					Index[i-1]+1, Index[i]+1,
 					start - sgi_get_start_sector(Index[i]));
 			if (gap > 0) gap = -gap;
@@ -549,7 +549,7 @@ verify_sgi(int verbose)
 		}
 		if (start < sgi_get_start_sector(Index[i])) {
 			if (verbose)
-				printf("Unused gap of %8u sectors - sectors %8u-%8u\n",
+				printf("Unused gap of %u sectors - sectors %u-%u\n",
 					sgi_get_start_sector(Index[i]) - start,
 					start, sgi_get_start_sector(Index[i])-1);
 			gap += sgi_get_start_sector(Index[i]) - start;
@@ -559,7 +559,7 @@ verify_sgi(int verbose)
 			   + sgi_get_num_sectors(Index[i]);
 		if (SGI_DEBUG > 1) {
 			if (verbose)
-				printf("%2d:%12d\t%12d\t%12d\n", Index[i],
+				printf("%2u:%12u\t%12u\t%12u\n", Index[i],
 					sgi_get_start_sector(Index[i]),
 					sgi_get_num_sectors(Index[i]),
 					sgi_get_sysid(Index[i]));
@@ -567,7 +567,7 @@ verify_sgi(int verbose)
 	}
 	if (start < lastblock) {
 		if (verbose)
-			printf("Unused gap of %8u sectors - sectors %8u-%8u\n",
+			printf("Unused gap of %u sectors - sectors %u-%u\n",
 				lastblock - start, start, lastblock-1);
 		gap += lastblock - start;
 		add2freelist(start, lastblock);
@@ -788,7 +788,7 @@ create_sgilabel(void)
 			/* otherwise print error and use truncated version */
 			g_cylinders = geometry.cylinders;
 			printf(
-"Warning: BLKGETSIZE ioctl failed on %s.  Using geometry cylinder value of %d.\n"
+"Warning: BLKGETSIZE ioctl failed on %s.  Using geometry cylinder value of %u.\n"
 "This value may be truncated for devices > 33.8 GB.\n", disk_device, g_cylinders);
 		}
 	}
@@ -799,9 +799,9 @@ create_sgilabel(void)
 				old[i].sysid = get_part_table(i)->sys_ind;
 				old[i].start = get_start_sect(get_part_table(i));
 				old[i].nsect = get_nr_sects(get_part_table(i));
-				printf("Trying to keep parameters of partition %d\n", i);
+				printf("Trying to keep parameters of partition %u\n", i);
 				if (SGI_DEBUG)
-					printf("ID=%02x\tSTART=%d\tLENGTH=%d\n",
+					printf("ID=%02x\tSTART=%u\tLENGTH=%u\n",
 				old[i].sysid, old[i].start, old[i].nsect);
 			}
 		}
diff --git a/util-linux/fdisk_sun.c b/util-linux/fdisk_sun.c
index 9cdf869e9..fa6f7e48b 100644
--- a/util-linux/fdisk_sun.c
+++ b/util-linux/fdisk_sun.c
@@ -27,9 +27,9 @@
 
 #define SCSI_IOCTL_GET_IDLUN 0x5382
 
-static int sun_other_endian;
-static int scsi_disk;
-static int floppy;
+static smallint sun_other_endian;
+static smallint scsi_disk;
+static smallint floppy;
 
 #ifndef IDE0_MAJOR
 #define IDE0_MAJOR 3
@@ -81,7 +81,7 @@ static const char *const sun_sys_types[] = {
 
 
 static void
-set_sun_partition(int i, uint start, uint stop, int sysid)
+set_sun_partition(int i, unsigned start, unsigned stop, int sysid)
 {
 	sunlabel->infos[i].id = sysid;
 	sunlabel->partitions[i].start_cylinder =
@@ -98,7 +98,8 @@ check_sun_label(void)
 	int csum;
 
 	if (sunlabel->magic != SUN_LABEL_MAGIC
-	 && sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED) {
+	 && sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED
+	) {
 		current_label_type = LABEL_DOS;
 		sun_other_endian = 0;
 		return 0;
@@ -173,7 +174,7 @@ sun_autoconfigure_scsi(void)
 		return NULL;
 
 	sprintf(buffer,
-		"Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n",
+		"Host: scsi%u Channel: %02u Id: %02u Lun: %02u\n",
 		/* This is very wrong (works only if you have one HBA),
 		   but I haven't found a way how to get hostno
 		   from the current kernel */
@@ -317,7 +318,7 @@ create_sunlabel(void)
 	}
 
 	snprintf((char *)(sunlabel->info), sizeof(sunlabel->info),
-		"%s%s%s cyl %d alt %d hd %d sec %d",
+		"%s%s%s cyl %u alt %u hd %u sec %u",
 		p ? p->vendor : "", (p && *p->vendor) ? " " : "",
 		p ? p->model : (floppy ? "3,5\" floppy" : "Linux custom"),
 		g_cylinders, SUN_SSWAP16(sunlabel->nacyl), g_heads, g_sectors);
@@ -361,7 +362,7 @@ toggle_sunflags(int i, unsigned char mask)
 }
 
 static void
-fetch_sun(uint *starts, uint *lens, uint *start, uint *stop)
+fetch_sun(unsigned *starts, unsigned *lens, unsigned *start, unsigned *stop)
 {
 	int i, continuous = 1;
 
@@ -390,7 +391,7 @@ fetch_sun(uint *starts, uint *lens, uint *start, uint *stop)
 	}
 }
 
-static uint *verify_sun_starts;
+static unsigned *verify_sun_starts;
 
 static int
 verify_sun_cmp(int *a, int *b)
@@ -404,7 +405,7 @@ verify_sun_cmp(int *a, int *b)
 static void
 verify_sun(void)
 {
-	uint starts[8], lens[8], start, stop;
+	unsigned starts[8], lens[8], start, stop;
 	int i,j,k,starto,endo;
 	int array[8];
 
@@ -413,7 +414,7 @@ verify_sun(void)
 	for (k = 0; k < 7; k++) {
 		for (i = 0; i < 8; i++) {
 			if (k && (lens[i] % (g_heads * g_sectors))) {
-				printf("Partition %d doesn't end on cylinder boundary\n", i+1);
+				printf("Partition %u doesn't end on cylinder boundary\n", i+1);
 			}
 			if (lens[i]) {
 				for (j = 0; j < i; j++)
@@ -433,8 +434,8 @@ verify_sun(void)
 								endo = starts[i]+lens[i];
 								if (starts[j]+lens[j] < endo)
 									endo = starts[j]+lens[j];
-								printf("Partition %d overlaps with others in "
-									"sectors %d-%d\n", i+1, starto, endo);
+								printf("Partition %u overlaps with others in "
+									"sectors %u-%u\n", i+1, starto, endo);
 							}
 						}
 					}
@@ -455,20 +456,20 @@ verify_sun(void)
 	}
 	stop = g_cylinders * g_heads * g_sectors;
 	if (starts[array[0]])
-		printf("Unused gap - sectors 0-%d\n", starts[array[0]]);
+		printf("Unused gap - sectors %u-%u\n", 0, starts[array[0]]);
 	for (i = 0; i < 7 && array[i+1] != -1; i++) {
-		printf("Unused gap - sectors %d-%d\n", starts[array[i]]+lens[array[i]], starts[array[i+1]]);
+		printf("Unused gap - sectors %u-%u\n", starts[array[i]]+lens[array[i]], starts[array[i+1]]);
 	}
 	start = starts[array[i]] + lens[array[i]];
 	if (start < stop)
-		printf("Unused gap - sectors %d-%d\n", start, stop);
+		printf("Unused gap - sectors %u-%u\n", start, stop);
 }
 
 static void
 add_sun_partition(int n, int sys)
 {
-	uint start, stop, stop2;
-	uint starts[8], lens[8];
+	unsigned start, stop, stop2;
+	unsigned starts[8], lens[8];
 	int whole_disk = 0;
 
 	char mesg[256];
@@ -529,7 +530,7 @@ and is of type 'Whole disk'\n");
 				whole_disk = 1;
 				break;
 			}
-			printf("Sector %d is already allocated\n", first);
+			printf("Sector %u is already allocated\n", first);
 		} else
 			break;
 	}
@@ -560,8 +561,8 @@ and is of type 'Whole disk'\n");
 		} else if (last > stop) {
 			printf(
 "You haven't covered the whole disk with the 3rd partition,\n"
-"but your value %d %s covers some other partition.\n"
-"Your entry has been changed to %d %s\n",
+"but your value %u %s covers some other partition.\n"
+"Your entry has been changed to %u %s\n",
 				scround(last), str_units(SINGULAR),
 				scround(stop), str_units(SINGULAR));
 			last = stop;
@@ -627,11 +628,11 @@ sun_list_table(int xtra)
 	w = strlen(disk_device);
 	if (xtra)
 		printf(
-		"\nDisk %s (Sun disk label): %d heads, %d sectors, %d rpm\n"
-		"%d cylinders, %d alternate cylinders, %d physical cylinders\n"
-		"%d extra sects/cyl, interleave %d:1\n"
+		"\nDisk %s (Sun disk label): %u heads, %u sectors, %u rpm\n"
+		"%u cylinders, %u alternate cylinders, %u physical cylinders\n"
+		"%u extra sects/cyl, interleave %u:1\n"
 		"%s\n"
-		"Units = %s of %d * 512 bytes\n\n",
+		"Units = %s of %u * 512 bytes\n\n",
 			disk_device, g_heads, g_sectors, SUN_SSWAP16(sunlabel->rspeed),
 			g_cylinders, SUN_SSWAP16(sunlabel->nacyl),
 			SUN_SSWAP16(sunlabel->pcylcount),
@@ -641,8 +642,8 @@ sun_list_table(int xtra)
 			str_units(PLURAL), units_per_sector);
 	else
 		printf(
-	"\nDisk %s (Sun disk label): %d heads, %d sectors, %d cylinders\n"
-	"Units = %s of %d * 512 bytes\n\n",
+	"\nDisk %s (Sun disk label): %u heads, %u sectors, %u cylinders\n"
+	"Units = %s of %u * 512 bytes\n\n",
 			disk_device, g_heads, g_sectors, g_cylinders,
 			str_units(PLURAL), units_per_sector);
 
@@ -652,7 +653,7 @@ sun_list_table(int xtra)
 		if (sunlabel->partitions[i].num_sectors) {
 			uint32_t start = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * g_heads * g_sectors;
 			uint32_t len = SUN_SSWAP32(sunlabel->partitions[i].num_sectors);
-			printf("%s %c%c %9ld %9ld %9ld%c  %2x  %s\n",
+			printf("%s %c%c %9lu %9lu %9lu%c  %2x  %s\n",
 				partname(disk_device, i+1, w),			/* device */
 				(sunlabel->infos[i].flags & 0x01) ? 'u' : ' ',  /* flags */
 				(sunlabel->infos[i].flags & 0x10) ? 'r' : ' ',