* Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
*/
+#ifndef _LARGEFILE64_SOURCE
+/* For lseek64 */
+#define _LARGEFILE64_SOURCE
+#endif
#include <assert.h> /* assert */
-#include "busybox.h"
-#define _(x) x
+#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)
+#endif
+
+#define SIZE(a) (sizeof(a)/sizeof((a)[0]))
#define DEFAULT_SECTOR_SIZE 512
#define MAX_SECTOR_SIZE 2048
#define LINUX_LVM 0x8e
#define LINUX_RAID 0xfd
-#define IS_EXTENDED(i) \
- ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
-
-#define SIZE(a) (sizeof(a)/sizeof((a)[0]))
-
-#define cround(n) (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
-#define scround(x) (((x)+units_per_sector-1)/units_per_sector)
+/* Used for sector numbers. Today's disk sizes make it necessary */
+typedef unsigned long long ullong;
struct hd_geometry {
unsigned char heads;
#define HDIO_GETGEO 0x0301 /* get device geometry */
-struct systypes {
- const char *name;
-};
+static const char msg_building_new_label[] =
+"Building a new %s. Changes will remain in memory only,\n"
+"until you decide to write them. After that the previous content\n"
+"won't be recoverable.\n\n";
-static uint sector_size = DEFAULT_SECTOR_SIZE;
-static uint user_set_sector_size;
-static uint sector_offset = 1;
+static const char msg_part_already_defined[] =
+"Partition %d is already defined, delete it before re-adding\n";
-/*
- * Raw disk label. For DOS-type partition tables the MBR,
- * with descriptions of the primary partitions.
- */
-#if (MAX_SECTOR_SIZE) > (BUFSIZ+1)
-static char MBRbuffer[MAX_SECTOR_SIZE];
-#else
-# define MBRbuffer bb_common_bufsiz1
-#endif
-#ifdef CONFIG_FEATURE_OSF_LABEL
+static unsigned sector_size = DEFAULT_SECTOR_SIZE;
+static unsigned user_set_sector_size;
+static unsigned sector_offset = 1;
+
+#if ENABLE_FEATURE_OSF_LABEL
static int possibly_osf_label;
#endif
-static uint heads, sectors, cylinders;
+static unsigned heads, sectors, cylinders;
static void update_units(void);
-/*
- * return partition name - uses static storage unless buf is supplied
- */
-static const char *
-partname(const char *dev, int pno, int lth)
-{
- static char buffer[80];
- const char *p;
- int w, wp;
- int bufsiz;
- char *bufp;
-
- bufp = buffer;
- bufsiz = sizeof(buffer);
-
- w = strlen(dev);
- p = "";
-
- if (isdigit(dev[w-1]))
- p = "p";
-
- /* devfs kludge - note: fdisk partition names are not supposed
- to equal kernel names, so there is no reason to do this */
- if (strcmp(dev + w - 4, "disc") == 0) {
- w -= 4;
- p = "part";
- }
-
- wp = strlen(p);
-
- if (lth) {
- snprintf(bufp, bufsiz, "%*.*s%s%-2u",
- lth-wp-2, w, dev, p, pno);
- } else {
- snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
- }
- return bufp;
-}
-
struct partition {
unsigned char boot_ind; /* 0x80 - active */
unsigned char head; /* starting head */
unsigned char size4[4]; /* nr of sectors in partition */
} ATTRIBUTE_PACKED;
-enum failure {
- ioctl_error, unable_to_open, unable_to_read, unable_to_seek,
- unable_to_write
-};
+static const char unable_to_open[] = "cannot open %s";
+static const char unable_to_read[] = "cannot read from %s";
+static const char unable_to_seek[] = "cannot seek on %s";
+static const char unable_to_write[] = "cannot write to %s";
+static const char ioctl_error[] = "BLKGETSIZE ioctl failed on %s";
+static void fdisk_fatal(const char *why) ATTRIBUTE_NORETURN;
enum label_type {
label_dos, label_sun, label_sgi, label_aix, label_osf
};
+
#define LABEL_IS_DOS (label_dos == current_label_type)
-#ifdef CONFIG_FEATURE_SUN_LABEL
+
+#if ENABLE_FEATURE_SUN_LABEL
#define LABEL_IS_SUN (label_sun == current_label_type)
+#define STATIC_SUN static
#else
#define LABEL_IS_SUN 0
+#define STATIC_SUN extern
#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
+
+#if ENABLE_FEATURE_SGI_LABEL
#define LABEL_IS_SGI (label_sgi == current_label_type)
+#define STATIC_SGI static
#else
#define LABEL_IS_SGI 0
+#define STATIC_SGI extern
#endif
-#ifdef CONFIG_FEATURE_AIX_LABEL
+
+#if ENABLE_FEATURE_AIX_LABEL
#define LABEL_IS_AIX (label_aix == current_label_type)
+#define STATIC_AIX static
#else
#define LABEL_IS_AIX 0
+#define STATIC_AIX extern
#endif
-#ifdef CONFIG_FEATURE_OSF_LABEL
+
+#if ENABLE_FEATURE_OSF_LABEL
#define LABEL_IS_OSF (label_osf == current_label_type)
+#define STATIC_OSF static
#else
#define LABEL_IS_OSF 0
+#define STATIC_OSF extern
#endif
enum action { fdisk, require, try_only, create_empty_dos, create_empty_sun };
static const char *disk_device;
static int fd; /* the disk */
static int partitions = 4; /* maximum partition + 1 */
-static uint display_in_cyl_units = 1;
-static uint units_per_sector = 1;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+static int display_in_cyl_units = 1;
+static unsigned units_per_sector = 1;
+#if ENABLE_FEATURE_FDISK_WRITABLE
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 void list_types(const struct systypes *sys);
-static uint read_int(uint low, uint dflt, uint high, uint base, char *mesg);
+static void list_types(const char *const *sys);
+static unsigned read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg);
#endif
static const char *partition_type(unsigned char type);
-static void fdisk_fatal(enum failure why) ATTRIBUTE_NORETURN;
static void get_geometry(void);
static int get_boot(enum action what);
#define PLURAL 0
#define SINGULAR 1
-#define hex_val(c) ({ \
- char _c = (c); \
- isdigit(_c) ? _c - '0' : \
- tolower(_c) + 10 - 'a'; \
- })
-
-
-#define LINE_LENGTH 800
-#define pt_offset(b, n) ((struct partition *)((b) + 0x1be + \
- (n) * sizeof(struct partition)))
-#define sector(s) ((s) & 0x3f)
-#define cylinder(s, c) ((c) | (((s) & 0xc0) << 2))
-
-#define hsc2sector(h,s,c) (sector(s) - 1 + sectors * \
- ((h) + heads * cylinder(s,c)))
-#define set_hsc(h,s,c,sector) { \
- s = sector % sectors + 1; \
- sector /= sectors; \
- h = sector % heads; \
- sector /= heads; \
- c = sector & 0xff; \
- s |= (sector >> 2) & 0xc0; \
- }
-
-
-static int32_t get_start_sect(const struct partition *p);
-static int32_t get_nr_sects(const struct partition *p);
+static unsigned get_start_sect(const struct partition *p);
+static unsigned get_nr_sects(const struct partition *p);
/*
* per partition table entry data
* Each logical partition table entry has two pointers, one for the
* partition and one link to the next one.
*/
-static struct pte {
+struct pte {
struct partition *part_table; /* points into sectorbuffer */
struct partition *ext_pointer; /* points into sectorbuffer */
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+ ullong offset; /* disk sector number */
+ char *sectorbuffer; /* disk sector contents */
+#if ENABLE_FEATURE_FDISK_WRITABLE
char changed; /* boolean */
#endif
- off_t offset; /* disk sector number */
- char *sectorbuffer; /* disk sector contents */
-} ptes[MAXIMUM_PARTS];
+};
+
+/* DOS partition types */
+
+static const char *const i386_sys_types[] = {
+ "\x00" "Empty",
+ "\x01" "FAT12",
+ "\x04" "FAT16 <32M",
+ "\x05" "Extended", /* DOS 3.3+ extended partition */
+ "\x06" "FAT16", /* DOS 16-bit >=32M */
+ "\x07" "HPFS/NTFS", /* OS/2 IFS, eg, HPFS or NTFS or QNX */
+ "\x0a" "OS/2 Boot Manager",/* OS/2 Boot Manager */
+ "\x0b" "Win95 FAT32",
+ "\x0c" "Win95 FAT32 (LBA)",/* LBA really is 'Extended Int 13h' */
+ "\x0e" "Win95 FAT16 (LBA)",
+ "\x0f" "Win95 Ext'd (LBA)",
+ "\x11" "Hidden FAT12",
+ "\x12" "Compaq diagnostics",
+ "\x14" "Hidden FAT16 <32M",
+ "\x16" "Hidden FAT16",
+ "\x17" "Hidden HPFS/NTFS",
+ "\x1b" "Hidden Win95 FAT32",
+ "\x1c" "Hidden W95 FAT32 (LBA)",
+ "\x1e" "Hidden W95 FAT16 (LBA)",
+ "\x3c" "Part.Magic recovery",
+ "\x41" "PPC PReP Boot",
+ "\x42" "SFS",
+ "\x63" "GNU HURD or SysV", /* GNU HURD or Mach or Sys V/386 (such as ISC UNIX) */
+ "\x80" "Old Minix", /* Minix 1.4a and earlier */
+ "\x81" "Minix / old Linux",/* Minix 1.4b and later */
+ "\x82" "Linux swap", /* also Solaris */
+ "\x83" "Linux",
+ "\x84" "OS/2 hidden C: drive",
+ "\x85" "Linux extended",
+ "\x86" "NTFS volume set",
+ "\x87" "NTFS volume set",
+ "\x8e" "Linux LVM",
+ "\x9f" "BSD/OS", /* BSDI */
+ "\xa0" "Thinkpad hibernation",
+ "\xa5" "FreeBSD", /* various BSD flavours */
+ "\xa6" "OpenBSD",
+ "\xa8" "Darwin UFS",
+ "\xa9" "NetBSD",
+ "\xab" "Darwin boot",
+ "\xb7" "BSDI fs",
+ "\xb8" "BSDI swap",
+ "\xbe" "Solaris boot",
+ "\xeb" "BeOS fs",
+ "\xee" "EFI GPT", /* Intel EFI GUID Partition Table */
+ "\xef" "EFI (FAT-12/16/32)", /* Intel EFI System Partition */
+ "\xf0" "Linux/PA-RISC boot", /* Linux/PA-RISC boot loader */
+ "\xf2" "DOS secondary", /* DOS 3.3+ secondary */
+ "\xfd" "Linux raid autodetect", /* New (2.2.x) raid partition with
+ autodetect using persistent
+ superblock */
+#if 0 /* ENABLE_WEIRD_PARTITION_TYPES */
+ "\x02" "XENIX root",
+ "\x03" "XENIX usr",
+ "\x08" "AIX", /* AIX boot (AIX -- PS/2 port) or SplitDrive */
+ "\x09" "AIX bootable", /* AIX data or Coherent */
+ "\x10" "OPUS",
+ "\x18" "AST SmartSleep",
+ "\x24" "NEC DOS",
+ "\x39" "Plan 9",
+ "\x40" "Venix 80286",
+ "\x4d" "QNX4.x",
+ "\x4e" "QNX4.x 2nd part",
+ "\x4f" "QNX4.x 3rd part",
+ "\x50" "OnTrack DM",
+ "\x51" "OnTrack DM6 Aux1", /* (or Novell) */
+ "\x52" "CP/M", /* CP/M or Microport SysV/AT */
+ "\x53" "OnTrack DM6 Aux3",
+ "\x54" "OnTrackDM6",
+ "\x55" "EZ-Drive",
+ "\x56" "Golden Bow",
+ "\x5c" "Priam Edisk",
+ "\x61" "SpeedStor",
+ "\x64" "Novell Netware 286",
+ "\x65" "Novell Netware 386",
+ "\x70" "DiskSecure Multi-Boot",
+ "\x75" "PC/IX",
+ "\x93" "Amoeba",
+ "\x94" "Amoeba BBT", /* (bad block table) */
+ "\xa7" "NeXTSTEP",
+ "\xbb" "Boot Wizard hidden",
+ "\xc1" "DRDOS/sec (FAT-12)",
+ "\xc4" "DRDOS/sec (FAT-16 < 32M)",
+ "\xc6" "DRDOS/sec (FAT-16)",
+ "\xc7" "Syrinx",
+ "\xda" "Non-FS data",
+ "\xdb" "CP/M / CTOS / ...",/* CP/M or Concurrent CP/M or
+ Concurrent DOS or CTOS */
+ "\xde" "Dell Utility", /* Dell PowerEdge Server utilities */
+ "\xdf" "BootIt", /* BootIt EMBRM */
+ "\xe1" "DOS access", /* DOS access or SpeedStor 12-bit FAT
+ extended partition */
+ "\xe3" "DOS R/O", /* DOS R/O or SpeedStor */
+ "\xe4" "SpeedStor", /* SpeedStor 16-bit FAT extended
+ partition < 1024 cyl. */
+ "\xf1" "SpeedStor",
+ "\xf4" "SpeedStor", /* SpeedStor large partition */
+ "\xfe" "LANstep", /* SpeedStor >1024 cyl. or LANstep */
+ "\xff" "BBT", /* Xenix Bad Block Table */
+#endif
+ NULL
+};
+
+
+/* Globals */
+
+struct globals {
+ char *line_ptr;
+ char line_buffer[80];
+ char partname_buffer[80];
+ jmp_buf listingbuf;
+ /* Raw disk label. For DOS-type partition tables the MBR,
+ * with descriptions of the primary partitions. */
+ char MBRbuffer[MAX_SECTOR_SIZE];
+ /* Partition tables */
+ struct pte ptes[MAXIMUM_PARTS];
+};
+/* bb_common_bufsiz1 is too small for this on 64 bit CPUs */
+#define G (*ptr_to_globals)
+
+#define line_ptr (G.line_ptr)
+#define listingbuf (G.listingbuf)
+#define line_buffer (G.line_buffer)
+#define partname_buffer (G.partname_buffer)
+#define MBRbuffer (G.MBRbuffer)
+#define ptes (G.ptes)
+
+
+/* Code */
+#define IS_EXTENDED(i) \
+ ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
+
+#define cround(n) (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
+
+#define scround(x) (((x)+units_per_sector-1)/units_per_sector)
+
+#define pt_offset(b, n) \
+ ((struct partition *)((b) + 0x1be + (n) * sizeof(struct partition)))
+
+#define sector(s) ((s) & 0x3f)
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#define cylinder(s, c) ((c) | (((s) & 0xc0) << 2))
+
+#define hsc2sector(h,s,c) \
+ (sector(s) - 1 + sectors * ((h) + heads * cylinder(s,c)))
+
+#define set_hsc(h,s,c,sector) \
+ do { \
+ s = sector % sectors + 1; \
+ sector /= sectors; \
+ h = sector % heads; \
+ sector /= heads; \
+ c = sector & 0xff; \
+ s |= (sector >> 2) & 0xc0; \
+ } while (0)
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
+/* read line; return 0 or first printable char */
+static int
+read_line(const char *prompt)
+{
+ int sz;
+
+ sz = read_line_input(prompt, line_buffer, sizeof(line_buffer), NULL);
+ if (sz <= 0)
+ exit(0); /* Ctrl-D or Ctrl-C */
+
+ if (line_buffer[sz-1] == '\n')
+ line_buffer[--sz] = '\0';
+
+ line_ptr = line_buffer;
+ while (*line_ptr && !isgraph(*line_ptr))
+ line_ptr++;
+ return *line_ptr;
+}
+#endif
+
+/*
+ * return partition name - uses static storage
+ */
+static const char *
+partname(const char *dev, int pno, int lth)
+{
+ const char *p;
+ int w, wp;
+ int bufsiz;
+ char *bufp;
+
+ bufp = partname_buffer;
+ bufsiz = sizeof(partname_buffer);
+
+ w = strlen(dev);
+ p = "";
+
+ if (isdigit(dev[w-1]))
+ p = "p";
+
+ /* devfs kludge - note: fdisk partition names are not supposed
+ to equal kernel names, so there is no reason to do this */
+ if (strcmp(dev + w - 4, "disc") == 0) {
+ w -= 4;
+ p = "part";
+ }
+
+ wp = strlen(p);
+
+ if (lth) {
+ snprintf(bufp, bufsiz, "%*.*s%s%-2u",
+ lth-wp-2, w, dev, p, pno);
+ } else {
+ snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
+ }
+ return bufp;
+}
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
set_all_unchanged(void)
{
ptes[i].changed = 0;
}
-static void
+static ALWAYS_INLINE void
set_changed(int i)
{
ptes[i].changed = 1;
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
-static inline struct partition *
+static ALWAYS_INLINE struct partition *
get_part_table(int i)
{
return ptes[i].part_table;
str_units(int n)
{ /* n==1: use singular */
if (n == 1)
- return display_in_cyl_units ? _("cylinder") : _("sector");
- else
- return display_in_cyl_units ? _("cylinders") : _("sectors");
+ return display_in_cyl_units ? "cylinder" : "sector";
+ return display_in_cyl_units ? "cylinders" : "sectors";
}
static int
valid_part_table_flag(const char *mbuffer)
{
- const unsigned char *b = (const unsigned char *)mbuffer;
- return (b[510] == 0x55 && b[511] == 0xaa);
+ return (mbuffer[510] == 0x55 && (uint8_t)mbuffer[511] == 0xaa);
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static char line_buffer[LINE_LENGTH];
-static char *line_ptr;
-
-/* read line; return 0 or first char */
-static int
-read_line(void)
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static ALWAYS_INLINE void
+write_part_table_flag(char *b)
{
- fflush(stdout); /* requested by niles@scyld.com */
- line_ptr = line_buffer;
- if (!fgets(line_buffer, LINE_LENGTH, stdin)) {
- /* error or eof */
- bb_error_msg_and_die("\ngot EOF - exiting...");
- }
- while (*line_ptr && !isgraph(*line_ptr))
- line_ptr++;
- return *line_ptr;
+ b[510] = 0x55;
+ b[511] = 0xaa;
}
static char
read_nonempty(const char *mesg)
{
- do {
- fputs(mesg, stdout);
- } while (!read_line());
+ while (!read_line(mesg)) /* repeat */;
return *line_ptr;
}
static char
read_maybe_empty(const char *mesg)
{
- fputs(mesg, stdout);
- if (!read_line()) {
+ if (!read_line(mesg)) {
line_ptr = line_buffer;
- *line_ptr = '\n';
- line_ptr[1] = 0;
+ line_ptr[0] = '\n';
+ line_ptr[1] = '\0';
}
- return *line_ptr;
+ return line_ptr[0];
}
static int
-read_hex(const struct systypes *sys)
+read_hex(const char *const *sys)
{
+ unsigned long v;
while (1) {
- read_nonempty(_("Hex code (type L to list codes): "));
- if (*line_ptr == 'l' || *line_ptr == 'L')
+ read_nonempty("Hex code (type L to list codes): ");
+ if (*line_ptr == 'l' || *line_ptr == 'L') {
list_types(sys);
- else if (isxdigit(*line_ptr)) {
- return strtoul(line_ptr, NULL, 16);
+ continue;
}
+ v = bb_strtoul(line_ptr, NULL, 16);
+ if (v > 0xff)
+ /* Bad input also triggers this */
+ continue;
+ return v;
}
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-
-static const struct systypes sgi_sys_types[];
-static unsigned int sgi_get_num_sectors(int i);
-static int sgi_get_sysid(int i);
-static void sgi_delete_partition(int i);
-static void sgi_change_sysid(int i, int sys);
-static void sgi_list_table(int xtra);
-static void sgi_set_xcyl(void);
-static int verify_sgi(int verbose);
-static void sgi_add_partition(int n, int sys);
-static void sgi_set_swappartition(int i);
-static const char *sgi_get_bootfile(void);
-static void sgi_set_bootfile(const char* aFile);
-static void create_sgiinfo(void);
-static void sgi_write_table(void);
-static void sgi_set_bootpartition(int i);
+#endif /* FEATURE_FDISK_WRITABLE */
+
#include "fdisk_aix.c"
typedef struct {
unsigned short csum; /* Label xor'd checksum */
} sun_partition;
#define sunlabel ((sun_partition *)MBRbuffer)
-#define SUNOS_SWAP 3
-#define SUN_WHOLE_DISK 5
-static void bselect(void);
-static void xbsd_print_disklabel(int);
+STATIC_OSF void bsd_select(void);
+STATIC_OSF void xbsd_print_disklabel(int);
#include "fdisk_osf.c"
-#define SGI_VOLHDR 0x00
-/* 1 and 2 were used for drive types no longer supported by SGI */
-#define SGI_SWAP 0x03
-/* 4 and 5 were for filesystem types SGI haven't ever supported on MIPS CPUs */
-#define SGI_VOLUME 0x06
-#define SGI_EFS 0x07
-#define SGI_LVOL 0x08
-#define SGI_RLVOL 0x09
-#define SGI_XFS 0x0a
-#define SGI_XFSLOG 0x0b
-#define SGI_XLV 0x0c
-#define SGI_XVM 0x0d
-#define SGI_ENTIRE_DISK SGI_VOLUME
-#if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL)
-static unsigned short
-__swap16(unsigned short x)
-{
- return (((uint16_t)(x) & 0xFF) << 8) | (((uint16_t)(x) & 0xFF00) >> 8);
+#if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL
+static uint16_t
+fdisk_swap16(uint16_t x)
+{
+ return (x << 8) | (x >> 8);
}
static uint32_t
-__swap32(uint32_t x)
+fdisk_swap32(uint32_t x)
{
- return (((x & 0xFF) << 24) |
- ((x & 0xFF00) << 8) |
- ((x & 0xFF0000) >> 8) |
- ((x & 0xFF000000) >> 24));
+ return (x << 24) |
+ ((x & 0xFF00) << 8) |
+ ((x & 0xFF0000) >> 8) |
+ (x >> 24);
}
#endif
+STATIC_SGI const char *const sgi_sys_types[];
+STATIC_SGI unsigned sgi_get_num_sectors(int i);
+STATIC_SGI int sgi_get_sysid(int i);
+STATIC_SGI void sgi_delete_partition(int i);
+STATIC_SGI void sgi_change_sysid(int i, int sys);
+STATIC_SGI void sgi_list_table(int xtra);
+#if ENABLE_FEATURE_FDISK_ADVANCED
+STATIC_SGI void sgi_set_xcyl(void);
+#endif
+STATIC_SGI int verify_sgi(int verbose);
+STATIC_SGI void sgi_add_partition(int n, int sys);
+STATIC_SGI void sgi_set_swappartition(int i);
+STATIC_SGI const char *sgi_get_bootfile(void);
+STATIC_SGI void sgi_set_bootfile(const char* aFile);
+STATIC_SGI void create_sgiinfo(void);
+STATIC_SGI void sgi_write_table(void);
+STATIC_SGI void sgi_set_bootpartition(int i);
#include "fdisk_sgi.c"
-static const struct systypes sun_sys_types[];
-static void sun_delete_partition(int i);
-static void sun_change_sysid(int i, int sys);
-static void sun_list_table(int xtra);
-static void sun_set_xcyl(void);
-static void add_sun_partition(int n, int sys);
-static void sun_set_alt_cyl(void);
-static void sun_set_ncyl(int cyl);
-static void sun_set_xcyl(void);
-static void sun_set_ilfact(void);
-static void sun_set_rspeed(void);
-static void sun_set_pcylcount(void);
-static void toggle_sunflags(int i, unsigned char mask);
-static void verify_sun(void);
-static void sun_write_table(void);
-#include "fdisk_sun.c"
-
-/* DOS partition types */
-
-static const struct systypes i386_sys_types[] = {
- { "\x00" "Empty" },
- { "\x01" "FAT12" },
- { "\x04" "FAT16 <32M" },
- { "\x05" "Extended" }, /* DOS 3.3+ extended partition */
- { "\x06" "FAT16" }, /* DOS 16-bit >=32M */
- { "\x07" "HPFS/NTFS" }, /* OS/2 IFS, eg, HPFS or NTFS or QNX */
- { "\x0a" "OS/2 Boot Manager" },/* OS/2 Boot Manager */
- { "\x0b" "Win95 FAT32" },
- { "\x0c" "Win95 FAT32 (LBA)" },/* LBA really is `Extended Int 13h' */
- { "\x0e" "Win95 FAT16 (LBA)" },
- { "\x0f" "Win95 Ext'd (LBA)" },
- { "\x11" "Hidden FAT12" },
- { "\x12" "Compaq diagnostics" },
- { "\x14" "Hidden FAT16 <32M" },
- { "\x16" "Hidden FAT16" },
- { "\x17" "Hidden HPFS/NTFS" },
- { "\x1b" "Hidden Win95 FAT32" },
- { "\x1c" "Hidden Win95 FAT32 (LBA)" },
- { "\x1e" "Hidden Win95 FAT16 (LBA)" },
- { "\x3c" "PartitionMagic recovery" },
- { "\x41" "PPC PReP Boot" },
- { "\x42" "SFS" },
- { "\x63" "GNU HURD or SysV" }, /* GNU HURD or Mach or Sys V/386 (such as ISC UNIX) */
- { "\x80" "Old Minix" }, /* Minix 1.4a and earlier */
- { "\x81" "Minix / old Linux" },/* Minix 1.4b and later */
- { "\x82" "Linux swap" }, /* also Solaris */
- { "\x83" "Linux" },
- { "\x84" "OS/2 hidden C: drive" },
- { "\x85" "Linux extended" },
- { "\x86" "NTFS volume set" },
- { "\x87" "NTFS volume set" },
- { "\x8e" "Linux LVM" },
- { "\x9f" "BSD/OS" }, /* BSDI */
- { "\xa0" "IBM Thinkpad hibernation" },
- { "\xa5" "FreeBSD" }, /* various BSD flavours */
- { "\xa6" "OpenBSD" },
- { "\xa8" "Darwin UFS" },
- { "\xa9" "NetBSD" },
- { "\xab" "Darwin boot" },
- { "\xb7" "BSDI fs" },
- { "\xb8" "BSDI swap" },
- { "\xbe" "Solaris boot" },
- { "\xeb" "BeOS fs" },
- { "\xee" "EFI GPT" }, /* Intel EFI GUID Partition Table */
- { "\xef" "EFI (FAT-12/16/32)" },/* Intel EFI System Partition */
- { "\xf0" "Linux/PA-RISC boot" },/* Linux/PA-RISC boot loader */
- { "\xf2" "DOS secondary" }, /* DOS 3.3+ secondary */
- { "\xfd" "Linux raid autodetect" },/* New (2.2.x) raid partition with
- autodetect using persistent
- superblock */
-#ifdef CONFIG_WEIRD_PARTITION_TYPES
- { "\x02" "XENIX root" },
- { "\x03" "XENIX usr" },
- { "\x08" "AIX" }, /* AIX boot (AIX -- PS/2 port) or SplitDrive */
- { "\x09" "AIX bootable" }, /* AIX data or Coherent */
- { "\x10" "OPUS" },
- { "\x18" "AST SmartSleep" },
- { "\x24" "NEC DOS" },
- { "\x39" "Plan 9" },
- { "\x40" "Venix 80286" },
- { "\x4d" "QNX4.x" },
- { "\x4e" "QNX4.x 2nd part" },
- { "\x4f" "QNX4.x 3rd part" },
- { "\x50" "OnTrack DM" },
- { "\x51" "OnTrack DM6 Aux1" }, /* (or Novell) */
- { "\x52" "CP/M" }, /* CP/M or Microport SysV/AT */
- { "\x53" "OnTrack DM6 Aux3" },
- { "\x54" "OnTrackDM6" },
- { "\x55" "EZ-Drive" },
- { "\x56" "Golden Bow" },
- { "\x5c" "Priam Edisk" },
- { "\x61" "SpeedStor" },
- { "\x64" "Novell Netware 286" },
- { "\x65" "Novell Netware 386" },
- { "\x70" "DiskSecure Multi-Boot" },
- { "\x75" "PC/IX" },
- { "\x93" "Amoeba" },
- { "\x94" "Amoeba BBT" }, /* (bad block table) */
- { "\xa7" "NeXTSTEP" },
- { "\xbb" "Boot Wizard hidden" },
- { "\xc1" "DRDOS/sec (FAT-12)" },
- { "\xc4" "DRDOS/sec (FAT-16 < 32M)" },
- { "\xc6" "DRDOS/sec (FAT-16)" },
- { "\xc7" "Syrinx" },
- { "\xda" "Non-FS data" },
- { "\xdb" "CP/M / CTOS / ..." },/* CP/M or Concurrent CP/M or
- Concurrent DOS or CTOS */
- { "\xde" "Dell Utility" }, /* Dell PowerEdge Server utilities */
- { "\xdf" "BootIt" }, /* BootIt EMBRM */
- { "\xe1" "DOS access" }, /* DOS access or SpeedStor 12-bit FAT
- extended partition */
- { "\xe3" "DOS R/O" }, /* DOS R/O or SpeedStor */
- { "\xe4" "SpeedStor" }, /* SpeedStor 16-bit FAT extended
- partition < 1024 cyl. */
- { "\xf1" "SpeedStor" },
- { "\xf4" "SpeedStor" }, /* SpeedStor large partition */
- { "\xfe" "LANstep" }, /* SpeedStor >1024 cyl. or LANstep */
- { "\xff" "BBT" }, /* Xenix Bad Block Table */
+STATIC_SUN const char *const sun_sys_types[];
+STATIC_SUN void sun_delete_partition(int i);
+STATIC_SUN void sun_change_sysid(int i, int sys);
+STATIC_SUN void sun_list_table(int xtra);
+STATIC_SUN void add_sun_partition(int n, int sys);
+#if ENABLE_FEATURE_FDISK_ADVANCED
+STATIC_SUN void sun_set_alt_cyl(void);
+STATIC_SUN void sun_set_ncyl(int cyl);
+STATIC_SUN void sun_set_xcyl(void);
+STATIC_SUN void sun_set_ilfact(void);
+STATIC_SUN void sun_set_rspeed(void);
+STATIC_SUN void sun_set_pcylcount(void);
#endif
- { 0 }
-};
-
-
-
-/* A valid partition table sector ends in 0x55 0xaa */
-static unsigned int
-part_table_flag(const char *b)
-{
- return ((uint) b[510]) + (((uint) b[511]) << 8);
-}
-
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static void
-write_part_table_flag(char *b)
-{
- b[510] = 0x55;
- b[511] = 0xaa;
-}
+STATIC_SUN void toggle_sunflags(int i, unsigned char mask);
+STATIC_SUN void verify_sun(void);
+STATIC_SUN void sun_write_table(void);
+#include "fdisk_sun.c"
+#if ENABLE_FEATURE_FDISK_WRITABLE
/* start_sect and nr_sects are stored little endian on all machines */
/* moreover, they are not aligned correctly */
static void
-store4_little_endian(unsigned char *cp, unsigned int val)
+store4_little_endian(unsigned char *cp, unsigned val)
{
- cp[0] = (val & 0xff);
- cp[1] = ((val >> 8) & 0xff);
- cp[2] = ((val >> 16) & 0xff);
- cp[3] = ((val >> 24) & 0xff);
+ cp[0] = val;
+ cp[1] = val >> 8;
+ cp[2] = val >> 16;
+ cp[3] = val >> 24;
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
-static unsigned int
+static unsigned
read4_little_endian(const unsigned char *cp)
{
- return (uint)(cp[0]) + ((uint)(cp[1]) << 8)
- + ((uint)(cp[2]) << 16) + ((uint)(cp[3]) << 24);
+ return cp[0] + (cp[1] << 8) + (cp[2] << 16) + (cp[3] << 24);
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
-set_start_sect(struct partition *p, unsigned int start_sect)
+set_start_sect(struct partition *p, unsigned start_sect)
{
store4_little_endian(p->start4, start_sect);
}
#endif
-static int32_t
+static unsigned
get_start_sect(const struct partition *p)
{
return read4_little_endian(p->start4);
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
-set_nr_sects(struct partition *p, int32_t nr_sects)
+set_nr_sects(struct partition *p, unsigned nr_sects)
{
store4_little_endian(p->size4, nr_sects);
}
#endif
-static int32_t
+static unsigned
get_nr_sects(const struct partition *p)
{
return read4_little_endian(p->size4);
/* normally O_RDWR, -l option gives O_RDONLY */
static int type_open = O_RDWR;
-
static int ext_index; /* the prime extended partition */
-static int listing; /* no aborts for fdisk -l */
+static int listing; /* no aborts for fdisk -l */
static int dos_compatible_flag = ~0;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static int dos_changed;
static int nowarn; /* no warnings for fdisk -l/-s */
#endif
+static unsigned user_cylinders, user_heads, user_sectors;
+static unsigned pt_heads, pt_sectors;
+static unsigned kern_heads, kern_sectors;
+static ullong extended_offset; /* offset of link pointers */
+static ullong total_number_of_sectors;
-static uint user_cylinders, user_heads, user_sectors;
-static uint pt_heads, pt_sectors;
-static uint kern_heads, kern_sectors;
-
-static off_t extended_offset; /* offset of link pointers */
-
-static unsigned long long total_number_of_sectors;
-
-
-static jmp_buf listingbuf;
-
-static void fdisk_fatal(enum failure why)
+static void fdisk_fatal(const char *why)
{
- const char *message;
-
if (listing) {
close(fd);
longjmp(listingbuf, 1);
}
-
- switch (why) {
- case unable_to_open:
- message = "\nUnable to open %s";
- break;
- case unable_to_read:
- message = "\nUnable to read %s";
- break;
- case unable_to_seek:
- message = "\nUnable to seek on %s";
- break;
- case unable_to_write:
- message = "\nUnable to write %s";
- break;
- case ioctl_error:
- message = "\nBLKGETSIZE ioctl failed on %s";
- break;
- default:
- message = "\nFatal error";
- }
-
- bb_error_msg_and_die(message, disk_device);
+ bb_error_msg_and_die(why, disk_device);
}
static void
-seek_sector(off_t secno)
+seek_sector(ullong secno)
{
- off_t offset = secno * sector_size;
- if (lseek(fd, offset, SEEK_SET) == (off_t) -1)
+ secno *= sector_size;
+ if (lseek64(fd, (off64_t)secno, SEEK_SET) == (off64_t) -1)
fdisk_fatal(unable_to_seek);
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
-write_sector(off_t secno, char *buf)
+write_sector(ullong secno, char *buf)
{
seek_sector(secno);
if (write(fd, buf, sector_size) != sector_size)
/* Allocate a buffer and read a partition table sector */
static void
-read_pte(struct pte *pe, off_t offset)
+read_pte(struct pte *pe, ullong offset)
{
pe->offset = offset;
- pe->sectorbuffer = (char *) xmalloc(sector_size);
+ pe->sectorbuffer = xmalloc(sector_size);
seek_sector(offset);
if (read(fd, pe->sectorbuffer, sector_size) != sector_size)
fdisk_fatal(unable_to_read);
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
pe->changed = 0;
#endif
pe->part_table = pe->ext_pointer = NULL;
}
-static unsigned int
+static unsigned
get_partition_start(const struct pte *pe)
{
return pe->offset + get_start_sect(pe->part_table);
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
/*
* Avoid warning about DOS partitions when no DOS partition was changed.
* Here a heuristic "is probably dos partition".
static void
menu(void)
{
+ puts("Command Action");
if (LABEL_IS_SUN) {
- puts(_("Command action"));
- puts(_("\ta\ttoggle a read only flag")); /* sun */
- puts(_("\tb\tedit bsd disklabel"));
- puts(_("\tc\ttoggle the mountable flag")); /* sun */
- puts(_("\td\tdelete a partition"));
- puts(_("\tl\tlist known partition types"));
- puts(_("\tm\tprint this menu"));
- puts(_("\tn\tadd a new partition"));
- puts(_("\to\tcreate a new empty DOS partition table"));
- puts(_("\tp\tprint the partition table"));
- puts(_("\tq\tquit without saving changes"));
- puts(_("\ts\tcreate a new empty Sun disklabel")); /* sun */
- puts(_("\tt\tchange a partition's system id"));
- puts(_("\tu\tchange display/entry units"));
- puts(_("\tv\tverify the partition table"));
- puts(_("\tw\twrite table to disk and exit"));
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
- puts(_("\tx\textra functionality (experts only)"));
+ puts("a\ttoggle a read only flag"); /* sun */
+ puts("b\tedit bsd disklabel");
+ puts("c\ttoggle the mountable flag"); /* sun */
+ puts("d\tdelete a partition");
+ puts("l\tlist known partition types");
+ puts("n\tadd a new partition");
+ 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 */
+ puts("t\tchange a partition's system id");
+ puts("u\tchange display/entry units");
+ puts("v\tverify the partition table");
+ puts("w\twrite table to disk and exit");
+#if ENABLE_FEATURE_FDISK_ADVANCED
+ puts("x\textra functionality (experts only)");
#endif
- } else
- if (LABEL_IS_SGI) {
- puts(_("Command action"));
- puts(_("\ta\tselect bootable partition")); /* sgi flavour */
- puts(_("\tb\tedit bootfile entry")); /* sgi */
- puts(_("\tc\tselect sgi swap partition")); /* sgi flavour */
- puts(_("\td\tdelete a partition"));
- puts(_("\tl\tlist known partition types"));
- puts(_("\tm\tprint this menu"));
- puts(_("\tn\tadd a new partition"));
- puts(_("\to\tcreate a new empty DOS partition table"));
- puts(_("\tp\tprint the partition table"));
- puts(_("\tq\tquit without saving changes"));
- puts(_("\ts\tcreate a new empty Sun disklabel")); /* sun */
- puts(_("\tt\tchange a partition's system id"));
- puts(_("\tu\tchange display/entry units"));
- puts(_("\tv\tverify the partition table"));
- puts(_("\tw\twrite table to disk and exit"));
- } else
- if (LABEL_IS_AIX) {
- puts(_("Command action"));
- puts(_("\tm\tprint this menu"));
- puts(_("\to\tcreate a new empty DOS partition table"));
- puts(_("\tq\tquit without saving changes"));
- puts(_("\ts\tcreate a new empty Sun disklabel")); /* sun */
- } else
- {
- puts(_("Command action"));
- puts(_("\ta\ttoggle a bootable flag"));
- puts(_("\tb\tedit bsd disklabel"));
- puts(_("\tc\ttoggle the dos compatibility flag"));
- puts(_("\td\tdelete a partition"));
- puts(_("\tl\tlist known partition types"));
- puts(_("\tm\tprint this menu"));
- puts(_("\tn\tadd a new partition"));
- puts(_("\to\tcreate a new empty DOS partition table"));
- puts(_("\tp\tprint the partition table"));
- puts(_("\tq\tquit without saving changes"));
- puts(_("\ts\tcreate a new empty Sun disklabel")); /* sun */
- puts(_("\tt\tchange a partition's system id"));
- puts(_("\tu\tchange display/entry units"));
- puts(_("\tv\tverify the partition table"));
- puts(_("\tw\twrite table to disk and exit"));
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
- puts(_("\tx\textra functionality (experts only)"));
+ } else if (LABEL_IS_SGI) {
+ puts("a\tselect bootable partition"); /* sgi flavour */
+ puts("b\tedit bootfile entry"); /* sgi */
+ puts("c\tselect sgi swap partition"); /* sgi flavour */
+ puts("d\tdelete a partition");
+ puts("l\tlist known partition types");
+ puts("n\tadd a new partition");
+ 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 */
+ puts("t\tchange a partition's system id");
+ puts("u\tchange display/entry units");
+ puts("v\tverify the partition table");
+ puts("w\twrite table to disk and exit");
+ } else if (LABEL_IS_AIX) {
+ 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 {
+ puts("a\ttoggle a bootable flag");
+ puts("b\tedit bsd disklabel");
+ puts("c\ttoggle the dos compatibility flag");
+ puts("d\tdelete a partition");
+ puts("l\tlist known partition types");
+ puts("n\tadd a new partition");
+ 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 */
+ puts("t\tchange a partition's system id");
+ puts("u\tchange display/entry units");
+ puts("v\tverify the partition table");
+ puts("w\twrite table to disk and exit");
+#if ENABLE_FEATURE_FDISK_ADVANCED
+ puts("x\textra functionality (experts only)");
#endif
}
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED
static void
xmenu(void)
{
+ puts("Command Action");
if (LABEL_IS_SUN) {
- puts(_("Command action"));
- puts(_("\ta\tchange number of alternate cylinders")); /*sun*/
- puts(_("\tc\tchange number of cylinders"));
- puts(_("\td\tprint the raw data in the partition table"));
- puts(_("\te\tchange number of extra sectors per cylinder"));/*sun*/
- puts(_("\th\tchange number of heads"));
- puts(_("\ti\tchange interleave factor")); /*sun*/
- puts(_("\to\tchange rotation speed (rpm)")); /*sun*/
- puts(_("\tm\tprint this menu"));
- puts(_("\tp\tprint the partition table"));
- puts(_("\tq\tquit without saving changes"));
- puts(_("\tr\treturn to main menu"));
- puts(_("\ts\tchange number of sectors/track"));
- puts(_("\tv\tverify the partition table"));
- puts(_("\tw\twrite table to disk and exit"));
- puts(_("\ty\tchange number of physical cylinders")); /*sun*/
- } else
- if (LABEL_IS_SGI) {
- puts(_("Command action"));
- puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
- puts(_("\tc\tchange number of cylinders"));
- puts(_("\td\tprint the raw data in the partition table"));
- puts(_("\te\tlist extended partitions")); /* !sun */
- puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
- puts(_("\th\tchange number of heads"));
- puts(_("\tm\tprint this menu"));
- puts(_("\tp\tprint the partition table"));
- puts(_("\tq\tquit without saving changes"));
- puts(_("\tr\treturn to main menu"));
- puts(_("\ts\tchange number of sectors/track"));
- puts(_("\tv\tverify the partition table"));
- puts(_("\tw\twrite table to disk and exit"));
- } else
- if (LABEL_IS_AIX) {
- puts(_("Command action"));
- puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
- puts(_("\tc\tchange number of cylinders"));
- puts(_("\td\tprint the raw data in the partition table"));
- puts(_("\te\tlist extended partitions")); /* !sun */
- puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
- puts(_("\th\tchange number of heads"));
- puts(_("\tm\tprint this menu"));
- puts(_("\tp\tprint the partition table"));
- puts(_("\tq\tquit without saving changes"));
- puts(_("\tr\treturn to main menu"));
- puts(_("\ts\tchange number of sectors/track"));
- puts(_("\tv\tverify the partition table"));
- puts(_("\tw\twrite table to disk and exit"));
- } else {
- puts(_("Command action"));
- puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
- puts(_("\tc\tchange number of cylinders"));
- puts(_("\td\tprint the raw data in the partition table"));
- puts(_("\te\tlist extended partitions")); /* !sun */
- puts(_("\tf\tfix partition order")); /* !sun, !aix, !sgi */
-#ifdef CONFIG_FEATURE_SGI_LABEL
- puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
+ puts("a\tchange number of alternate cylinders"); /*sun*/
+ puts("c\tchange number of cylinders");
+ puts("d\tprint the raw data in the partition table");
+ puts("e\tchange number of extra sectors per cylinder");/*sun*/
+ puts("h\tchange number of heads");
+ puts("i\tchange interleave factor"); /*sun*/
+ puts("o\tchange rotation speed (rpm)"); /*sun*/
+ puts("p\tprint the partition table");
+ puts("q\tquit without saving changes");
+ puts("r\treturn to main menu");
+ puts("s\tchange number of sectors/track");
+ puts("v\tverify the partition table");
+ puts("w\twrite table to disk and exit");
+ puts("y\tchange number of physical cylinders"); /*sun*/
+ } else if (LABEL_IS_SGI) {
+ puts("b\tmove beginning of data in a partition"); /* !sun */
+ puts("c\tchange number of cylinders");
+ puts("d\tprint the raw data in the partition table");
+ puts("e\tlist extended partitions"); /* !sun */
+ puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
+ puts("h\tchange number of heads");
+ puts("p\tprint the partition table");
+ puts("q\tquit without saving changes");
+ puts("r\treturn to main menu");
+ puts("s\tchange number of sectors/track");
+ puts("v\tverify the partition table");
+ puts("w\twrite table to disk and exit");
+ } else if (LABEL_IS_AIX) {
+ puts("b\tmove beginning of data in a partition"); /* !sun */
+ puts("c\tchange number of cylinders");
+ puts("d\tprint the raw data in the partition table");
+ puts("e\tlist extended partitions"); /* !sun */
+ puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
+ puts("h\tchange number of heads");
+ puts("p\tprint the partition table");
+ puts("q\tquit without saving changes");
+ puts("r\treturn to main menu");
+ puts("s\tchange number of sectors/track");
+ puts("v\tverify the partition table");
+ puts("w\twrite table to disk and exit");
+ } else {
+ puts("b\tmove beginning of data in a partition"); /* !sun */
+ puts("c\tchange number of cylinders");
+ puts("d\tprint the raw data in the partition table");
+ puts("e\tlist extended partitions"); /* !sun */
+ puts("f\tfix partition order"); /* !sun, !aix, !sgi */
+#if ENABLE_FEATURE_SGI_LABEL
+ puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
#endif
- puts(_("\th\tchange number of heads"));
- puts(_("\tm\tprint this menu"));
- puts(_("\tp\tprint the partition table"));
- puts(_("\tq\tquit without saving changes"));
- puts(_("\tr\treturn to main menu"));
- puts(_("\ts\tchange number of sectors/track"));
- puts(_("\tv\tverify the partition table"));
- puts(_("\tw\twrite table to disk and exit"));
+ puts("h\tchange number of heads");
+ puts("p\tprint the partition table");
+ puts("q\tquit without saving changes");
+ puts("r\treturn to main menu");
+ puts("s\tchange number of sectors/track");
+ puts("v\tverify the partition table");
+ puts("w\twrite table to disk and exit");
}
}
#endif /* ADVANCED mode */
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static const struct systypes *
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static const char *const *
get_sys_types(void)
{
return (
}
#else
#define get_sys_types() i386_sys_types
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
-static const char *partition_type(unsigned char type)
+static const char *
+partition_type(unsigned char type)
{
int i;
- const struct systypes *types = get_sys_types();
+ const char *const *types = get_sys_types();
- for (i = 0; types[i].name; i++)
- if ((unsigned char )types[i].name[0] == type)
- return types[i].name + 1;
+ for (i = 0; types[i]; i++)
+ if ((unsigned char)types[i][0] == type)
+ return types[i] + 1;
- return _("Unknown");
+ return "Unknown";
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static int
get_sysid(int i)
{
ptes[i].part_table->sys_ind);
}
-void list_types(const struct systypes *sys)
+static void
+list_types(const char *const *sys)
{
- uint last[4], done = 0, next = 0, size;
+ enum { COLS = 3 };
+
+ unsigned last[COLS];
+ unsigned done, next, size;
int i;
- for (i = 0; sys[i].name; i++);
- size = i;
+ for (size = 0; sys[size]; size++) /* */;
- for (i = 3; i >= 0; i--)
- last[3 - i] = done += (size + i - done) / (i + 1);
- i = done = 0;
+ done = 0;
+ for (i = COLS-1; i >= 0; i--) {
+ done += (size + i - done) / (i + 1);
+ last[COLS-1 - i] = done;
+ }
+ i = done = next = 0;
do {
- printf("%c%2x %-15.15s", i ? ' ' : '\n',
- (unsigned char)sys[next].name[0],
- partition_type((unsigned char)sys[next].name[0]));
+ printf("%c%2x %-22.22s", i ? ' ' : '\n',
+ (unsigned char)sys[next][0],
+ sys[next] + 1);
next = last[i++] + done;
- if (i > 3 || next >= last[i]) {
+ if (i >= COLS || next >= last[i]) {
i = 0;
next = ++done;
}
} while (done < last[0]);
putchar('\n');
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
static int
is_cleared_partition(const struct partition *p)
memset(p, 0, sizeof(struct partition));
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
-set_partition(int i, int doext, off_t start, off_t stop, int sysid)
+set_partition(int i, int doext, ullong start, ullong stop, int sysid)
{
struct partition *p;
- off_t offset;
+ ullong offset;
if (doext) {
p = ptes[i].ext_pointer;
}
#endif
-static int
-test_c(const char **m, const char *mesg)
-{
- int val = 0;
- if (!*m)
- printf(_("You must set"));
- else {
- printf(" %s", *m);
- val = 1;
- }
- *m = mesg;
- return val;
-}
-
static int
warn_geometry(void)
{
- const char *m = NULL;
- int prev = 0;
+ if (heads && sectors && cylinders)
+ return 0;
+ printf("Unknown value(s) for:");
if (!heads)
- prev = test_c(&m, _("heads"));
+ printf(" heads");
if (!sectors)
- prev = test_c(&m, _("sectors"));
+ printf(" sectors");
if (!cylinders)
- prev = test_c(&m, _("cylinders"));
- if (!m)
- return 0;
-
- printf("%s%s.\n"
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
- "You can do this from the extra functions menu.\n"
+ printf(" cylinders");
+ printf(
+#if ENABLE_FEATURE_FDISK_WRITABLE
+ " (settable in the extra functions menu)"
#endif
- , prev ? _(" and ") : " ", m);
-
+ "\n");
return 1;
}
-static void update_units(void)
+static void
+update_units(void)
{
int cyl_units = heads * sectors;
units_per_sector = 1; /* in sectors */
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
warn_cylinders(void)
{
if (LABEL_IS_DOS && cylinders > 1024 && !nowarn)
- printf(_("\n"
+ printf("\n"
"The number of cylinders for this disk is set to %d.\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"
"2) booting and partitioning software from other OSs\n"
-" (e.g., DOS FDISK, OS/2 FDISK)\n"),
+" (e.g., DOS FDISK, OS/2 FDISK)\n",
cylinders);
}
#endif
p = pex->part_table;
if (!get_start_sect(p)) {
- printf(_("Bad offset in primary extended partition\n"));
+ printf("Bad offset in primary extended partition\n");
return;
}
if (partitions >= MAXIMUM_PARTS) {
/* This is not a Linux restriction, but
this program uses arrays of size MAXIMUM_PARTS.
- Do not try to `improve' this test. */
+ Do not try to 'improve' this test. */
struct pte *pre = &ptes[partitions-1];
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
- printf(_("Warning: deleting partitions after %d\n"),
+#if ENABLE_FEATURE_FDISK_WRITABLE
+ printf("Warning: deleting partitions after %d\n",
partitions);
pre->changed = 1;
#endif
for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) {
if (IS_EXTENDED(p->sys_ind)) {
if (pe->ext_pointer)
- printf(_("Warning: extra link "
+ printf("Warning: extra link "
"pointer in partition table"
- " %d\n"), partitions + 1);
+ " %d\n", partitions + 1);
else
pe->ext_pointer = p;
} else if (p->sys_ind) {
if (pe->part_table)
- printf(_("Warning: ignoring extra "
+ printf("Warning: ignoring extra "
"data in partition table"
- " %d\n"), partitions + 1);
+ " %d\n", partitions + 1);
else
pe->part_table = p;
}
partitions++;
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
/* remove empty links */
remove:
for (i = 4; i < partitions; i++) {
struct pte *pe = &ptes[i];
- if (!get_nr_sects(pe->part_table) &&
- (partitions > 5 || ptes[4].part_table->sys_ind)) {
- printf("omitting empty partition (%d)\n", i+1);
+ if (!get_nr_sects(pe->part_table)
+ && (partitions > 5 || ptes[4].part_table->sys_ind)
+ ) {
+ printf("Omitting empty partition (%d)\n", i+1);
delete_partition(i);
goto remove; /* numbering changed */
}
#endif
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
create_doslabel(void)
{
int i;
- printf(
- _("Building a new DOS disklabel. Changes will remain in memory only,\n"
- "until you decide to write them. After that, of course, the previous\n"
- "content won't be recoverable.\n\n"));
+ printf(msg_building_new_label, "DOS disklabel");
current_label_type = label_dos;
-#ifdef CONFIG_FEATURE_OSF_LABEL
+#if ENABLE_FEATURE_OSF_LABEL
possibly_osf_label = 0;
#endif
partitions = 4;
set_changed(0);
get_boot(create_empty_dos);
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
static void
get_sectorsize(void)
if (ioctl(fd, BLKSSZGET, &arg) == 0)
sector_size = arg;
if (sector_size != DEFAULT_SECTOR_SIZE)
- printf(_("Note: sector size is %d (not %d)\n"),
+ printf("Note: sector size is %d (not %d)\n",
sector_size, DEFAULT_SECTOR_SIZE);
}
}
get_geometry(void)
{
int sec_fac;
- unsigned long long bytes; /* really u64 */
+ uint64_t v64;
get_sectorsize();
sec_fac = sector_size / 512;
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
guess_device_type();
#endif
heads = cylinders = sectors = 0;
sectors = user_sectors ? user_sectors :
pt_sectors ? pt_sectors :
kern_sectors ? kern_sectors : 63;
- if (ioctl(fd, BLKGETSIZE64, &bytes) == 0) {
- /* got bytes */
+ if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
+ /* got bytes, convert to 512 byte sectors */
+ total_number_of_sectors = (v64 >> 9);
} else {
- unsigned long longsectors;
-
- if (ioctl(fd, BLKGETSIZE, &longsectors))
- longsectors = 0;
- bytes = ((unsigned long long) longsectors) << 9;
+ unsigned long longsectors; /* need temp of type long */
+ if (ioctl(fd, BLKGETSIZE, &longsectors))
+ longsectors = 0;
+ total_number_of_sectors = longsectors;
}
- total_number_of_sectors = (bytes >> 9);
-
sector_offset = 1;
if (dos_compatible_flag)
sector_offset = sectors;
pe->ext_pointer = NULL;
pe->offset = 0;
pe->sectorbuffer = MBRbuffer;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
pe->changed = (what == create_empty_dos);
#endif
}
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
if (what == create_empty_sun && check_sun_label())
return 0;
#endif
memset(MBRbuffer, 0, 512);
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
if (what == create_empty_dos)
goto got_dos_table; /* skip reading disk */
- if ((fd = open(disk_device, type_open)) < 0) {
- if ((fd = open(disk_device, O_RDONLY)) < 0) {
+ fd = open(disk_device, type_open);
+ if (fd < 0) {
+ fd = open(disk_device, O_RDONLY);
+ if (fd < 0) {
if (what == try_only)
return 1;
fdisk_fatal(unable_to_open);
} else
- printf(_("You will not be able to write "
- "the partition table.\n"));
+ printf("You will not be able to write "
+ "the partition table\n");
}
if (512 != read(fd, MBRbuffer, 512)) {
fdisk_fatal(unable_to_read);
}
#else
- if ((fd = open(disk_device, O_RDONLY)) < 0)
+ fd = open(disk_device, O_RDONLY);
+ if (fd < 0)
return 1;
if (512 != read(fd, MBRbuffer, 512))
return 1;
update_units();
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
if (check_sun_label())
return 0;
#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
+#if ENABLE_FEATURE_SGI_LABEL
if (check_sgi_label())
return 0;
#endif
-#ifdef CONFIG_FEATURE_AIX_LABEL
+#if ENABLE_FEATURE_AIX_LABEL
if (check_aix_label())
return 0;
#endif
-#ifdef CONFIG_FEATURE_OSF_LABEL
+#if ENABLE_FEATURE_OSF_LABEL
if (check_osf_label()) {
possibly_osf_label = 1;
if (!valid_part_table_flag(MBRbuffer)) {
current_label_type = label_osf;
return 0;
}
- printf(_("This disk has both DOS and BSD magic.\n"
- "Give the 'b' command to go to BSD mode.\n"));
+ printf("This disk has both DOS and BSD magic.\n"
+ "Give the 'b' command to go to BSD mode.\n");
}
#endif
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
got_dos_table:
#endif
if (!valid_part_table_flag(MBRbuffer)) {
-#ifndef CONFIG_FEATURE_FDISK_WRITABLE
+#if !ENABLE_FEATURE_FDISK_WRITABLE
return -1;
#else
switch (what) {
case fdisk:
- printf(_("Device contains neither a valid DOS "
+ printf("Device contains neither a valid DOS "
"partition table, nor Sun, SGI or OSF "
- "disklabel\n"));
+ "disklabel\n");
#ifdef __sparc__
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
create_sunlabel();
#endif
#else
case try_only:
return -1;
case create_empty_dos:
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
case create_empty_sun:
#endif
break;
default:
- bb_error_msg_and_die(_("Internal error"));
+ bb_error_msg_and_die("internal error");
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
warn_cylinders();
#endif
warn_geometry();
if (IS_EXTENDED(pe->part_table->sys_ind)) {
if (partitions != 4)
- printf(_("Ignoring extra extended "
- "partition %d\n"), i + 1);
+ printf("Ignoring extra extended "
+ "partition %d\n", i + 1);
else
read_extended(i);
}
struct pte *pe = &ptes[i];
if (!valid_part_table_flag(pe->sectorbuffer)) {
- printf(_("Warning: invalid flag 0x%04x of partition "
- "table %d will be corrected by w(rite)\n"),
- part_table_flag(pe->sectorbuffer), i + 1);
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+ printf("Warning: invalid flag 0x%02x,0x%02x of partition "
+ "table %d will be corrected by w(rite)\n",
+ pe->sectorbuffer[510],
+ pe->sectorbuffer[511],
+ i + 1);
+#if ENABLE_FEATURE_FDISK_WRITABLE
pe->changed = 1;
#endif
}
return 0;
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
/*
* Print the message MESG, then read an integer between LOW and HIGH (inclusive).
* If the user hits Enter, DFLT is returned.
*
* There is no default if DFLT is not between LOW and HIGH.
*/
-static uint
-read_int(uint low, uint dflt, uint high, uint base, char *mesg)
+static unsigned
+read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg)
{
- uint i;
+ unsigned i;
int default_ok = 1;
const char *fmt = "%s (%u-%u, default %u): ";
break;
}
if (absolute) {
- unsigned long long bytes;
+ ullong bytes;
unsigned long unit;
- bytes = (unsigned long long) i * absolute;
+ bytes = (ullong) i * absolute;
unit = sector_size * units_per_sector;
bytes += unit/2; /* round */
bytes /= unit;
use_default = 0;
}
}
- if (use_default)
- printf(_("Using default value %u\n"), i = dflt);
+ if (use_default) {
+ i = dflt;
+ printf("Using default value %u\n", i);
+ }
if (i >= low && i <= high)
break;
- else
- printf(_("Value is out of range\n"));
+ printf("Value is out of range\n");
}
return i;
}
struct pte *pe;
int i;
- i = read_int(1, 0, max, 0, _("Partition number")) - 1;
+ i = read_int(1, 0, max, 0, "Partition number") - 1;
pe = &ptes[i];
if (warn) {
|| (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 %d has empty type\n", i+1);
}
}
return i;
}
}
if (pno >= 0) {
- printf(_("Selected partition %d\n"), pno+1);
+ printf("Selected partition %d\n", pno+1);
return pno;
}
- printf(_("No partition is defined yet!\n"));
+ printf("No partition is defined yet!\n");
return -1;
not_unique:
}
}
if (pno >= 0) {
- printf(_("Selected partition %d\n"), pno+1);
+ printf("Selected partition %d\n", pno+1);
return pno;
}
- printf(_("All primary partitions have been defined already!\n"));
+ printf("All primary partitions have been defined already!\n");
return -1;
not_unique:
{
display_in_cyl_units = !display_in_cyl_units;
update_units();
- printf(_("Changing display/entry units to %s\n"),
+ printf("Changing display/entry units to %s\n",
str_units(PLURAL));
}
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 %d is an extended partition\n", i + 1);
p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
pe->changed = 1;
}
dos_compatible_flag = ~dos_compatible_flag;
if (dos_compatible_flag) {
sector_offset = sectors;
- printf(_("DOS Compatibility flag is set\n"));
- }
- else {
+ printf("DOS Compatibility flag is set\n");
+ } else {
sector_offset = 1;
- printf(_("DOS Compatibility flag is not set\n"));
+ printf("DOS Compatibility flag is not set\n");
}
}
/* 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 %d does not exist yet!\n", i + 1);
return;
}
while (1) {
- sys = read_hex (get_sys_types());
+ sys = read_hex(get_sys_types());
if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) {
- printf(_("Type 0 means free space to many systems\n"
+ printf("Type 0 means free space to many systems\n"
"(but not to Linux). Having partitions of\n"
- "type 0 is probably unwise. You can delete\n"
- "a partition using the `d' command.\n"));
+ "type 0 is probably unwise.\n");
/* break; */
}
if (!LABEL_IS_SUN && !LABEL_IS_SGI) {
if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {
- printf(_("You cannot change a partition into"
- " an extended one or vice versa\n"
- "Delete it first.\n"));
+ printf("You cannot change a partition into"
+ " an extended one or vice versa\n");
break;
}
}
if (sys < 256) {
+#if ENABLE_FEATURE_SUN_LABEL
if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK)
- printf(_("Consider leaving partition 3 "
+ printf("Consider leaving partition 3 "
"as Whole disk (5),\n"
"as SunOS/Solaris expects it and "
- "even Linux likes it.\n\n"));
+ "even Linux likes it\n\n");
+#endif
+#if ENABLE_FEATURE_SGI_LABEL
if (LABEL_IS_SGI &&
(
(i == 10 && sys != SGI_ENTIRE_DISK) ||
(i == 8 && sys != 0)
)
- ){
- printf(_("Consider leaving partition 9 "
+ ) {
+ printf("Consider leaving partition 9 "
"as volume header (0),\nand "
"partition 11 as entire volume (6)"
- "as IRIX expects it.\n\n"));
+ "as IRIX expects it\n\n");
}
+#endif
if (sys == origsys)
break;
if (LABEL_IS_SUN) {
} else
p->sys_ind = sys;
- printf(_("Changed system type of partition %d "
- "to %x (%s)\n"), i + 1, sys,
+ printf("Changed system type of partition %d "
+ "to %x (%s)\n", i + 1, sys,
partition_type(sys));
ptes[i].changed = 1;
if (is_dos_partition(origsys) ||
}
}
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
-/* check_consistency() and long2chs() added Sat Mar 6 12:28:16 1993,
+/* check_consistency() and linear2chs() added Sat Mar 6 12:28:16 1993,
* faith@cs.unc.edu, based on code fragments from pfdisk by Gordon W. Ross,
* Jan. 1990 (version 1.2.1 by Gordon W. Ross Aug. 1990; Modified by S.
* Lubkin Oct. 1991). */
static void
-long2chs(ulong ls, uint *c, uint *h, uint *s)
+linear2chs(unsigned ls, unsigned *c, unsigned *h, unsigned *s)
{
int spc = heads * sectors;
static void
check_consistency(const struct partition *p, int partition)
{
- uint pbc, pbh, pbs; /* physical beginning c, h, s */
- uint pec, peh, pes; /* physical ending c, h, s */
- uint lbc, lbh, lbs; /* logical beginning c, h, s */
- uint lec, leh, les; /* logical ending c, h, s */
+ unsigned pbc, pbh, pbs; /* physical beginning c, h, s */
+ unsigned pec, peh, pes; /* physical ending c, h, s */
+ unsigned lbc, lbh, lbs; /* logical beginning c, h, s */
+ unsigned lec, leh, les; /* logical ending c, h, s */
if (!heads || !sectors || (partition >= 4))
return; /* do not check extended partitions */
pes = p->end_sector & 0x3f;
/* compute logical beginning (c, h, s) */
- long2chs(get_start_sect(p), &lbc, &lbh, &lbs);
+ linear2chs(get_start_sect(p), &lbc, &lbh, &lbs);
/* compute logical ending (c, h, s) */
- long2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
+ linear2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
/* Same physical / logical beginning? */
if (cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
- printf(_("Partition %d has different physical/logical "
- "beginnings (non-Linux?):\n"), partition + 1);
- printf(_(" phys=(%d, %d, %d) "), pbc, pbh, pbs);
- printf(_("logical=(%d, %d, %d)\n"),lbc, lbh, lbs);
+ printf("Partition %d has different physical/logical "
+ "beginnings (non-Linux?):\n", partition + 1);
+ printf(" phys=(%d, %d, %d) ", pbc, pbh, pbs);
+ printf("logical=(%d, %d, %d)\n",lbc, lbh, lbs);
}
/* Same physical / logical ending? */
if (cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
- printf(_("Partition %d has different physical/logical "
- "endings:\n"), partition + 1);
- printf(_(" phys=(%d, %d, %d) "), pec, peh, pes);
- printf(_("logical=(%d, %d, %d)\n"),lec, leh, les);
+ printf("Partition %d has different physical/logical "
+ "endings:\n", partition + 1);
+ printf(" phys=(%d, %d, %d) ", pec, peh, pes);
+ printf("logical=(%d, %d, %d)\n", lec, leh, les);
}
/* Ending on cylinder boundary? */
if (peh != (heads - 1) || pes != sectors) {
- printf(_("Partition %i does not end on cylinder boundary.\n"),
+ printf("Partition %i does not end on cylinder boundary\n",
partition + 1);
}
}
long megabytes = bytes/1000000;
if (megabytes < 10000)
- printf(_("\nDisk %s: %ld MB, %lld bytes\n"),
+ printf("\nDisk %s: %ld MB, %lld bytes\n",
disk_device, megabytes, bytes);
else
- printf(_("\nDisk %s: %ld.%ld GB, %lld bytes\n"),
+ 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("%d heads, %d sectors/track, %d cylinders",
heads, sectors, cylinders);
if (units_per_sector == 1)
- printf(_(", total %llu sectors"),
+ printf(", total %llu sectors",
total_number_of_sectors / (sector_size/512));
- printf(_("\nUnits = %s of %d * %d = %d bytes\n\n"),
+ printf("\nUnits = %s of %d * %d = %d bytes\n\n",
str_units(PLURAL),
units_per_sector, sector_size, units_per_sector * sector_size);
}
{
const struct pte *pe;
const struct partition *p;
- off_t last_p_start_pos = 0, p_start_pos;
+ ullong last_p_start_pos = 0, p_start_pos;
int i, last_i = 0;
for (i = 0 ; i < partitions; i++) {
return 0;
}
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED
/*
* Fix the chain of logicals.
* extended_offset is unchanged, the set of sectors used is unchanged
int i,k;
if (!wrong_p_order(NULL)) {
- printf(_("Nothing to do. Ordering is correct already.\n\n"));
+ printf("Ordering is already correct\n\n");
return;
}
if (w < 5)
w = 5;
- // 1 12345678901 12345678901 12345678901 12
- printf(_("%*s Boot Start End Blocks Id System\n"),
- w+1, _("Device"));
+ // 1 12345678901 12345678901 12345678901 12
+ printf("%*s Boot Start End Blocks Id System\n",
+ w+1, "Device");
for (i = 0; i < partitions; i++) {
const struct pte *pe = &ptes[i];
- off_t psects;
- off_t pblocks;
- unsigned int podd;
+ ullong psects;
+ ullong pblocks;
+ unsigned podd;
p = pe->part_table;
if (!p || is_cleared_partition(p))
partname(disk_device, i+1, w+2),
!p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */
? '*' : '?',
- (unsigned long long) cround(get_partition_start(pe)), /* start */
- (unsigned long long) cround(get_partition_start(pe) + psects /* end */
+ (ullong) cround(get_partition_start(pe)), /* start */
+ (ullong) cround(get_partition_start(pe) + psects /* end */
- (psects ? 1 : 0)),
- (unsigned long long) pblocks, podd ? '+' : ' ', /* odd flag on end */
+ (ullong) pblocks, podd ? '+' : ' ', /* odd flag on end */
p->sys_ind, /* type id */
partition_type(p->sys_ind)); /* type name */
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"));
+ printf("\nPartition table entries are not in disk order\n");
}
}
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED
static void
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: %d heads, %d sectors, %d cylinders\n\n",
disk_device, heads, sectors, cylinders);
- printf(_("Nr AF Hd Sec Cyl Hd Sec Cyl Start Size ID\n"));
+ printf("Nr AF Hd Sec Cyl Hd Sec Cyl Start Size ID\n");
for (i = 0 ; i < partitions; i++) {
pe = &ptes[i];
p = (extend ? pe->ext_pointer : pe->part_table);
}
#endif
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
-fill_bounds(off_t *first, off_t *last)
+fill_bounds(ullong *first, ullong *last)
{
int i;
const struct pte *pe = &ptes[0];
}
static void
-check(int n, uint h, uint s, uint c, off_t start)
+check(int n, unsigned h, unsigned s, unsigned c, ullong start)
{
- off_t total, real_s, real_c;
+ ullong total, real_s, real_c;
real_s = sector(s) - 1;
real_c = cylinder(s, c);
total = (real_c * sectors + real_s) * heads + h;
if (!total)
- printf(_("Warning: partition %d contains sector 0\n"), n);
+ printf("Partition %d contains sector 0\n", n);
if (h >= heads)
- printf(_("Partition %d: head %d greater than maximum %d\n"),
+ printf("Partition %d: head %d greater than maximum %d\n",
n, h + 1, heads);
if (real_s >= sectors)
- printf(_("Partition %d: sector %d greater than "
- "maximum %d\n"), n, s, sectors);
+ printf("Partition %d: sector %d greater than "
+ "maximum %d\n", n, s, sectors);
if (real_c >= cylinders)
- printf(_("Partitions %d: cylinder %llu greater than "
- "maximum %d\n"), n, (unsigned long long)real_c + 1, cylinders);
+ printf("Partition %d: cylinder %llu greater than "
+ "maximum %d\n", n, real_c + 1, cylinders);
if (cylinders <= 1024 && start != total)
- printf(_("Partition %d: previous sectors %llu disagrees with "
- "total %llu\n"), n, (unsigned long long)start, (unsigned long long)total);
+ printf("Partition %d: previous sectors %llu disagrees with "
+ "total %llu\n", n, start, total);
}
static void
verify(void)
{
int i, j;
- uint total = 1;
- off_t first[partitions], last[partitions];
+ unsigned total = 1;
+ ullong first[partitions], last[partitions];
struct partition *p;
if (warn_geometry())
if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
check_consistency(p, i);
if (get_partition_start(pe) < first[i])
- printf(_("Warning: bad start-of-data in "
- "partition %d\n"), i + 1);
+ printf("Warning: bad start-of-data in "
+ "partition %d\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);
- total += first[i] >= first[j] ?
- first[i] : first[j];
- total -= last[i] <= last[j] ?
- last[i] : last[j];
+ 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);
+ total += first[i] >= first[j] ?
+ first[i] : first[j];
+ total -= last[i] <= last[j] ?
+ last[i] : last[j];
+ }
}
}
}
if (extended_offset) {
struct pte *pex = &ptes[ext_index];
- off_t e_last = get_start_sect(pex->part_table) +
+ ullong e_last = get_start_sect(pex->part_table) +
get_nr_sects(pex->part_table) - 1;
for (i = 4; i < partitions; i++) {
p = ptes[i].part_table;
if (!p->sys_ind) {
if (i != 4 || i + 1 < partitions)
- printf(_("Warning: partition %d "
- "is empty\n"), i + 1);
+ printf("Warning: partition %d "
+ "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);
}
- 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);
}
}
if (total > heads * sectors * cylinders)
- printf(_("Total allocated sectors %d greater than the maximum "
- "%d\n"), total, heads * sectors * cylinders);
- else if ((total = heads * sectors * cylinders - total) != 0)
- printf(_("%d unallocated sectors\n"), total);
+ printf("Total allocated sectors %d greater than the maximum "
+ "%d\n", total, heads * sectors * cylinders);
+ else {
+ total = heads * sectors * cylinders - total;
+ if (total != 0)
+ printf("%d unallocated sectors\n", total);
+ }
}
static void
int i, num_read = 0;
struct partition *p = ptes[n].part_table;
struct partition *q = ptes[ext_index].part_table;
- long long llimit;
- off_t start, stop = 0, limit, temp,
- first[partitions], last[partitions];
+ ullong limit, temp;
+ ullong start, stop = 0;
+ ullong first[partitions], last[partitions];
if (p && p->sys_ind) {
- printf(_("Partition %d is already defined. Delete "
- "it before re-adding it.\n"), n + 1);
+ printf(msg_part_already_defined, n + 1);
return;
}
fill_bounds(first, last);
if (n < 4) {
start = sector_offset;
if (display_in_cyl_units || !total_number_of_sectors)
- llimit = heads * sectors * cylinders - 1;
+ limit = (ullong) heads * sectors * cylinders - 1;
else
- llimit = total_number_of_sectors - 1;
- limit = llimit;
- if (limit != llimit)
- limit = 0x7fffffff;
+ limit = total_number_of_sectors - 1;
if (extended_offset) {
first[ext_index] = extended_offset;
last[ext_index] = get_start_sect(q) +
for (i = 0; i < partitions; i++)
first[i] = (cround(first[i]) - 1) * units_per_sector;
- snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
+ snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));
do {
temp = start;
for (i = 0; i < partitions; i++) {
if (start > limit)
break;
if (start >= temp+units_per_sector && num_read) {
- printf(_("Sector %llu is already allocated\n"), (unsigned long long)temp);
+ printf("Sector %lld is already allocated\n", temp);
temp = start;
num_read = 0;
}
if (!num_read && start == temp) {
- off_t saved_start;
+ ullong saved_start;
saved_start = start;
start = read_int(cround(saved_start), cround(saved_start), cround(limit),
limit = first[i] - 1;
}
if (start > limit) {
- printf(_("No free sectors available\n"));
+ printf("No free sectors available\n");
if (n > 4)
partitions--;
return;
stop = limit;
} else {
snprintf(mesg, sizeof(mesg),
- _("Last %s or +size or +sizeM or +sizeK"),
+ "Last %s or +size or +sizeM or +sizeK",
str_units(SINGULAR));
stop = read_int(cround(start), cround(limit), cround(limit),
cround(start), mesg);
return;
}
if (LABEL_IS_AIX) {
- printf(_("\tSorry - this fdisk cannot handle AIX disk labels."
- "\n\tIf you want to add DOS-type partitions, create"
- "\n\ta new empty DOS partition table first. (Use o.)"
- "\n\tWARNING: "
- "This will destroy the present disk contents.\n"));
+ printf("Sorry - this fdisk cannot handle AIX disk labels.\n"
+"If you want to add DOS-type partitions, create a new empty DOS partition\n"
+"table first (use 'o'). This will destroy the present disk contents.\n");
return;
}
free_primary += !ptes[i].part_table->sys_ind;
if (!free_primary && partitions >= MAXIMUM_PARTS) {
- printf(_("The maximum number of partitions has been created\n"));
+ printf("The maximum number of partitions has been created\n");
return;
}
if (extended_offset)
add_logical();
else
- printf(_("You must delete some partition and add "
- "an extended partition first\n"));
+ printf("You must delete some partition and add "
+ "an extended partition first\n");
} else {
- char c, line[LINE_LENGTH];
- snprintf(line, sizeof(line), "%s\n %s\n p primary "
- "partition (1-4)\n",
- "Command action", (extended_offset ?
- "l logical (5 or over)" : "e extended"));
+ char c, line[80];
+ snprintf(line, sizeof(line),
+ "Command action\n"
+ " %s\n"
+ " p primary partition (1-4)\n",
+ (extended_offset ?
+ "l logical (5 or over)" : "e extended"));
while (1) {
c = read_nonempty(line);
if (c == 'p' || c == 'P') {
add_partition(i, LINUX_NATIVE);
return;
}
- else if (c == 'l' && extended_offset) {
+ if (c == 'l' && extended_offset) {
add_logical();
return;
}
- else if (c == 'e' && !extended_offset) {
+ if (c == 'e' && !extended_offset) {
i = get_nonexisting_partition(0, 4);
if (i >= 0)
add_partition(i, EXTENDED);
return;
}
- else
- printf(_("Invalid partition number "
- "for type `%c'\n"), c);
+ printf("Invalid partition number "
+ "for type '%c'\n", c);
}
}
}
sun_write_table();
}
- printf(_("The partition table has been altered!\n\n"));
+ printf("The partition table has been altered!\n\n");
reread_partition_table(1);
}
static void
reread_partition_table(int leave)
{
- int error = 0;
int i;
- printf(_("Calling ioctl() to re-read partition table.\n"));
+ printf("Calling ioctl() to re-read partition table\n");
sync();
- sleep(2);
- if ((i = ioctl(fd, BLKRRPART)) != 0) {
- error = errno;
- } else {
+ /* sleep(2); Huh? */
+ i = ioctl(fd, BLKRRPART);
+#if 0
+ else {
/* some kernel versions (1.2.x) seem to have trouble
rereading the partition table, but if asked to do it
twice, the second time works. - biro@yggdrasil.com */
sync();
sleep(2);
- if ((i = ioctl(fd, BLKRRPART)) != 0)
- error = errno;
+ i = ioctl(fd, BLKRRPART);
}
+#endif
if (i) {
- printf(_("\nWARNING: Re-reading the partition table "
- "failed with error %d: %s.\n"
- "The kernel still uses the old table.\n"
- "The new table will be used "
- "at the next reboot.\n"),
- error, strerror(error));
+ bb_perror_msg("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"
+ "\nWARNING: If you have created or modified any DOS 6.x\n"
"partitions, please see the fdisk manual page for additional\n"
- "information.\n"));
+ "information\n");
+#endif
if (leave) {
- close(fd);
-
- printf(_("Syncing disks.\n"));
- sync();
- sleep(4); /* for sync() */
- exit(!!i);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ close(fd);
+ exit(i != 0);
}
}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED
#define MAX_PER_LINE 16
static void
print_buffer(char *pbuffer)
printf("0x%03X:", i);
printf(" %02X", (unsigned char) pbuffer[i]);
if (l == MAX_PER_LINE - 1) {
- printf("\n");
+ puts("");
l = -1;
}
}
if (l > 0)
- printf("\n");
- printf("\n");
+ puts("");
+ puts("");
}
-
static void
print_raw(void)
{
int i;
- printf(_("Device: %s\n"), disk_device);
+ printf("Device: %s\n", disk_device);
if (LABEL_IS_SGI || LABEL_IS_SUN)
print_buffer(MBRbuffer);
else {
{
struct pte *pe = &ptes[i];
struct partition *p = pe->part_table;
- off_t new, first;
+ ullong 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 %d 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;
+ "New beginning of data") - pe->offset;
if (new != get_nr_sects(p)) {
first = get_nr_sects(p) + get_start_sect(p) - new;
while (1) {
putchar('\n');
- c = tolower(read_nonempty(_("Expert command (m for help): ")));
+ c = tolower(read_nonempty("Expert command (m for help): "));
switch (c) {
case 'a':
if (LABEL_IS_SUN)
case 'c':
user_cylinders = cylinders =
read_int(1, cylinders, 1048576, 0,
- _("Number of cylinders"));
+ "Number of cylinders");
if (LABEL_IS_SUN)
sun_set_ncyl(cylinders);
if (LABEL_IS_DOS)
fix_partition_table_order();
break;
case 'g':
-#ifdef CONFIG_FEATURE_SGI_LABEL
+#if ENABLE_FEATURE_SGI_LABEL
create_sgilabel();
#endif
break;
case 'h':
user_heads = heads = read_int(1, heads, 256, 0,
- _("Number of heads"));
+ "Number of heads");
update_units();
break;
case 'i':
break;
case 'q':
close(fd);
- printf("\n");
+ puts("");
exit(0);
case 'r':
return;
case 's':
user_sectors = sectors = read_int(1, sectors, 63, 0,
- _("Number of sectors"));
+ "Number of sectors");
if (dos_compatible_flag) {
sector_offset = sectors;
- printf(_("Warning: setting sector offset for DOS "
- "compatiblity\n"));
+ printf("Warning: setting sector offset for DOS "
+ "compatiblity\n");
}
update_units();
break;
static void
-try(const char *device, int user_specified)
+trydev(const char *device, int user_specified)
{
int gb;
if (!user_specified)
if (is_ide_cdrom_or_tape(device))
return;
- if ((fd = open(disk_device, type_open)) >= 0) {
+ fd = open(disk_device, type_open);
+ if (fd >= 0) {
gb = get_boot(try_only);
if (gb > 0) { /* I/O error */
close(fd);
if (LABEL_IS_AIX) {
return;
}
-#ifdef CONFIG_FEATURE_OSF_LABEL
- if (btrydev(device) < 0)
+#if ENABLE_FEATURE_OSF_LABEL
+ if (bsd_trydev(device) < 0)
#endif
- printf(_("Disk %s doesn't contain a valid "
- "partition table\n"), device);
+ printf("Disk %s doesn't contain a valid "
+ "partition table\n", device);
close(fd);
} else {
close(fd);
list_table(0);
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
if (!LABEL_IS_SUN && partitions > 4){
delete_partition(ext_index);
}
and SCSI hard disks which may not be
installed on the system. */
if (errno == EACCES) {
- printf(_("Cannot open %s\n"), device);
+ printf("Cannot open %s\n", device);
return;
}
}
char line[100], ptname[100], devname[120], *s;
int ma, mi, sz;
- procpt = bb_wfopen("/proc/partitions", "r");
+ procpt = fopen_or_warn("/proc/partitions", "r");
while (fgets(line, sizeof(line), procpt)) {
if (sscanf(line, " %d %d %d %[^\n ]",
if (isdigit(s[-1]))
continue;
sprintf(devname, "/dev/%s", ptname);
- try(devname, 0);
+ trydev(devname, 0);
}
-#ifdef CONFIG_FEATURE_CLEAN_UP
+#if ENABLE_FEATURE_CLEAN_UP
fclose(procpt);
#endif
}
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
static void
unknown_command(int c)
{
- printf(_("%c: unknown command\n"), c);
+ printf("%c: unknown command\n", c);
}
#endif
+int fdisk_main(int argc, char **argv);
int fdisk_main(int argc, char **argv)
{
- int c;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
- int optl = 0;
-#endif
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
- int opts = 0;
-#endif
+ char *str_b, *str_C, *str_H, *str_S;
+ unsigned opt;
/*
- * Calls:
* fdisk -v
* fdisk -l [-b sectorsize] [-u] device ...
* fdisk -s [partition] ...
* fdisk [-b sectorsize] [-u] device
*
* Options -C, -H, -S set the geometry.
- *
*/
- while ((c = getopt(argc, argv, "b:C:H:lS:u"
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
- "s"
-#endif
- )) != -1) {
- switch (c) {
- case 'b':
- /* Ugly: this sector size is really per device,
- so cannot be combined with multiple disks,
- and te same goes for the C/H/S options.
- */
- sector_size = xatoi_u(optarg);
- if (sector_size != 512 && sector_size != 1024 &&
- sector_size != 2048)
- bb_show_usage();
- sector_offset = 2;
- user_set_sector_size = 1;
- break;
- case 'C':
- user_cylinders = xatoi_u(optarg);
- break;
- case 'H':
- user_heads = xatoi_u(optarg);
- if (user_heads <= 0 || user_heads >= 256)
- user_heads = 0;
- break;
- case 'S':
- user_sectors = xatoi_u(optarg);
- if (user_sectors <= 0 || user_sectors >= 64)
- user_sectors = 0;
- break;
- case 'l':
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
- optl = 1;
-#endif
- break;
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
- case 's':
- opts = 1;
- break;
-#endif
- case 'u':
- display_in_cyl_units = 0;
- break;
- default:
+ enum {
+ OPT_b = 1 << 0,
+ OPT_C = 1 << 1,
+ OPT_H = 1 << 2,
+ OPT_l = 1 << 3,
+ OPT_S = 1 << 4,
+ OPT_u = 1 << 5,
+ OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
+ };
+
+ PTR_TO_GLOBALS = xzalloc(sizeof(G));
+
+ opt = getopt32(argc, argv, "b:C:H:lS:u" USE_FEATURE_FDISK_BLKSIZE("s"),
+ &str_b, &str_C, &str_H, &str_S);
+ argc -= optind;
+ argv += optind;
+ if (opt & OPT_b) { // -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.
+ */
+ sector_size = xatoi_u(str_b);
+ if (sector_size != 512 && sector_size != 1024 &&
+ sector_size != 2048)
bb_show_usage();
- }
- }
-
- if (user_set_sector_size && argc-optind != 1)
- printf(_("Warning: the -b (set sector size) option should"
- " be used with one specified device\n"));
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
- if (optl) {
+ sector_offset = 2;
+ user_set_sector_size = 1;
+ }
+ if (opt & OPT_C) user_cylinders = xatoi_u(str_C); // -C
+ if (opt & OPT_H) { // -H
+ user_heads = xatoi_u(str_H);
+ if (user_heads <= 0 || user_heads >= 256)
+ user_heads = 0;
+ }
+ //if (opt & OPT_l) // -l
+ if (opt & OPT_S) { // -S
+ user_sectors = xatoi_u(str_S);
+ if (user_sectors <= 0 || user_sectors >= 64)
+ user_sectors = 0;
+ }
+ if (opt & OPT_u) display_in_cyl_units = 0; // -u
+ //if (opt & OPT_s) // -s
+
+ if (user_set_sector_size && argc != 1)
+ printf("Warning: the -b (set sector size) option should"
+ " be used with one specified device\n");
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
+ if (opt & OPT_l) {
nowarn = 1;
#endif
type_open = O_RDONLY;
- if (argc > optind) {
+ if (argc > 0) {
int k;
-#if __GNUC__
+#if defined(__GNUC__)
/* avoid gcc warning:
variable `k' might be clobbered by `longjmp' */
(void)&k;
#endif
listing = 1;
- for (k = optind; k < argc; k++)
- try(argv[k], 1);
+ for (k = 0; k < argc; k++)
+ trydev(argv[k], 1);
} else {
/* we no longer have default device names */
/* but, we can use /proc/partitions instead */
tryprocpt();
}
return 0;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
}
#endif
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
- if (opts) {
+#if ENABLE_FEATURE_FDISK_BLKSIZE
+ if (opt & OPT_s) {
long size;
int j;
nowarn = 1;
type_open = O_RDONLY;
- opts = argc - optind;
- if (opts <= 0)
+ if (argc <= 0)
bb_show_usage();
- for (j = optind; j < argc; j++) {
+ for (j = 0; j < argc; j++) {
disk_device = argv[j];
- if ((fd = open(disk_device, type_open)) < 0)
+ fd = open(disk_device, type_open);
+ if (fd < 0)
fdisk_fatal(unable_to_open);
if (ioctl(fd, BLKGETSIZE, &size))
fdisk_fatal(ioctl_error);
close(fd);
- if (opts == 1)
+ if (argc == 1)
printf("%ld\n", size/2);
else
printf("%s: %ld\n", argv[j], size/2);
}
#endif
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
- if (argc-optind == 1)
- disk_device = argv[optind];
- else
+#if ENABLE_FEATURE_FDISK_WRITABLE
+ if (argc != 1)
bb_show_usage();
+ disk_device = argv[0];
get_boot(fdisk);
if (LABEL_IS_OSF) {
/* OSF label, and no DOS label */
- printf(_("Detected an OSF/1 disklabel on %s, entering "
- "disklabel mode.\n"), disk_device);
- bselect();
+ printf("Detected an OSF/1 disklabel on %s, entering "
+ "disklabel mode\n", disk_device);
+ bsd_select();
/*Why do we do this? It seems to be counter-intuitive*/
current_label_type = label_dos;
/* If we return we may want to make an empty DOS label? */
}
while (1) {
+ int c;
putchar('\n');
- c = tolower(read_nonempty(_("Command (m for help): ")));
+ c = tolower(read_nonempty("Command (m for help): "));
switch (c) {
case 'a':
if (LABEL_IS_DOS)
break;
case 'b':
if (LABEL_IS_SGI) {
- printf(_("\nThe current boot file is: %s\n"),
+ printf("\nThe current boot file is: %s\n",
sgi_get_bootfile());
- if (read_maybe_empty(_("Please enter the name of the "
- "new boot file: ")) == '\n')
- printf(_("Boot file unchanged\n"));
+ if (read_maybe_empty("Please enter the name of the "
+ "new boot file: ") == '\n')
+ printf("Boot file unchanged\n");
else
sgi_set_bootfile(line_ptr);
- } else
-#ifdef CONFIG_FEATURE_OSF_LABEL
- bselect();
+ }
+#if ENABLE_FEATURE_OSF_LABEL
+ else
+ bsd_select();
#endif
-
-/* BUG!? Think what will happen if !CONFIG_FEATURE_OSF_LABEL !!! */
-
break;
case 'c':
if (LABEL_IS_DOS)
break;
case 'q':
close(fd);
- printf("\n");
+ puts("");
return 0;
case 's':
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
create_sunlabel();
#endif
break;
case 'w':
write_table(); /* does not return */
break;
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED
case 'x':
if (LABEL_IS_SGI) {
- printf(_("\n\tSorry, no experts menu for SGI "
- "partition tables available.\n\n"));
+ printf("\n\tSorry, no experts menu for SGI "
+ "partition tables available\n\n");
} else
xselect();
break;
}
}
return 0;
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
}