/[magellan-source]/trunk/mkinitrd-magellan/busybox/util-linux/fdisk.c

Diff of /trunk/mkinitrd-magellan/busybox/util-linux/fdisk.c

Parent Directory | Revision Log | View Patch Patch

-revision 983 by niro,
Fri Apr 24 18:33:46 2009 UTC
+revision 984 by niro,
Sun May 30 11:32:42 2010 UTC
 Line 9
  #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"
  /* 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
-Line 49 
 enum {
+Line 56 
 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;
-Line 67 
 static const char msg_building_new_label
+Line 84 
 static const char msg_building_new_label
  "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 {
-Line 83 
 struct partition {
+Line 100 
 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_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";
-Line 132 
 static void update_units(void);
+Line 149 
 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);
-Line 147 
 static int get_boot(void);
+Line 164 
 static int get_boot(void);
  #define PLURAL   0
  #define SINGULAR 1
- static unsigned get_start_sect(const struct partition *p);
+ static sector_t get_start_sect(const struct partition *p);
- static unsigned get_nr_sects(const struct partition *p);
+ static sector_t get_nr_sects(const struct partition *p);
  /*
   * per partition table entry data
-Line 161 
 static unsigned get_nr_sects(const struc
+Line 178 
 static unsigned get_nr_sects(const struc
  struct pte {
  	struct partition *part_table;   /* points into sectorbuffer */
  	struct partition *ext_pointer;  /* points into sectorbuffer */
- 	ullong offset;          /* disk sector number */
+ 	sector_t offset;                /* disk sector number */
- 	char *sectorbuffer;     /* disk sector contents */
+ 	char *sectorbuffer;             /* disk sector contents */
  #if ENABLE_FEATURE_FDISK_WRITABLE
  	char changed;           /* boolean */
  #endif
-Line 304 
 struct globals {
+Line 321 
 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 */
+ 	sector_t extended_offset;       /* offset of link pointers */
- 	ullong total_number_of_sectors;
+ 	sector_t total_number_of_sectors;
  	jmp_buf listingbuf;
  	char line_buffer[80];
-Line 360 
 struct globals {
+Line 377 
 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;
  }
-Line 425 
 read_line(const char *prompt)
+Line 460 
 read_line(const char *prompt)
  		line_buffer[--sz] = '\0';
  	line_ptr = line_buffer;
- 	while (*line_ptr && !isgraph(*line_ptr))
+ 	while (*line_ptr != '\0' && (unsigned char)*line_ptr <= ' ')
  		line_ptr++;
  	return *line_ptr;
  }
-Line 562 
 static void fdisk_fatal(const char *why)
+Line 597 
 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)
+ 	uint64_t off = (uint64_t)secno * sector_size;
- 	 || lseek(dev_fd, (off_t)secno, SEEK_SET) == (off_t) -1
+ 	if (off > MAXINT(off_t)
+ 	 || lseek(dev_fd, (off_t)off, SEEK_SET) == (off_t) -1
  	) {
  		fdisk_fatal(unable_to_seek);
  	}
-Line 579 
 seek_sector(ullong secno)
+Line 615 
 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);
-Line 703 
 set_start_sect(struct partition *p, unsi
+Line 739 
 set_start_sect(struct partition *p, unsi
  }
  #endif
- static unsigned
+ static sector_t
  get_start_sect(const struct partition *p)
  {
  	return read4_little_endian(p->start4);
-Line 717 
 set_nr_sects(struct partition *p, unsign
+Line 753 
 set_nr_sects(struct partition *p, unsign
  }
  #endif
- static unsigned
+ static sector_t
  get_nr_sects(const struct partition *p)
  {
  	return read4_little_endian(p->size4);
-Line 725 
 get_nr_sects(const struct partition *p)
+Line 761 
 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);
-Line 739 
 read_pte(struct pte *pe, ullong offset)
+Line 775 
 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);
-Line 981 
 clear_partition(struct partition *p)
+Line 1017 
 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;
-Line 1045 
 warn_cylinders(void)
+Line 1081 
 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"
-Line 1081 
 read_extended(int ext)
+Line 1117 
 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
-Line 1100 
 read_extended(int ext)
+Line 1136 
 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;
  			}
-Line 1140 
 read_extended(int ext)
+Line 1176 
 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 */
  		}
-Line 1181 
 get_sectorsize(void)
+Line 1217 
 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);
  	}
-Line 1302 
 static int get_boot(void)
+Line 1338 
 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);
-Line 1372 
 static int get_boot(void)
+Line 1408 
 static int get_boot(void)
  				  "partition table, nor Sun, SGI or OSF "
  				  "disklabel\n");
  #ifdef __sparc__
- 			USE_FEATURE_SUN_LABEL(create_sunlabel();)
+ 			IF_FEATURE_SUN_LABEL(create_sunlabel();)
  #else
  			create_doslabel();
  #endif
-Line 1385 
 static int get_boot(void)
+Line 1421 
 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);
  		}
-Line 1402 
 static int get_boot(void)
+Line 1438 
 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;)
  		}
  	}
-Line 1421 
 static int get_boot(void)
+Line 1457 
 static int get_boot(void)
   *
   * There is no default if DFLT is not between LOW and HIGH.
   */
- static unsigned
+ static sector_t
- read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg)
+ 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): ";
-Line 1447 
 read_int(unsigned low, unsigned dflt, un
+Line 1483 
 read_int(unsigned low, unsigned dflt, un
  			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;
-Line 1456 
 read_int(unsigned low, unsigned dflt, un
+Line 1494 
 read_int(unsigned low, unsigned dflt, un
  			case 'c':
  			case 'C':
  				if (!display_in_cyl_units)
- 					i *= g_heads * g_sectors;
+ 					value *= g_heads * g_sectors;
  				break;
  			case 'K':
  				absolute = 1024;
-Line 1479 
 read_int(unsigned low, unsigned dflt, un
+Line 1517 
 read_int(unsigned low, unsigned dflt, un
  				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;
+ 				value = -value;
- 			i += base;
+ 			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;
+ 			value = dflt;
- 			printf("Using default value %u\n", i);
+ 			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
+ static unsigned
- get_partition(int warn, int max)
+ 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];
-Line 1520 
 get_partition(int warn, int max)
+Line 1558 
 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];
-Line 1543 
 get_existing_partition(int warn, int max
+Line 1581 
 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");
-Line 1554 
 get_existing_partition(int warn, int max
+Line 1592 
 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];
-Line 1570 
 get_nonexisting_partition(int warn, int
+Line 1608 
 get_nonexisting_partition(int warn, int
  		}
  	}
  	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");
-Line 1597 
 toggle_active(int i)
+Line 1635 
 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;
  }
-Line 1670 
 delete_partition(int i)
+Line 1708 
 delete_partition(int i)
  			if (pe->part_table) /* prevent SEGFAULT */
  				set_start_sect(pe->part_table,
- 						   get_partition_start(pe) -
+ 						get_partition_start(pe) -
- 						   extended_offset);
+ 						extended_offset);
  			pe->offset = extended_offset;
  			pe->changed = 1;
  		}
-Line 1710 
 change_sysid(void)
+Line 1748 
 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) {
-Line 1761 
 change_sysid(void)
+Line 1799 
 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;
-Line 1819 
 check_consistency(const struct partition
+Line 1857 
 check_consistency(const struct 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("     phys=(%u, %u, %u) ", pbc, pbh, pbs);
- 		printf("logical=(%d, %d, %d)\n", lbc, lbh, lbs);
+ 		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("     phys=(%u, %u, %u) ", pec, peh, pes);
- 		printf("logical=(%d, %d, %d)\n", lec, leh, les);
+ 		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);
  	}
  }
-Line 1843 
 check_consistency(const struct partition
+Line 1881 
 check_consistency(const struct partition
  static void
  list_disk_geometry(void)
  {
- 	long long bytes = (total_number_of_sectors << 9);
+ 	ullong bytes = ((ullong)total_number_of_sectors << 9);
- 	long megabytes = bytes/1000000;
+ 	long megabytes = bytes / 1000000;
  	if (megabytes < 10000)
- 		printf("\nDisk %s: %ld MB, %lld bytes\n",
+ 		printf("\nDisk %s: %lu MB, %llu bytes\n",
- 			   disk_device, megabytes, bytes);
+ 			disk_device, megabytes, bytes);
  	else
- 		printf("\nDisk %s: %ld.%ld GB, %lld bytes\n",
+ 		printf("\nDisk %s: %lu.%lu GB, %llu bytes\n",
- 			   disk_device, megabytes/1000, (megabytes/100)%10, bytes);
+ 			disk_device, megabytes/1000, (megabytes/100)%10, bytes);
- 	printf("%d heads, %d sectors/track, %d cylinders",
+ 	printf("%u heads, %u sectors/track, %u cylinders",
  		   g_heads, g_sectors, g_cylinders);
  	if (units_per_sector == 1)
- 		printf(", total %llu sectors",
+ 		printf(", total %"SECT_FMT"u sectors",
- 			   total_number_of_sectors / (sector_size/512));
+ 			total_number_of_sectors / (sector_size/512));
- 	printf("\nUnits = %s of %d * %d = %d bytes\n\n",
+ 	printf("\nUnits = %s of %u * %u = %u bytes\n\n",
- 		   str_units(PLURAL),
+ 		str_units(PLURAL),
- 		   units_per_sector, sector_size, units_per_sector * sector_size);
+ 		units_per_sector, sector_size, units_per_sector * sector_size);
  }
  /*
-Line 1872 
 wrong_p_order(int *prev)
+Line 1910 
 wrong_p_order(int *prev)
  {
  	const struct pte *pe;
  	const struct partition *p;
- 	ullong last_p_start_pos = 0, p_start_pos;
+ 	sector_t last_p_start_pos = 0, p_start_pos;
- 	int i, last_i = 0;
+ 	unsigned i, last_i = 0;
  	for (i = 0; i < g_partitions; i++) {
  		if (i == 4) {
-Line 2041 
 list_table(int xtra)
+Line 2079 
 list_table(int xtra)
  	for (i = 0; i < g_partitions; i++) {
  		const struct pte *pe = &ptes[i];
- 		ullong psects;
+ 		sector_t psects;
- 		ullong pblocks;
+ 		sector_t pblocks;
  		unsigned podd;
  		p = pe->part_table;
-Line 2060 
 list_table(int xtra)
+Line 2098 
 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 */
+ 			cround(get_partition_start(pe)),           /* start */
- 			(ullong) cround(get_partition_start(pe) + psects    /* end */
+ 			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 */
-Line 2075 
 list_table(int xtra)
+Line 2113 
 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
+ 	/* partition table entries are not checked for correct order
- 	   is a sgi, sun or aix labeled disk... */
+ 	 * 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");
-Line 2091 
 x_list_table(int extend)
+Line 2129 
 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);
  		}
-Line 2114 
 x_list_table(int extend)
+Line 2153 
 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;
-Line 2133 
 fill_bounds(ullong *first, ullong *last)
+Line 2172 
 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 "
+ 		printf("Partition %u: sector %u greater than "
- 			"maximum %d\n", n, s, g_sectors);
+ 			"maximum %u\n", n, s, g_sectors);
  	if (real_c >= g_cylinders)
- 		printf("Partition %d: cylinder %llu greater than "
+ 		printf("Partition %u: cylinder %"SECT_FMT"u greater than "
- 			"maximum %d\n", n, real_c + 1, g_cylinders);
+ 			"maximum %u\n", n, real_c + 1, g_cylinders);
  	if (g_cylinders <= 1024 && start != total)
- 		printf("Partition %d: previous sectors %llu disagrees with "
+ 		printf("Partition %u: previous sectors %"SECT_FMT"u disagrees with "
- 			"total %llu\n", n, start, total);
+ 			"total %"SECT_FMT"u\n", n, start, total);
  }
  static void
  verify(void)
  {
  	int i, j;
- 	unsigned total = 1;
+ 	sector_t total = 1;
- 	ullong first[g_partitions], last[g_partitions];
+ 	sector_t first[g_partitions], last[g_partitions];
  	struct partition *p;
  	if (warn_geometry())
-Line 2185 
 verify(void)
+Line 2224 
 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 "
+ 					printf("Warning: partition %u overlaps "
- 						"partition %d\n", j + 1, i + 1);
+ 						"partition %u\n", j + 1, i + 1);
  					total += first[i] >= first[j] ?
  						first[i] : first[j];
  					total -= last[i] <= last[j] ?
-Line 2205 
 verify(void)
+Line 2244 
 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++) {
-Line 2213 
 verify(void)
+Line 2252 
 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 "
+ 				printf("Logical partition %u not entirely in "
- 					"partition %d\n", i + 1, ext_index + 1);
+ 					"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 "
+ 		printf("Total allocated sectors %u greater than the maximum "
- 			"%d\n", total, g_heads * g_sectors * g_cylinders);
+ 			"%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);
  	}
  }
-Line 2239 
 add_partition(int n, int sys)
+Line 2278 
 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;
+ 	sector_t limit, temp;
- 	ullong start, stop = 0;
+ 	sector_t start, stop = 0;
- 	ullong first[g_partitions], last[g_partitions];
+ 	sector_t first[g_partitions], last[g_partitions];
  	if (p && p->sys_ind) {
  		printf(msg_part_already_defined, n + 1);
-Line 2251 
 add_partition(int n, int sys)
+Line 2290 
 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) {
-Line 2282 
 add_partition(int n, int sys)
+Line 2321 
 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),
 , 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;
  		}
-Line 2542 
 print_raw(void)
+Line 2582 
 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);
-Line 2757 
 list_devs_in_proc_partititons(void)
+Line 2797 
 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++)
-Line 2781 
 unknown_command(int c)
+Line 2821 
 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;
  	/*
-Line 2797 
 int fdisk_main(int argc, char **argv)
+Line 2837 
 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
  		/* Ugly: this sector size is really per device,
-Line 2843 
 int fdisk_main(int argc, char **argv)
+Line 2882 
 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)
+ 			if (argv[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;
  	}
  #endif
  #if ENABLE_FEATURE_FDISK_WRITABLE
- 	if (argc != 1)
+ 	if (!argv[0] || argv[1])
  		bb_show_usage();
  	disk_device = argv[0];

 Legend:



Removed from v.983
 


changed lines


 
Added in v.984
 Legend:



Removed from v.983
 


changed lines


 
Added in v.984
-Removed from v.983
+Added in v.984