* Copyright (C) 1992 A. V. Le Blanc (LeBlanc@mcc.ac.uk)
* Copyright (C) 2001,2002 Vladimir Oleynik <dzo@simtreas.ru> (initial bb port)
*
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
*/
+/* Looks like someone forgot to add this to config system */
+//usage:#ifndef ENABLE_FEATURE_FDISK_BLKSIZE
+//usage:# define ENABLE_FEATURE_FDISK_BLKSIZE 0
+//usage:# define IF_FEATURE_FDISK_BLKSIZE(a)
+//usage:#endif
+//usage:
+//usage:#define fdisk_trivial_usage
+//usage: "[-ul" IF_FEATURE_FDISK_BLKSIZE("s") "] "
+//usage: "[-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SSZ] DISK"
+//usage:#define fdisk_full_usage "\n\n"
+//usage: "Change partition table\n"
+//usage: "\n -u Start and End are in sectors (instead of cylinders)"
+//usage: "\n -l Show partition table for each DISK, then exit"
+//usage: IF_FEATURE_FDISK_BLKSIZE(
+//usage: "\n -s Show partition sizes in kb for each DISK, then exit"
+//usage: )
+//usage: "\n -b 2048 (for certain MO disks) use 2048-byte sectors"
+//usage: "\n -C CYLINDERS Set number of cylinders/heads/sectors"
+//usage: "\n -H HEADS"
+//usage: "\n -S SECTORS"
+
#ifndef _LARGEFILE64_SOURCE
/* For lseek64 */
# define _LARGEFILE64_SOURCE
unsigned char size4[4]; /* nr of sectors in partition */
} PACKED;
-static const char unable_to_open[] ALIGN1 = "can't open '%s'";
-static const char unable_to_read[] ALIGN1 = "can't read from %s";
-static const char unable_to_seek[] ALIGN1 = "can't seek on %s";
+/*
+ * per partition table entry data
+ *
+ * The four primary partitions have the same sectorbuffer (MBRbuffer)
+ * and have NULL ext_pointer.
+ * Each logical partition table entry has two pointers, one for the
+ * partition and one link to the next one.
+ */
+struct pte {
+ struct partition *part_table; /* points into sectorbuffer */
+ struct partition *ext_pointer; /* points into sectorbuffer */
+ sector_t offset_from_dev_start; /* disk sector number */
+ char *sectorbuffer; /* disk sector contents */
+#if ENABLE_FEATURE_FDISK_WRITABLE
+ char changed; /* boolean */
+#endif
+};
+
+#define unable_to_open "can't open '%s'"
+#define unable_to_read "can't read from %s"
+#define unable_to_seek "can't seek on %s"
enum label_type {
- LABEL_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF
+ LABEL_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF, LABEL_GPT
};
#define LABEL_IS_DOS (LABEL_DOS == current_label_type)
#define STATIC_OSF extern
#endif
+#if ENABLE_FEATURE_GPT_LABEL
+#define LABEL_IS_GPT (LABEL_GPT == current_label_type)
+#define STATIC_GPT static
+#else
+#define LABEL_IS_GPT 0
+#define STATIC_GPT extern
+#endif
+
enum action { OPEN_MAIN, TRY_ONLY, CREATE_EMPTY_DOS, CREATE_EMPTY_SUN };
static void update_units(void);
#endif
static const char *partition_type(unsigned char type);
static void get_geometry(void);
+static void read_pte(struct pte *pe, sector_t offset);
#if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
static int get_boot(enum action what);
#else
static sector_t get_start_sect(const struct partition *p);
static sector_t get_nr_sects(const struct partition *p);
-/*
- * per partition table entry data
- *
- * The four primary partitions have the same sectorbuffer (MBRbuffer)
- * and have NULL ext_pointer.
- * Each logical partition table entry has two pointers, one for the
- * partition and one link to the next one.
- */
-struct pte {
- struct partition *part_table; /* points into sectorbuffer */
- struct partition *ext_pointer; /* points into sectorbuffer */
- sector_t offset; /* disk sector number */
- char *sectorbuffer; /* disk sector contents */
-#if ENABLE_FEATURE_FDISK_WRITABLE
- char changed; /* boolean */
-#endif
-};
-
/* DOS partition types */
static const char *const i386_sys_types[] = {
return v64;
}
/* Needs temp of type long */
- if (ioctl(fd, BLKGETSIZE, &longsectors))
+ if (ioctl(fd, BLKGETSIZE, &longsectors)) {
+ /* Perhaps this is a disk image */
+ off_t sz = lseek(fd, 0, SEEK_END);
longsectors = 0;
+ if (sz > 0)
+ longsectors = (uoff_t)sz / sector_size;
+ lseek(fd, 0, SEEK_SET);
+ }
if (sizeof(long) > sizeof(sector_t)
&& longsectors != (sector_t)longsectors
) {
#define hsc2sector(h,s,c) \
(sector(s) - 1 + sectors * ((h) + heads * cylinder(s,c)))
-#define set_hsc(h,s,c,sector) \
- do { \
- s = sector % g_sectors + 1; \
- sector /= g_sectors; \
- h = sector % g_heads; \
- sector /= g_heads; \
- c = sector & 0xff; \
- s |= (sector >> 2) & 0xc0; \
- } while (0)
-
static void
close_dev_fd(void)
{
{
int sz;
- sz = read_line_input(prompt, line_buffer, sizeof(line_buffer), NULL);
+ sz = read_line_input(NULL, prompt, line_buffer, sizeof(line_buffer), /*timeout*/ -1);
if (sz <= 0)
exit(EXIT_SUCCESS); /* Ctrl-D or Ctrl-C */
unsigned long v;
while (1) {
read_nonempty("Hex code (type L to list codes): ");
- if (*line_ptr == 'l' || *line_ptr == 'L') {
+ if ((line_ptr[0] | 0x20) == 'l') {
list_types(sys);
continue;
}
STATIC_OSF void xbsd_print_disklabel(int);
#include "fdisk_osf.c"
+STATIC_GPT void gpt_list_table(int xtra);
+#include "fdisk_gpt.c"
+
#if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL
static uint16_t
fdisk_swap16(uint16_t x)
static void
read_pte(struct pte *pe, sector_t offset)
{
- pe->offset = offset;
+ pe->offset_from_dev_start = offset;
pe->sectorbuffer = xzalloc(sector_size);
seek_sector(offset);
/* xread would make us abort - bad for fdisk -l */
}
static sector_t
-get_partition_start(const struct pte *pe)
+get_partition_start_from_dev_start(const struct pte *pe)
{
- return pe->offset + get_start_sect(pe->part_table);
+ return pe->offset_from_dev_start + get_start_sect(pe->part_table);
}
#if ENABLE_FEATURE_FDISK_WRITABLE
puts("o\tcreate a new empty DOS partition table");
puts("q\tquit without saving changes");
puts("s\tcreate a new empty Sun disklabel"); /* sun */
+ } else if (LABEL_IS_GPT) {
+ puts("o\tcreate a new empty DOS partition table");
+ puts("p\tprint the partition table");
+ puts("q\tquit without saving changes");
+ puts("s\tcreate a new empty Sun disklabel"); /* sun */
} else {
puts("a\ttoggle a bootable flag");
puts("b\tedit bsd disklabel");
bb_putchar('\n');
}
+#define set_hsc(h, s, c, sector) do \
+{ \
+ s = sector % g_sectors + 1; \
+ sector /= g_sectors; \
+ h = sector % g_heads; \
+ sector /= g_heads; \
+ c = sector & 0xff; \
+ s |= (sector >> 2) & 0xc0; \
+} while (0)
+
+static void set_hsc_start_end(struct partition *p, sector_t start, sector_t stop)
+{
+ if (dos_compatible_flag && (start / (g_sectors * g_heads) > 1023))
+ start = g_heads * g_sectors * 1024 - 1;
+ set_hsc(p->head, p->sector, p->cyl, start);
+
+ if (dos_compatible_flag && (stop / (g_sectors * g_heads) > 1023))
+ stop = g_heads * g_sectors * 1024 - 1;
+ set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
+}
+
static void
set_partition(int i, int doext, sector_t start, sector_t stop, int sysid)
{
offset = extended_offset;
} else {
p = ptes[i].part_table;
- offset = ptes[i].offset;
+ offset = ptes[i].offset_from_dev_start;
}
p->boot_ind = 0;
p->sys_ind = sysid;
set_start_sect(p, start - offset);
set_nr_sects(p, stop - start + 1);
- if (dos_compatible_flag && (start / (g_sectors * g_heads) > 1023))
- start = g_heads * g_sectors * 1024 - 1;
- set_hsc(p->head, p->sector, p->cyl, start);
- if (dos_compatible_flag && (stop / (g_sectors * g_heads) > 1023))
- stop = g_heads * g_sectors * 1024 - 1;
- set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
+ set_hsc_start_end(p, start, stop);
ptes[i].changed = 1;
}
#endif
/*
* Opens disk_device and optionally reads MBR.
- * FIXME: document what each 'what' value will do!
+ * If what == OPEN_MAIN:
+ * Open device, read MBR. Abort program on short read. Create empty
+ * disklabel if the on-disk structure is invalid (WRITABLE mode).
+ * If what == TRY_ONLY:
+ * Open device, read MBR. Return an error if anything is out of place.
+ * Do not create an empty disklabel. This is used for the "list"
+ * operations: "fdisk -l /dev/sda" and "fdisk -l" (all devices).
+ * If what == CREATE_EMPTY_*:
+ * This means that get_boot() was called recursively from create_*label().
+ * Do not re-open the device; just set up the ptes array and print
+ * geometry warnings.
+ *
* Returns:
* -1: no 0xaa55 flag present (possibly entire disk BSD)
* 0: found or created label
struct pte *pe = &ptes[i];
pe->part_table = pt_offset(MBRbuffer, i);
pe->ext_pointer = NULL;
- pe->offset = 0;
+ pe->offset_from_dev_start = 0;
pe->sectorbuffer = MBRbuffer;
#if ENABLE_FEATURE_FDISK_WRITABLE
pe->changed = (what == CREATE_EMPTY_DOS);
if (check_aix_label())
return 0;
#endif
+#if ENABLE_FEATURE_GPT_LABEL
+ if (check_gpt_label())
+ return 0;
+#endif
#if ENABLE_FEATURE_OSF_LABEL
if (check_osf_label()) {
possibly_osf_label = 1;
if (!valid_part_table_flag(MBRbuffer)) {
if (what == OPEN_MAIN) {
printf("Device contains neither a valid DOS "
- "partition table, nor Sun, SGI or OSF "
+ "partition table, nor Sun, SGI, OSF or GPT "
"disklabel\n");
#ifdef __sparc__
IF_FEATURE_SUN_LABEL(create_sunlabel();)
if (pe->part_table) /* prevent SEGFAULT */
set_start_sect(pe->part_table,
- get_partition_start(pe) -
+ get_partition_start_from_dev_start(pe) -
extended_offset);
- pe->offset = extended_offset;
+ pe->offset_from_dev_start = extended_offset;
pe->changed = 1;
}
pe = &ptes[i];
p = pe->part_table;
if (p->sys_ind) {
- p_start_pos = get_partition_start(pe);
+ p_start_pos = get_partition_start_from_dev_start(pe);
if (last_p_start_pos > p_start_pos) {
if (prev)
/* (Its sector is the global extended_offset.) */
stage1:
for (j = 5; j < g_partitions - 1; j++) {
- oj = ptes[j].offset;
- ojj = ptes[j+1].offset;
+ oj = ptes[j].offset_from_dev_start;
+ ojj = ptes[j+1].offset_from_dev_start;
if (oj > ojj) {
- ptes[j].offset = ojj;
- ptes[j+1].offset = oj;
+ ptes[j].offset_from_dev_start = ojj;
+ ptes[j+1].offset_from_dev_start = oj;
pj = ptes[j].part_table;
set_start_sect(pj, get_start_sect(pj)+oj-ojj);
pjj = ptes[j+1].part_table;
pjj = ptes[j+1].part_table;
sj = get_start_sect(pj);
sjj = get_start_sect(pjj);
- oj = ptes[j].offset;
- ojj = ptes[j+1].offset;
+ oj = ptes[j].offset_from_dev_start;
+ ojj = ptes[j+1].offset_from_dev_start;
if (oj+sj > ojj+sjj) {
tmp = *pj;
*pj = *pjj;
fix_chain_of_logicals();
printf("Done.\n");
-
}
#endif
sun_list_table(xtra);
return;
}
- if (LABEL_IS_SUN) {
+ if (LABEL_IS_SGI) {
sgi_list_table(xtra);
return;
}
+ if (LABEL_IS_GPT) {
+ gpt_list_table(xtra);
+ return;
+ }
list_disk_geometry();
partname(disk_device, i+1, w+2),
!p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */
? '*' : '?',
- cround(get_partition_start(pe)), /* start */
- cround(get_partition_start(pe) + psects /* end */
+ cround(get_partition_start_from_dev_start(pe)), /* start */
+ cround(get_partition_start_from_dev_start(pe) + psects /* end */
- (psects ? 1 : 0)),
pblocks, podd ? '+' : ' ', /* odd flag on end */
p->sys_ind, /* type id */
first[i] = 0xffffffff;
last[i] = 0;
} else {
- first[i] = get_partition_start(pe);
+ first[i] = get_partition_start_from_dev_start(pe);
last[i] = first[i] + get_nr_sects(p) - 1;
}
}
p = pe->part_table;
if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
check_consistency(p, i);
- if (get_partition_start(pe) < first[i])
+ if (get_partition_start_from_dev_start(pe) < first[i])
printf("Warning: bad start-of-data in "
"partition %u\n", i + 1);
check(i + 1, p->end_head, p->end_sector, p->end_cyl,
for (i = 0; i < g_partitions; i++) {
int lastplusoff;
- if (start == ptes[i].offset)
+ if (start == ptes[i].offset_from_dev_start)
start += sector_offset;
lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
if (start >= first[i] && start <= lastplusoff)
sector_t saved_start;
saved_start = start;
- start = read_int(cround(saved_start), cround(saved_start), cround(limit),
- 0, mesg);
+ start = read_int(cround(saved_start), cround(saved_start), cround(limit), 0, mesg);
if (display_in_cyl_units) {
start = (start - 1) * units_per_sector;
if (start < saved_start)
if (n > 4) { /* NOT for fifth partition */
struct pte *pe = &ptes[n];
- pe->offset = start - sector_offset;
- if (pe->offset == extended_offset) { /* must be corrected */
- pe->offset++;
+ pe->offset_from_dev_start = start - sector_offset;
+ if (pe->offset_from_dev_start == extended_offset) { /* must be corrected */
+ pe->offset_from_dev_start++;
if (sector_offset == 1)
start++;
}
for (i = 0; i < g_partitions; i++) {
struct pte *pe = &ptes[i];
- if (start < pe->offset && limit >= pe->offset)
- limit = pe->offset - 1;
+ if (start < pe->offset_from_dev_start && limit >= pe->offset_from_dev_start)
+ limit = pe->offset_from_dev_start - 1;
if (start < first[i] && limit >= first[i])
limit = first[i] - 1;
}
snprintf(mesg, sizeof(mesg),
"Last %s or +size or +sizeM or +sizeK",
str_units(SINGULAR));
- stop = read_int(cround(start), cround(limit), cround(limit),
- cround(start), mesg);
+ stop = read_int(cround(start), cround(limit), cround(limit), cround(start), mesg);
if (display_in_cyl_units) {
stop = stop * units_per_sector - 1;
if (stop >limit)
set_partition(n, 0, start, stop, sys);
if (n > 4)
- set_partition(n - 1, 1, ptes[n].offset, stop, EXTENDED);
+ set_partition(n - 1, 1, ptes[n].offset_from_dev_start, stop, EXTENDED);
if (IS_EXTENDED(sys)) {
struct pte *pe4 = &ptes[4];
ext_index = n;
pen->ext_pointer = p;
- pe4->offset = extended_offset = start;
+ pe4->offset_from_dev_start = extended_offset = start;
pe4->sectorbuffer = xzalloc(sector_size);
pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
pe4->ext_pointer = pe4->part_table + 1;
pe->sectorbuffer = xzalloc(sector_size);
pe->part_table = pt_offset(pe->sectorbuffer, 0);
pe->ext_pointer = pe->part_table + 1;
- pe->offset = 0;
+ pe->offset_from_dev_start = 0;
pe->changed = 1;
g_partitions++;
}
"l logical (5 or over)" : "e extended"));
while (1) {
c = read_nonempty(line);
- if (c == 'p' || c == 'P') {
+ if ((c | 0x20) == 'p') {
i = get_nonexisting_partition(0, 4);
if (i >= 0)
add_partition(i, LINUX_NATIVE);
}
}
+static void
+reread_partition_table(int leave)
+{
+ int i;
+
+ printf("Calling ioctl() to re-read partition table\n");
+ sync();
+ /* Users with slow external USB disks on a 320MHz ARM system (year 2011)
+ * report that sleep is needed, otherwise BLKRRPART may fail with -EIO:
+ */
+ sleep(1);
+ i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
+ "WARNING: rereading partition table "
+ "failed, kernel still uses old table");
+#if 0
+ if (dos_changed)
+ printf(
+ "\nWARNING: If you have created or modified any DOS 6.x\n"
+ "partitions, please see the fdisk manual page for additional\n"
+ "information\n");
+#endif
+
+ if (leave) {
+ if (ENABLE_FEATURE_CLEAN_UP)
+ close_dev_fd();
+ exit(i != 0);
+ }
+}
+
static void
write_table(void)
{
ptes[3].changed = 1;
for (i = 3; i < g_partitions; i++) {
struct pte *pe = &ptes[i];
-
if (pe->changed) {
write_part_table_flag(pe->sectorbuffer);
- write_sector(pe->offset, pe->sectorbuffer);
+ write_sector(pe->offset_from_dev_start, pe->sectorbuffer);
}
}
}
sgi_write_table();
}
else if (LABEL_IS_SUN) {
- int needw = 0;
-
- for (i = 0; i < 8; i++)
- if (ptes[i].changed)
- needw = 1;
- if (needw)
- sun_write_table();
+ for (i = 0; i < 8; i++) {
+ if (ptes[i].changed) {
+ sun_write_table();
+ break;
+ }
+ }
}
- printf("The partition table has been altered!\n\n");
+ printf("The partition table has been altered.\n");
reread_partition_table(1);
}
-
-static void
-reread_partition_table(int leave)
-{
- int i;
-
- printf("Calling ioctl() to re-read partition table\n");
- sync();
- /* sleep(2); Huh? */
- i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
- "WARNING: rereading partition table "
- "failed, kernel still uses old table");
-#if 0
- if (dos_changed)
- printf(
- "\nWARNING: If you have created or modified any DOS 6.x\n"
- "partitions, please see the fdisk manual page for additional\n"
- "information\n");
-#endif
-
- if (leave) {
- if (ENABLE_FEATURE_CLEAN_UP)
- close_dev_fd();
- exit(i != 0);
- }
-}
#endif /* FEATURE_FDISK_WRITABLE */
#if ENABLE_FEATURE_FDISK_ADVANCED
{
struct pte *pe = &ptes[i];
struct partition *p = pe->part_table;
- sector_t new, first;
+ sector_t new, first, nr_sects;
if (warn_geometry())
return;
- if (!p->sys_ind || !get_nr_sects(p) || IS_EXTENDED(p->sys_ind)) {
+ nr_sects = get_nr_sects(p);
+ if (!p->sys_ind || !nr_sects || IS_EXTENDED(p->sys_ind)) {
printf("Partition %u has no data area\n", i + 1);
return;
}
- first = get_partition_start(pe);
- new = read_int(first, first, first + get_nr_sects(p) - 1, first,
- "New beginning of data") - pe->offset;
-
- if (new != get_nr_sects(p)) {
- first = get_nr_sects(p) + get_start_sect(p) - new;
- set_nr_sects(p, first);
- set_start_sect(p, new);
+ first = get_partition_start_from_dev_start(pe); /* == pe->offset_from_dev_start + get_start_sect(p) */
+ new = read_int(0 /*was:first*/, first, first + nr_sects - 1, first, "New beginning of data");
+ if (new != first) {
+ sector_t new_relative = new - pe->offset_from_dev_start;
+ nr_sects += (get_start_sect(p) - new_relative);
+ set_start_sect(p, new_relative);
+ set_nr_sects(p, nr_sects);
+ read_nonempty("Recalculate C/H/S values? (Y/N): ");
+ if ((line_ptr[0] | 0x20) == 'y')
+ set_hsc_start_end(p, new, new + nr_sects - 1);
pe->changed = 1;
}
}
while (1) {
bb_putchar('\n');
- c = tolower(read_nonempty("Expert command (m for help): "));
+ c = 0x20 | read_nonempty("Expert command (m for help): ");
switch (c) {
case 'a':
if (LABEL_IS_SUN)
#endif
break;
case 'h':
- user_heads = g_heads = read_int(1, g_heads, 256, 0,
- "Number of heads");
+ user_heads = g_heads = read_int(1, g_heads, 256, 0, "Number of heads");
update_units();
break;
case 'i':
case 'r':
return;
case 's':
- user_sectors = g_sectors = read_int(1, g_sectors, 63, 0,
- "Number of sectors");
+ user_sectors = g_sectors = read_int(1, g_sectors, 63, 0, "Number of sectors");
if (dos_compatible_flag) {
sector_offset = g_sectors;
printf("Warning: setting sector offset for DOS "
close_dev_fd();
}
+/* Is it a whole disk? The digit check is still useful
+ for Xen devices for example. */
+static int is_whole_disk(const char *disk)
+{
+ unsigned len;
+ int fd = open(disk, O_RDONLY);
+
+ if (fd != -1) {
+ struct hd_geometry geometry;
+ int err = ioctl(fd, HDIO_GETGEO, &geometry);
+ close(fd);
+ if (!err)
+ return (geometry.start == 0);
+ }
+
+ /* Treat "nameN" as a partition name, not whole disk */
+ /* note: mmcblk0 should work from the geometry check above */
+ len = strlen(disk);
+ if (len != 0 && isdigit(disk[len - 1]))
+ return 0;
+
+ return 1;
+}
+
/* for fdisk -l: try all things in /proc/partitions
that look like a partition name (do not end in a digit) */
static void
list_devs_in_proc_partititons(void)
{
FILE *procpt;
- char line[100], ptname[100], devname[120], *s;
+ char line[100], ptname[100], devname[120];
int ma, mi, sz;
procpt = fopen_or_warn("/proc/partitions", "r");
if (sscanf(line, " %u %u %u %[^\n ]",
&ma, &mi, &sz, ptname) != 4)
continue;
- for (s = ptname; *s; s++)
- continue;
- /* note: excluding '0': e.g. mmcblk0 is not a partition name! */
- if (s[-1] >= '1' && s[-1] <= '9')
- continue;
+
sprintf(devname, "/dev/%s", ptname);
- open_list_and_close(devname, 0);
+ if (is_whole_disk(devname))
+ open_list_and_close(devname, 0);
}
#if ENABLE_FEATURE_CLEAN_UP
fclose(procpt);
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) { // -b
+ if (opt & OPT_b) {
/* Ugly: this sector size is really per device,
- so cannot be combined with multiple disks,
- and the same goes for the C/H/S options.
- */
- if (sector_size != 512 && sector_size != 1024
- && sector_size != 2048)
+ * so cannot be combined with multiple disks,
+ * and the same goes for the C/H/S options.
+ */
+ if (sector_size < 512
+ || sector_size > 0x10000
+ || (sector_size & (sector_size-1)) /* not power of 2 */
+ ) {
bb_show_usage();
+ }
sector_offset = 2;
user_set_sector_size = 1;
}
while (1) {
int c;
bb_putchar('\n');
- c = tolower(read_nonempty("Command (m for help): "));
+ c = 0x20 | read_nonempty("Command (m for help): ");
switch (c) {
case 'a':
if (LABEL_IS_DOS)
printf("\nThe current boot file is: %s\n",
sgi_get_bootfile());
if (read_maybe_empty("Please enter the name of the "
- "new boot file: ") == '\n')
+ "new boot file: ") == '\n')
printf("Boot file unchanged\n");
else
sgi_set_bootfile(line_ptr);
verify();
break;
case 'w':
- write_table(); /* does not return */
+ write_table(); /* does not return */
break;
#if ENABLE_FEATURE_FDISK_ADVANCED
case 'x':