/* vi: set sw=4 ts=4: */
-/* fdisk.c -- Partition table manipulator for Linux.
+/*
+ * fdisk.c -- Partition table manipulator for Linux.
*
* 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 GPLv2 or later, see file LICENSE in this source tree.
*/
+//config:config FDISK
+//config: bool "fdisk (41 kb)"
+//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: )
//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"
-//usage: "\n -S SECTORS"
+//usage: "\n -H HEADS Typically 255"
+//usage: "\n -S SECTORS Typically 63"
#ifndef _LARGEFILE64_SOURCE
/* For lseek64 */
# 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
* do not support more than 2^32 sectors
*/
typedef uint32_t sector_t;
-#if UINT_MAX == 4294967295
+#if UINT_MAX == 0xffffffff
# define SECT_FMT ""
-#elif ULONG_MAX == 4294967295
+#elif ULONG_MAX == 0xffffffff
# define SECT_FMT "l"
#else
# error Cant detect sizeof(uint32_t)
#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"
static const char msg_part_already_defined[] ALIGN1 =
"Partition %u is already defined, delete it before re-adding\n";
+/* #endif */
struct partition {
unsigned sector_offset; // = 1;
unsigned g_heads, g_sectors, g_cylinders;
smallint /* enum label_type */ current_label_type;
- smallint display_in_cyl_units; // = 1;
+ smallint display_in_cyl_units;
#if ENABLE_FEATURE_OSF_LABEL
smallint possibly_osf_label;
#endif
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];
#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 { \
sector_size = DEFAULT_SECTOR_SIZE; \
sector_offset = 1; \
g_partitions = 4; \
- display_in_cyl_units = 1; \
units_per_sector = 1; \
dos_compatible_flag = 1; \
} while (0)
#define cylinder(s, c) ((c) | (((s) & 0xc0) << 2))
-#define hsc2sector(h,s,c) \
- (sector(s) - 1 + sectors * ((h) + heads * cylinder(s,c)))
-
static void
close_dev_fd(void)
{
xmove_fd(xopen(bb_dev_null, O_RDONLY), dev_fd);
}
-/*
- * Return partition name - uses static storage
- */
+/* Return partition name */
static const char *
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 = "";
}
#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)
{
b[511] = 0xaa;
}
+/* Read line; return 0 or first printable non-space char */
+static int
+read_line(const char *prompt)
+{
+ int sz;
+
+ sz = read_line_input(NULL, prompt, line_buffer, sizeof(line_buffer));
+ 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 char
read_nonempty(const char *mesg)
{
if (*line_ptr == '+' || *line_ptr == '-') {
int minus = (*line_ptr == '-');
- int absolute = 0;
+ unsigned scale_shift;
- value = atoi(line_ptr + 1);
+ if (sizeof(value) <= sizeof(long))
+ value = strtoul(line_ptr + 1, NULL, 10);
+ else
+ value = strtoull(line_ptr + 1, NULL, 10);
/* (1) if 2nd char is digit, use_default = 0.
- * (2) move line_ptr to first non-digit. */
+ * (2) move line_ptr to first non-digit.
+ */
while (isdigit(*++line_ptr))
use_default = 0;
- switch (*line_ptr) {
- case 'c':
- case 'C':
- if (!display_in_cyl_units)
- value *= g_heads * g_sectors;
- break;
- case 'K':
- absolute = 1024;
- break;
+ scale_shift = 0;
+ switch (*line_ptr | 0x20) {
case 'k':
- absolute = 1000;
+ scale_shift = 10; /* 1024 */
break;
+/*
+ * fdisk from util-linux 2.31 seems to round '+NNNk' and '+NNNK' to megabytes,
+ * (512-byte) sector count of the partition does not equal NNN*2:
+ *
+ * Last sector, +sectors or +size{K,M,G,T,P} (1953792-1000215215, default 1000215215): +9727k
+ * Device Boot Start End Sectors Size Id Type
+ * /dev/sdaN 1953792 1972223 18432 9M 83 Linux <-- size exactly 9*1024*1024 bytes
+ *
+ * Last sector, +sectors or +size{K,M,G,T,P} (1953792-1000215215, default 1000215215): +9728k
+ * /dev/sdaN 1953792 1974271 20480 10M 83 Linux <-- size exactly 10*1024*1024 bytes
+ *
+ * If 'k' means 1000 bytes (not 1024), then 9728k = 9728*1000 = 9500*1024,
+ * exactly halfway from 9000 to 10000, which explains why it jumps to next mbyte
+ * at this value.
+ *
+ * 'm' does not seem to behave this way: it means 1024*1024 bytes.
+ *
+ * Not sure we want to copy this. If user says he wants 1234kbyte partition,
+ * we do _exactly that_: 1234kbytes = 2468 sectors.
+ */
case 'm':
- case 'M':
- absolute = 1000000;
+ scale_shift = 20; /* 1024*1024 */
break;
case 'g':
- case 'G':
- absolute = 1000000000;
+ scale_shift = 30; /* 1024*1024*1024 */
+ break;
+ case 't':
+ scale_shift = 40; /* 1024*1024*1024*1024 */
break;
default:
break;
}
- if (absolute) {
+ if (scale_shift) {
ullong bytes;
unsigned long unit;
- bytes = (ullong) value * absolute;
+ bytes = (ullong) value << scale_shift;
unit = sector_size * units_per_sector;
bytes += unit/2; /* round */
bytes /= unit;
- value = bytes;
+ value = (bytes != 0 ? bytes - 1 : 0);
}
if (minus)
value = -value;
value += base;
} else {
- value = atoi(line_ptr);
+ if (sizeof(value) <= sizeof(long))
+ value = strtoul(line_ptr, NULL, 10);
+ else
+ value = strtoull(line_ptr, NULL, 10);
while (isdigit(*line_ptr)) {
line_ptr++;
use_default = 0;
}
static int
-get_nonexisting_partition(int warn, unsigned max)
+get_nonexisting_partition(void)
{
+ const int max = 4;
int pno = -1;
unsigned i;
return -1;
not_unique:
- return get_partition(warn, max);
+ return get_partition(/*warn*/ 0, max);
}
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);
/* Same physical / logical beginning? */
if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
printf("Partition %u has different physical/logical "
- "beginnings (non-Linux?):\n", partition + 1);
- printf(" phys=(%u, %u, %u) ", pbc, pbh, pbs);
- printf("logical=(%u, %u, %u)\n", lbc, lbh, lbs);
+ "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 %u has different physical/logical "
- "endings:\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 %u does not end on cylinder boundary\n",
- partition + 1);
+ "end:\n", partition + 1);
+ printf(" phys=(%u,%u,%u) ", pec, peh, pes);
+ printf("logical=(%u,%u,%u)\n", lec, leh, les);
}
}
list_disk_geometry(void)
{
ullong bytes = ((ullong)total_number_of_sectors << 9);
- long megabytes = bytes / 1000000;
-
- if (megabytes < 10000)
- printf("\nDisk %s: %lu MB, %llu bytes\n",
- disk_device, megabytes, bytes);
- else
- 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 %"SECT_FMT"u sectors",
- total_number_of_sectors / (sector_size/512));
- printf("\nUnits = %s of %u * %u = %u bytes\n\n",
+ ullong xbytes = bytes / (1024*1024);
+ char x = 'M';
+
+ 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);
+ units_per_sector, sector_size, units_per_sector * sector_size
+ );
}
/*
}
#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) {
}
/* 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];
- sector_t psects;
- sector_t 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 %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 */
- ? '*' : '?',
- cround(get_partition_start_from_dev_start(pe)), /* start */
- cround(get_partition_start_from_dev_start(pe) + psects /* end */
- - (psects ? 1 : 0)),
- 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);
}
p = (extend ? pe->ext_pointer : pe->part_table);
if (p != NULL) {
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,
+ 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);
}
{
int i, j;
sector_t total = 1;
+ sector_t chs_size;
sector_t first[g_partitions], last[g_partitions];
struct partition *p;
}
}
- if (total > g_heads * g_sectors * g_cylinders)
- printf("Total allocated sectors %u greater than the maximum "
- "%u\n", total, g_heads * g_sectors * g_cylinders);
+ 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("%"SECT_FMT"u unallocated sectors\n", total);
}
stop = limit;
} else {
snprintf(mesg, sizeof(mesg),
- "Last %s or +size or +sizeM or +sizeK",
- str_units(SINGULAR));
+ "Last %s or +size{,K,M,G,T}",
+ str_units(SINGULAR)
+ );
stop = read_int(cround(start), cround(limit), cround(limit), cround(start), mesg);
if (display_in_cyl_units) {
stop = stop * units_per_sector - 1;
} else {
char c, line[80];
snprintf(line, sizeof(line),
- "Command action\n"
- " %s\n"
- " p primary partition (1-4)\n",
+ "Partition type\n"
+ " p primary partition (1-4)\n"
+ " %s\n",
(extended_offset ?
"l logical (5 or over)" : "e extended"));
while (1) {
c = read_nonempty(line);
- if ((c | 0x20) == 'p') {
- i = get_nonexisting_partition(0, 4);
+ c |= 0x20; /* lowercase */
+ if (c == 'p') {
+ i = get_nonexisting_partition();
if (i >= 0)
add_partition(i, LINUX_NATIVE);
return;
return;
}
if (c == 'e' && !extended_offset) {
- i = get_nonexisting_partition(0, 4);
+ i = get_nonexisting_partition();
if (i >= 0)
add_partition(i, EXTENDED);
return;
if (dos_compatible_flag) {
sector_offset = g_sectors;
puts("Warning: setting sector offset for DOS "
- "compatiblity");
+ "compatibility");
}
update_units();
break;
close_dev_fd(); /* needed: fd 3 must not stay closed */
- opt_complementary = "b+:C+:H+:S+"; /* numeric params */
- opt = getopt32(argv, "b:C:H:lS:u" IF_FEATURE_FDISK_BLKSIZE("s"),
+ opt = getopt32(argv, "b:+C:+H:+lS:+u" IF_FEATURE_FDISK_BLKSIZE("s"),
§or_size, &user_cylinders, &user_heads, &user_sectors);
argv += optind;
if (opt & OPT_b) {
projects / oweals / busybox.git / blobdiff