diff options
Diffstat (limited to 'util-linux/fdisk.c')
| -rw-r--r-- | util-linux/fdisk.c | 3917 |
1 files changed, 2013 insertions, 1904 deletions
diff --git a/util-linux/fdisk.c b/util-linux/fdisk.c index 8a5340a..33ad847 100644 --- a/util-linux/fdisk.c +++ b/util-linux/fdisk.c @@ -1,10 +1,9 @@ /* fdisk.c -- Partition table manipulator for Linux. * * Copyright (C) 1992 A. V. Le Blanc (LeBlanc@mcc.ac.uk) + * Copyright (C) 2001,2002 Vladimir Oleynik <dzo@simtreas.ru> (Busybox port) * - * Licensed under the GPL v1 or later, see the file LICENSE in this tarball. - * - * Vladimir Oleynik <dzo@simtreas.ru> 2001,2002 Busybox port + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. */ #define UTIL_LINUX_VERSION "2.12" @@ -91,10 +90,10 @@ /* including <linux/hdreg.h> also fails */ struct hd_geometry { - unsigned char heads; - unsigned char sectors; - unsigned short cylinders; - unsigned long start; + unsigned char heads; + unsigned char sectors; + unsigned short cylinders; + unsigned long start; }; #define HDIO_GETGEO 0x0301 /* get device geometry */ @@ -104,9 +103,9 @@ struct systypes { const char *name; }; -static uint sector_size = DEFAULT_SECTOR_SIZE, - user_set_sector_size, - sector_offset = 1; +static uint sector_size = DEFAULT_SECTOR_SIZE; +static uint user_set_sector_size; +static uint sector_offset = 1; /* * Raw disk label. For DOS-type partition tables the MBR, @@ -119,23 +118,23 @@ static char MBRbuffer[MAX_SECTOR_SIZE]; #endif #ifdef CONFIG_FEATURE_SUN_LABEL -static int sun_label; /* looking at sun disklabel */ +static int sun_label; /* looking at sun disklabel */ #else #define sun_label 0 #endif #ifdef CONFIG_FEATURE_SGI_LABEL -static int sgi_label; /* looking at sgi disklabel */ +static int sgi_label; /* looking at sgi disklabel */ #else #define sgi_label 0 #endif #ifdef CONFIG_FEATURE_AIX_LABEL -static int aix_label; /* looking at aix disklabel */ +static int aix_label; /* looking at aix disklabel */ #else #define aix_label 0 #endif #ifdef CONFIG_FEATURE_OSF_LABEL -static int osf_label; /* looking at OSF/1 disklabel */ -static int possibly_osf_label; +static int osf_label; /* looking at OSF/1 disklabel */ +static int possibly_osf_label; #else #define osf_label 0 #endif @@ -150,7 +149,8 @@ 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) { +partname(const char *dev, int pno, int lth) +{ static char buffer[80]; const char *p; int w, wp; @@ -168,7 +168,7 @@ partname(const char *dev, int pno, int lth) { /* 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) { + if (strcmp(dev + w - 4, "disc") == 0) { w -= 4; p = "part"; } @@ -202,7 +202,7 @@ enum failure { unable_to_write }; -enum action {fdisk, require, try_only, create_empty_dos, create_empty_sun}; +enum action { fdisk, require, try_only, create_empty_dos, create_empty_sun }; static const char *disk_device; static int fd; /* the disk */ @@ -214,7 +214,7 @@ static char *line_ptr; 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 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); #endif @@ -275,7 +275,8 @@ static struct pte { #ifdef CONFIG_FEATURE_FDISK_WRITABLE static void -set_all_unchanged(void) { +set_all_unchanged(void) +{ int i; for (i = 0; i < MAXIMUM_PARTS; i++) @@ -283,20 +284,23 @@ set_all_unchanged(void) { } static void -set_changed(int i) { +set_changed(int i) +{ ptes[i].changed = 1; } #endif /* CONFIG_FEATURE_FDISK_WRITABLE */ #if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_OSF_LABEL) static struct partition * -get_part_table(int i) { +get_part_table(int i) +{ return ptes[i].part_table; } #endif static const char * -str_units(int n) { /* n==1: use singular */ +str_units(int n) +{ /* n==1: use singular */ if (n == 1) return display_in_cyl_units ? _("cylinder") : _("sector"); else @@ -359,19 +363,17 @@ read_hex(const struct systypes *sys) { int hex; - while (1) - { - read_char(_("Hex code (type L to list codes): ")); - if (*line_ptr == 'l' || *line_ptr == 'L') - list_types(sys); - else if (isxdigit (*line_ptr)) - { - hex = 0; - do - hex = hex << 4 | hex_val(*line_ptr++); - while (isxdigit(*line_ptr)); - return hex; - } + while (1) { + read_char(_("Hex code (type L to list codes): ")); + if (*line_ptr == 'l' || *line_ptr == 'L') + list_types(sys); + else if (isxdigit (*line_ptr)) { + hex = 0; + do + hex = hex << 4 | hex_val(*line_ptr++); + while (isxdigit(*line_ptr)); + return hex; + } } } #endif /* CONFIG_FEATURE_FDISK_WRITABLE */ @@ -407,58 +409,59 @@ typedef struct { * Some fixes */ -static int aix_other_endian; -static short aix_volumes=1; +static int aix_other_endian; +static short aix_volumes = 1; /* * only dealing with free blocks here */ static void -aix_info( void ) { - puts( - _("\n\tThere is a valid AIX label on this disk.\n" - "\tUnfortunately Linux cannot handle these\n" - "\tdisks at the moment. Nevertheless some\n" - "\tadvice:\n" - "\t1. fdisk will destroy its contents on write.\n" - "\t2. Be sure that this disk is NOT a still vital\n" - "\t part of a volume group. (Otherwise you may\n" - "\t erase the other disks as well, if unmirrored.)\n" - "\t3. Before deleting this physical volume be sure\n" - "\t to remove the disk logically from your AIX\n" - "\t machine. (Otherwise you become an AIXpert).") - ); +aix_info(void) +{ + puts( + _("\n\tThere is a valid AIX label on this disk.\n" + "\tUnfortunately Linux cannot handle these\n" + "\tdisks at the moment. Nevertheless some\n" + "\tadvice:\n" + "\t1. fdisk will destroy its contents on write.\n" + "\t2. Be sure that this disk is NOT a still vital\n" + "\t part of a volume group. (Otherwise you may\n" + "\t erase the other disks as well, if unmirrored.)\n" + "\t3. Before deleting this physical volume be sure\n" + "\t to remove the disk logically from your AIX\n" + "\t machine. (Otherwise you become an AIXpert).") + ); } static void -aix_nolabel( void ) +aix_nolabel(void) { - aixlabel->magic = 0; - aix_label = 0; - partitions = 4; - memset( MBRbuffer, 0, sizeof(MBRbuffer) ); /* avoid fdisk cores */ - return; + aixlabel->magic = 0; + aix_label = 0; + partitions = 4; + memset(MBRbuffer, 0, sizeof(MBRbuffer)); /* avoid fdisk cores */ + return; } static int -check_aix_label( void ) +check_aix_label(void) { - if (aixlabel->magic != AIX_LABEL_MAGIC && - aixlabel->magic != AIX_LABEL_MAGIC_SWAPPED) { - aix_label = 0; - aix_other_endian = 0; - return 0; - } - aix_other_endian = (aixlabel->magic == AIX_LABEL_MAGIC_SWAPPED); - update_units(); - aix_label = 1; - partitions= 1016; - aix_volumes = 15; - aix_info(); - aix_nolabel(); /* %% */ - aix_label = 1; /* %% */ - return 1; + if (aixlabel->magic != AIX_LABEL_MAGIC && + aixlabel->magic != AIX_LABEL_MAGIC_SWAPPED) { + aix_label = 0; + aix_other_endian = 0; + return 0; + } + aix_other_endian = (aixlabel->magic == AIX_LABEL_MAGIC_SWAPPED); + update_units(); + aix_label = 1; + partitions = 1016; + aix_volumes = 15; + aix_info(); + aix_nolabel(); /* %% */ + aix_label = 1; /* %% */ + return 1; } #endif /* AIX_LABEL */ @@ -525,10 +528,10 @@ check_aix_label( void ) struct xbsd_disklabel { uint32_t d_magic; /* the magic number */ - int16_t d_type; /* drive type */ - int16_t d_subtype; /* controller/d_type specific */ - char d_typename[16]; /* type name, e.g. "eagle" */ - char d_packname[16]; /* pack identifier */ + int16_t d_type; /* drive type */ + int16_t d_subtype; /* controller/d_type specific */ + char d_typename[16]; /* type name, e.g. "eagle" */ + char d_packname[16]; /* pack identifier */ /* disk geometry: */ uint32_t d_secsize; /* # of bytes per sector */ uint32_t d_nsectors; /* # of data sectors per track */ @@ -660,28 +663,28 @@ static const char * const xbsd_dktypenames[] = { #ifdef DKTYPENAMES static const struct systypes xbsd_fstypes[] = { -/* BSD_FS_UNUSED */ {"\x00" "unused"}, -/* BSD_FS_SWAP */ {"\x01" "swap"}, -/* BSD_FS_V6 */ {"\x02" "Version 6"}, -/* BSD_FS_V7 */ {"\x03" "Version 7"}, -/* BSD_FS_SYSV */ {"\x04" "System V"}, -/* BSD_FS_V71K */ {"\x05" "4.1BSD"}, -/* BSD_FS_V8 */ {"\x06" "Eighth Edition"}, -/* BSD_FS_BSDFFS */ {"\x07" "4.2BSD"}, + { "\x00" "unused" }, /* BSD_FS_UNUSED */ + { "\x01" "swap" }, /* BSD_FS_SWAP */ + { "\x02" "Version 6" }, /* BSD_FS_V6 */ + { "\x03" "Version 7" }, /* BSD_FS_V7 */ + { "\x04" "System V" }, /* BSD_FS_SYSV */ + { "\x05" "4.1BSD" }, /* BSD_FS_V71K */ + { "\x06" "Eighth Edition" }, /* BSD_FS_V8 */ + { "\x07" "4.2BSD" }, /* BSD_FS_BSDFFS */ #ifdef __alpha__ -/* BSD_FS_EXT2 */ {"\x08" "ext2"}, + { "\x08" "ext2" }, /* BSD_FS_EXT2 */ #else -/* BSD_FS_MSDOS */ {"\x08" "MS-DOS"}, -#endif -/* BSD_FS_BSDLFS */ {"\x09" "4.4LFS"}, -/* BSD_FS_OTHER */ {"\x0a" "unknown"}, -/* BSD_FS_HPFS */ {"\x0b" "HPFS"}, -/* BSD_FS_ISO9660 */ {"\x0c" "ISO-9660"}, -/* BSD_FS_BOOT */ {"\x0d" "boot"}, -/* BSD_FS_ADOS */ {"\x0e" "ADOS"}, -/* BSD_FS_HFS */ {"\x0f" "HFS"}, -/* BSD_FS_ADVFS */ {"\x10" "AdvFS"}, - { NULL } + { "\x08" "MS-DOS" }, /* BSD_FS_MSDOS */ +#endif + { "\x09" "4.4LFS" }, /* BSD_FS_BSDLFS */ + { "\x0a" "unknown" }, /* BSD_FS_OTHER */ + { "\x0b" "HPFS" }, /* BSD_FS_HPFS */ + { "\x0c" "ISO-9660" }, /* BSD_FS_ISO9660 */ + { "\x0d" "boot" }, /* BSD_FS_BOOT */ + { "\x0e" "ADOS" }, /* BSD_FS_ADOS */ + { "\x0f" "HFS" }, /* BSD_FS_HFS */ + { "\x10" "AdvFS" }, /* BSD_FS_ADVFS */ + { NULL } }; #define BSD_FSMAXTYPES (SIZE(xbsd_fstypes)-1) @@ -854,28 +857,28 @@ typedef struct { #define FREEBSD_PARTITION 0xa5 #define NETBSD_PARTITION 0xa9 -static void xbsd_delete_part (void); -static void xbsd_new_part (void); -static void xbsd_write_disklabel (void); -static int xbsd_create_disklabel (void); -static void xbsd_edit_disklabel (void); -static void xbsd_write_bootstrap (void); -static void xbsd_change_fstype (void); -static int xbsd_get_part_index (int max); -static int xbsd_check_new_partition (int *i); -static void xbsd_list_types (void); -static u_short xbsd_dkcksum (struct xbsd_disklabel *lp); -static int xbsd_initlabel (struct partition *p, struct xbsd_disklabel *d); -static int xbsd_readlabel (struct partition *p, struct xbsd_disklabel *d); -static int xbsd_writelabel (struct partition *p, struct xbsd_disklabel *d); +static void xbsd_delete_part(void); +static void xbsd_new_part(void); +static void xbsd_write_disklabel(void); +static int xbsd_create_disklabel(void); +static void xbsd_edit_disklabel(void); +static void xbsd_write_bootstrap(void); +static void xbsd_change_fstype(void); +static int xbsd_get_part_index(int max); +static int xbsd_check_new_partition(int *i); +static void xbsd_list_types(void); +static u_short xbsd_dkcksum(struct xbsd_disklabel *lp); +static int xbsd_initlabel(struct partition *p, struct xbsd_disklabel *d); +static int xbsd_readlabel(struct partition *p, struct xbsd_disklabel *d); +static int xbsd_writelabel(struct partition *p, struct xbsd_disklabel *d); #if defined (__alpha__) -static void alpha_bootblock_checksum (char *boot); +static void alpha_bootblock_checksum(char *boot); #endif #if !defined (__alpha__) -static int xbsd_translate_fstype (int linux_type); -static void xbsd_link_part (void); +static int xbsd_translate_fstype(int linux_type); +static void xbsd_link_part(void); static struct partition *xbsd_part; static int xbsd_part_index; #endif @@ -899,8 +902,9 @@ static struct xbsd_disklabel xbsd_dlabel; * so this does not mean that there is a BSD disk label. */ static int -check_osf_label(void) { - if (xbsd_readlabel (NULL, &xbsd_dlabel) == 0) +check_osf_label(void) +{ + if (xbsd_readlabel(NULL, &xbsd_dlabel) == 0) return 0; return 1; } @@ -908,7 +912,8 @@ check_osf_label(void) { static void xbsd_print_disklabel(int); static int -btrydev (const char * dev) { +btrydev(const char * dev) +{ if (xbsd_readlabel (NULL, &xbsd_dlabel) == 0) return -1; printf(_("\nBSD label for device: %s\n"), dev); @@ -917,34 +922,37 @@ btrydev (const char * dev) { } static void -bmenu (void) { - puts (_("Command action")); - puts (_("\td\tdelete a BSD partition")); - puts (_("\te\tedit drive data")); - puts (_("\ti\tinstall bootstrap")); - puts (_("\tl\tlist known filesystem types")); - puts (_("\tm\tprint this menu")); - puts (_("\tn\tadd a new BSD partition")); - puts (_("\tp\tprint BSD partition table")); - puts (_("\tq\tquit without saving changes")); - puts (_("\tr\treturn to main menu")); - puts (_("\ts\tshow complete disklabel")); - puts (_("\tt\tchange a partition's filesystem id")); - puts (_("\tu\tchange units (cylinders/sectors)")); - puts (_("\tw\twrite disklabel to disk")); +bmenu(void) +{ + puts (_("Command action")); + puts (_("\td\tdelete a BSD partition")); + puts (_("\te\tedit drive data")); + puts (_("\ti\tinstall bootstrap")); + puts (_("\tl\tlist known filesystem types")); + puts (_("\tm\tprint this menu")); + puts (_("\tn\tadd a new BSD partition")); + puts (_("\tp\tprint BSD partition table")); + puts (_("\tq\tquit without saving changes")); + puts (_("\tr\treturn to main menu")); + puts (_("\ts\tshow complete disklabel")); + puts (_("\tt\tchange a partition's filesystem id")); + puts (_("\tu\tchange units (cylinders/sectors)")); + puts (_("\tw\twrite disklabel to disk")); #if !defined (__alpha__) - puts (_("\tx\tlink BSD partition to non-BSD partition")); + puts (_("\tx\tlink BSD partition to non-BSD partition")); #endif } #if !defined (__alpha__) static int -hidden(int type) { +hidden(int type) +{ return type ^ 0x10; } static int -is_bsd_partition_type(int type) { +is_bsd_partition_type(int type) +{ return (type == FREEBSD_PARTITION || type == hidden(FREEBSD_PARTITION) || type == NETBSD_PARTITION || @@ -953,273 +961,277 @@ is_bsd_partition_type(int type) { #endif static void -bselect (void) { +bselect(void) +{ #if !defined (__alpha__) - int t, ss; - struct partition *p; - - for (t=0; t<4; t++) { - p = get_part_table(t); - if (p && is_bsd_partition_type(p->sys_ind)) { - xbsd_part = p; - xbsd_part_index = t; - ss = get_start_sect(xbsd_part); - if (ss == 0) { - fprintf (stderr, _("Partition %s has invalid starting sector 0.\n"), - partname(disk_device, t+1, 0)); - return; - } - printf (_("Reading disklabel of %s at sector %d.\n"), - partname(disk_device, t+1, 0), ss + BSD_LABELSECTOR); - if (xbsd_readlabel (xbsd_part, &xbsd_dlabel) == 0) - if (xbsd_create_disklabel () == 0) - return; - break; - } - } - - if (t == 4) { - printf (_("There is no *BSD partition on %s.\n"), disk_device); - return; - } + int t, ss; + struct partition *p; + + for (t = 0; t < 4; t++) { + p = get_part_table(t); + if (p && is_bsd_partition_type(p->sys_ind)) { + xbsd_part = p; + xbsd_part_index = t; + ss = get_start_sect(xbsd_part); + if (ss == 0) { + fprintf(stderr, _("Partition %s has invalid starting sector 0.\n"), + partname(disk_device, t+1, 0)); + return; + } + printf(_("Reading disklabel of %s at sector %d.\n"), + partname(disk_device, t+1, 0), ss + BSD_LABELSECTOR); + if (xbsd_readlabel(xbsd_part, &xbsd_dlabel) == 0) + if (xbsd_create_disklabel() == 0) + return; + break; + } + } + + if (t == 4) { + printf(_("There is no *BSD partition on %s.\n"), disk_device); + return; + } #elif defined (__alpha__) - if (xbsd_readlabel (NULL, &xbsd_dlabel) == 0) - if (xbsd_create_disklabel () == 0) - exit ( EXIT_SUCCESS ); - -#endif - - while (1) { - putchar ('\n'); - switch (tolower (read_char (_("BSD disklabel command (m for help): ")))) { - case 'd': - xbsd_delete_part (); - break; - case 'e': - xbsd_edit_disklabel (); - break; - case 'i': - xbsd_write_bootstrap (); - break; - case 'l': - xbsd_list_types (); - break; - case 'n': - xbsd_new_part (); - break; - case 'p': - xbsd_print_disklabel (0); - break; - case 'q': - close (fd); - exit ( EXIT_SUCCESS ); - case 'r': - return; - case 's': - xbsd_print_disklabel (1); - break; - case 't': - xbsd_change_fstype (); - break; - case 'u': - change_units(); - break; - case 'w': - xbsd_write_disklabel (); - break; + if (xbsd_readlabel(NULL, &xbsd_dlabel) == 0) + if (xbsd_create_disklabel() == 0) + exit (EXIT_SUCCESS); + +#endif + + while (1) { + putchar('\n'); + switch (tolower(read_char(_("BSD disklabel command (m for help): ")))) { + case 'd': + xbsd_delete_part(); + break; + case 'e': + xbsd_edit_disklabel(); + break; + case 'i': + xbsd_write_bootstrap(); + break; + case 'l': + xbsd_list_types(); + break; + case 'n': + xbsd_new_part(); + break; + case 'p': + xbsd_print_disklabel(0); + break; + case 'q': + close(fd); + exit(EXIT_SUCCESS); + case 'r': + return; + case 's': + xbsd_print_disklabel(1); + break; + case 't': + xbsd_change_fstype(); + break; + case 'u': + change_units(); + break; + case 'w': + xbsd_write_disklabel(); + break; #if !defined (__alpha__) - case 'x': - xbsd_link_part (); - break; + case 'x': + xbsd_link_part(); + break; #endif - default: - bmenu (); - break; - } - } + default: + bmenu(); + break; + } + } } static void -xbsd_delete_part (void) +xbsd_delete_part(void) { - int i; + int i; - i = xbsd_get_part_index (xbsd_dlabel.d_npartitions); - xbsd_dlabel.d_partitions[i].p_size = 0; - xbsd_dlabel.d_partitions[i].p_offset = 0; - xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED; - if (xbsd_dlabel.d_npartitions == i + 1) - while (xbsd_dlabel.d_partitions[xbsd_dlabel.d_npartitions-1].p_size == 0) - xbsd_dlabel.d_npartitions--; + i = xbsd_get_part_index(xbsd_dlabel.d_npartitions); + xbsd_dlabel.d_partitions[i].p_size = 0; + xbsd_dlabel.d_partitions[i].p_offset = 0; + xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED; + if (xbsd_dlabel.d_npartitions == i + 1) + while (xbsd_dlabel.d_partitions[xbsd_dlabel.d_npartitions-1].p_size == 0) + xbsd_dlabel.d_npartitions--; } static void -xbsd_new_part (void) +xbsd_new_part(void) { - off_t begin, end; - char mesg[256]; - int i; + off_t begin, end; + char mesg[256]; + int i; - if (!xbsd_check_new_partition (&i)) - return; + if (!xbsd_check_new_partition(&i)) + return; #if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__) - begin = get_start_sect(xbsd_part); - end = begin + get_nr_sects(xbsd_part) - 1; + begin = get_start_sect(xbsd_part); + end = begin + get_nr_sects(xbsd_part) - 1; #else - begin = 0; - end = xbsd_dlabel.d_secperunit - 1; + begin = 0; + end = xbsd_dlabel.d_secperunit - 1; #endif - snprintf (mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR)); - begin = read_int (bsd_cround (begin), bsd_cround (begin), bsd_cround (end), - 0, mesg); + snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR)); + begin = read_int(bsd_cround(begin), bsd_cround(begin), bsd_cround(end), + 0, mesg); - if (display_in_cyl_units) - begin = (begin - 1) * xbsd_dlabel.d_secpercyl; + if (display_in_cyl_units) + begin = (begin - 1) * xbsd_dlabel.d_secpercyl; - snprintf (mesg, sizeof(mesg), _("Last %s or +size or +sizeM or +sizeK"), - str_units(SINGULAR)); - end = read_int (bsd_cround (begin), bsd_cround (end), bsd_cround (end), - bsd_cround (begin), mesg); + snprintf(mesg, sizeof(mesg), _("Last %s or +size or +sizeM or +sizeK"), + str_units(SINGULAR)); + end = read_int(bsd_cround (begin), bsd_cround (end), bsd_cround (end), + bsd_cround (begin), mesg); - if (display_in_cyl_units) - end = end * xbsd_dlabel.d_secpercyl - 1; + if (display_in_cyl_units) + end = end * xbsd_dlabel.d_secpercyl - 1; - xbsd_dlabel.d_partitions[i].p_size = end - begin + 1; - xbsd_dlabel.d_partitions[i].p_offset = begin; - xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED; + xbsd_dlabel.d_partitions[i].p_size = end - begin + 1; + xbsd_dlabel.d_partitions[i].p_offset = begin; + xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED; } static void -xbsd_print_disklabel (int show_all) { - struct xbsd_disklabel *lp = &xbsd_dlabel; - struct xbsd_partition *pp; - int i, j; +xbsd_print_disklabel(int show_all) +{ + struct xbsd_disklabel *lp = &xbsd_dlabel; + struct xbsd_partition *pp; + int i, j; - if (show_all) { + if (show_all) { #if defined (__alpha__) - printf("# %s:\n", disk_device); + printf("# %s:\n", disk_device); #else - printf("# %s:\n", partname(disk_device, xbsd_part_index+1, 0)); -#endif - if ((unsigned) lp->d_type < BSD_DKMAXTYPES) - printf(_("type: %s\n"), xbsd_dktypenames[lp->d_type]); - else - printf(_("type: %d\n"), lp->d_type); - printf(_("disk: %.*s\n"), (int) sizeof(lp->d_typename), lp->d_typename); - printf(_("label: %.*s\n"), (int) sizeof(lp->d_packname), lp->d_packname); - printf(_("flags:")); - if (lp->d_flags & BSD_D_REMOVABLE) - printf(_(" removable")); - if (lp->d_flags & BSD_D_ECC) - printf(_(" ecc")); - if (lp->d_flags & BSD_D_BADSECT) - printf(_(" badsect")); - printf("\n"); - /* On various machines the fields of *lp are short/int/long */ - /* In order to avoid problems, we cast them all to long. */ - printf(_("bytes/sector: %ld\n"), (long) lp->d_secsize); - printf(_("sectors/track: %ld\n"), (long) lp->d_nsectors); - printf(_("tracks/cylinder: %ld\n"), (long) lp->d_ntracks); - printf(_("sectors/cylinder: %ld\n"), (long) lp->d_secpercyl); - printf(_("cylinders: %ld\n"), (long) lp->d_ncylinders); - printf(_("rpm: %d\n"), lp->d_rpm); - printf(_("interleave: %d\n"), lp->d_interleave); - printf(_("trackskew: %d\n"), lp->d_trackskew); - printf(_("cylinderskew: %d\n"), lp->d_cylskew); - printf(_("headswitch: %ld\t\t# milliseconds\n"), - (long) lp->d_headswitch); - printf(_("track-to-track seek: %ld\t# milliseconds\n"), - (long) lp->d_trkseek); - printf(_("drivedata: ")); - for (i = NDDATA - 1; i >= 0; i--) - if (lp->d_drivedata[i]) - break; - if (i < 0) - i = 0; - for (j = 0; j <= i; j++) - printf("%ld ", (long) lp->d_drivedata[j]); - } - printf(_("\n%d partitions:\n"), lp->d_npartitions); - printf(_("# start end size fstype [fsize bsize cpg]\n")); - pp = lp->d_partitions; - for (i = 0; i < lp->d_npartitions; i++, pp++) { - if (pp->p_size) { - if (display_in_cyl_units && lp->d_secpercyl) { - printf(" %c: %8ld%c %8ld%c %8ld%c ", - 'a' + i, - (long) pp->p_offset / lp->d_secpercyl + 1, - (pp->p_offset % lp->d_secpercyl) ? '*' : ' ', - (long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) - / lp->d_secpercyl, - ((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ', - (long) pp->p_size / lp->d_secpercyl, - (pp->p_size % lp->d_secpercyl) ? '*' : ' '); - } else { - printf(" %c: %8ld %8ld %8ld ", - 'a' + i, - (long) pp->p_offset, - (long) pp->p_offset + pp->p_size - 1, - (long) pp->p_size); - } - if ((unsigned) pp->p_fstype < BSD_FSMAXTYPES) - printf("%8.8s", xbsd_fstypes[pp->p_fstype].name); - else - printf("%8x", pp->p_fstype); - switch (pp->p_fstype) { - case BSD_FS_UNUSED: - printf(" %5ld %5ld %5.5s ", - (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, ""); - break; - - case BSD_FS_BSDFFS: - printf(" %5ld %5ld %5d ", - (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, - pp->p_cpg); - break; + printf("# %s:\n", partname(disk_device, xbsd_part_index+1, 0)); +#endif + if ((unsigned) lp->d_type < BSD_DKMAXTYPES) + printf(_("type: %s\n"), xbsd_dktypenames[lp->d_type]); + else + printf(_("type: %d\n"), lp->d_type); + printf(_("disk: %.*s\n"), (int) sizeof(lp->d_typename), lp->d_typename); + printf(_("label: %.*s\n"), (int) sizeof(lp->d_packname), lp->d_packname); + printf(_("flags:")); + if (lp->d_flags & BSD_D_REMOVABLE) + printf(_(" removable")); + if (lp->d_flags & BSD_D_ECC) + printf(_(" ecc")); + if (lp->d_flags & BSD_D_BADSECT) + printf(_(" badsect")); + printf("\n"); + /* On various machines the fields of *lp are short/int/long */ + /* In order to avoid problems, we cast them all to long. */ + printf(_("bytes/sector: %ld\n"), (long) lp->d_secsize); + printf(_("sectors/track: %ld\n"), (long) lp->d_nsectors); + printf(_("tracks/cylinder: %ld\n"), (long) lp->d_ntracks); + printf(_("sectors/cylinder: %ld\n"), (long) lp->d_secpercyl); + printf(_("cylinders: %ld\n"), (long) lp->d_ncylinders); + printf(_("rpm: %d\n"), lp->d_rpm); + printf(_("interleave: %d\n"), lp->d_interleave); + printf(_("trackskew: %d\n"), lp->d_trackskew); + printf(_("cylinderskew: %d\n"), lp->d_cylskew); + printf(_("headswitch: %ld\t\t# milliseconds\n"), + (long) lp->d_headswitch); + printf(_("track-to-track seek: %ld\t# milliseconds\n"), + (long) lp->d_trkseek); + printf(_("drivedata: ")); + for (i = NDDATA - 1; i >= 0; i--) + if (lp->d_drivedata[i]) + break; + if (i < 0) + i = 0; + for (j = 0; j <= i; j++) + printf("%ld ", (long) lp->d_drivedata[j]); + } + printf(_("\n%d partitions:\n"), lp->d_npartitions); + printf(_("# start end size fstype [fsize bsize cpg]\n")); + pp = lp->d_partitions; + for (i = 0; i < lp->d_npartitions; i++, pp++) { + if (pp->p_size) { + if (display_in_cyl_units && lp->d_secpercyl) { + printf(" %c: %8ld%c %8ld%c %8ld%c ", + 'a' + i, + (long) pp->p_offset / lp->d_secpercyl + 1, + (pp->p_offset % lp->d_secpercyl) ? '*' : ' ', + (long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl, + ((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ', + (long) pp->p_size / lp->d_secpercyl, + (pp->p_size % lp->d_secpercyl) ? '*' : ' ' + ); + } else { + printf(" %c: %8ld %8ld %8ld ", + 'a' + i, + (long) pp->p_offset, + (long) pp->p_offset + pp->p_size - 1, + (long) pp->p_size + ); + } - default: - printf("%22.22s", ""); - break; - } - printf("\n"); - } - } + if ((unsigned) pp->p_fstype < BSD_FSMAXTYPES) + printf("%8.8s", xbsd_fstypes[pp->p_fstype].name); + else + printf("%8x", pp->p_fstype); + + switch (pp->p_fstype) { + case BSD_FS_UNUSED: + printf(" %5ld %5ld %5.5s ", + (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, ""); + break; + case BSD_FS_BSDFFS: + printf(" %5ld %5ld %5d ", + (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, pp->p_cpg); + break; + default: + printf("%22.22s", ""); + break; + } + printf("\n"); + } + } } static void -xbsd_write_disklabel (void) { +xbsd_write_disklabel(void) +{ #if defined (__alpha__) - printf (_("Writing disklabel to %s.\n"), disk_device); - xbsd_writelabel (NULL, &xbsd_dlabel); + printf(_("Writing disklabel to %s.\n"), disk_device); + xbsd_writelabel(NULL, &xbsd_dlabel); #else - printf (_("Writing disklabel to %s.\n"), - partname(disk_device, xbsd_part_index+1, 0)); - xbsd_writelabel (xbsd_part, &xbsd_dlabel); + printf(_("Writing disklabel to %s.\n"), + partname(disk_device, xbsd_part_index + 1, 0)); + xbsd_writelabel(xbsd_part, &xbsd_dlabel); #endif reread_partition_table(0); /* no exit yet */ } static int -xbsd_create_disklabel (void) { +xbsd_create_disklabel(void) +{ char c; #if defined (__alpha__) - fprintf (stderr, _("%s contains no disklabel.\n"), disk_device); + fprintf(stderr, _("%s contains no disklabel.\n"), disk_device); #else - fprintf (stderr, _("%s contains no disklabel.\n"), - partname(disk_device, xbsd_part_index+1, 0)); + fprintf(stderr, _("%s contains no disklabel.\n"), + partname(disk_device, xbsd_part_index + 1, 0)); #endif while (1) { - c = read_char (_("Do you want to create a disklabel? (y/n) ")); + c = read_char(_("Do you want to create a disklabel? (y/n) ")); if (c == 'y' || c == 'Y') { - if (xbsd_initlabel ( + if (xbsd_initlabel( #if defined (__alpha__) || defined (__powerpc__) || defined (__hppa__) || \ - defined (__s390__) || defined (__s390x__) + defined (__s390__) || defined (__s390x__) NULL, &xbsd_dlabel #else xbsd_part, &xbsd_dlabel/* not used, xbsd_part_index*/ @@ -1235,176 +1247,173 @@ xbsd_create_disklabel (void) { } static int -edit_int (int def, char *mesg) +edit_int(int def, char *mesg) { - do { - fputs (mesg, stdout); - printf (" (%d): ", def); - if (!read_line ()) - return def; - } - while (!isdigit (*line_ptr)); - return atoi (line_ptr); + do { + fputs(mesg, stdout); + printf(" (%d): ", def); + if (!read_line()) + return def; + } + while (!isdigit(*line_ptr)); /* FIXME: ?!! */ + return atoi(line_ptr); } static void -xbsd_edit_disklabel (void) +xbsd_edit_disklabel(void) { - struct xbsd_disklabel *d; + struct xbsd_disklabel *d; - d = &xbsd_dlabel; + d = &xbsd_dlabel; #if defined (__alpha__) || defined (__ia64__) - d -> d_secsize = (u_long) edit_int ((u_long) d -> d_secsize ,_("bytes/sector")); - d -> d_nsectors = (u_long) edit_int ((u_long) d -> d_nsectors ,_("sectors/track")); - d -> d_ntracks = (u_long) edit_int ((u_long) d -> d_ntracks ,_("tracks/cylinder")); - d -> d_ncylinders = (u_long) edit_int ((u_long) d -> d_ncylinders ,_("cylinders")); + d->d_secsize = (u_long) edit_int((u_long) d->d_secsize ,_("bytes/sector")); + d->d_nsectors = (u_long) edit_int((u_long) d->d_nsectors ,_("sectors/track")); + d->d_ntracks = (u_long) edit_int((u_long) d->d_ntracks ,_("tracks/cylinder")); + d->d_ncylinders = (u_long) edit_int((u_long) d->d_ncylinders ,_("cylinders")); #endif - /* d -> d_secpercyl can be != d -> d_nsectors * d -> d_ntracks */ - while (1) - { - d -> d_secpercyl = (u_long) edit_int ((u_long) d -> d_nsectors * d -> d_ntracks, - _("sectors/cylinder")); - if (d -> d_secpercyl <= d -> d_nsectors * d -> d_ntracks) - break; + /* d->d_secpercyl can be != d->d_nsectors * d->d_ntracks */ + while (1) { + d->d_secpercyl = (u_long) edit_int((u_long) d->d_nsectors * d->d_ntracks, + _("sectors/cylinder")); + if (d->d_secpercyl <= d->d_nsectors * d->d_ntracks) + break; - printf (_("Must be <= sectors/track * tracks/cylinder (default).\n")); - } - d -> d_rpm = (u_short) edit_int ((u_short) d -> d_rpm ,_("rpm")); - d -> d_interleave = (u_short) edit_int ((u_short) d -> d_interleave,_("interleave")); - d -> d_trackskew = (u_short) edit_int ((u_short) d -> d_trackskew ,_("trackskew")); - d -> d_cylskew = (u_short) edit_int ((u_short) d -> d_cylskew ,_("cylinderskew")); - d -> d_headswitch = (u_long) edit_int ((u_long) d -> d_headswitch ,_("headswitch")); - d -> d_trkseek = (u_long) edit_int ((u_long) d -> d_trkseek ,_("track-to-track seek")); + printf(_("Must be <= sectors/track * tracks/cylinder (default).\n")); + } + d->d_rpm = (u_short) edit_int((u_short) d->d_rpm ,_("rpm")); + d->d_interleave = (u_short) edit_int((u_short) d->d_interleave,_("interleave")); + d->d_trackskew = (u_short) edit_int((u_short) d->d_trackskew ,_("trackskew")); + d->d_cylskew = (u_short) edit_int((u_short) d->d_cylskew ,_("cylinderskew")); + d->d_headswitch = (u_long) edit_int((u_long) d->d_headswitch ,_("headswitch")); + d->d_trkseek = (u_long) edit_int((u_long) d->d_trkseek ,_("track-to-track seek")); - d -> d_secperunit = d -> d_secpercyl * d -> d_ncylinders; + d->d_secperunit = d->d_secpercyl * d->d_ncylinders; } static int xbsd_get_bootstrap (char *path, void *ptr, int size) { - int fdb; + int fdb; - if ((fdb = open (path, O_RDONLY)) < 0) - { - perror (path); - return 0; - } - if (read (fdb, ptr, size) < 0) - { - perror (path); - close (fdb); - return 0; - } - printf (" ... %s\n", path); - close (fdb); - return 1; + if ((fdb = open (path, O_RDONLY)) < 0) { + perror(path); + return 0; + } + if (read(fdb, ptr, size) < 0) { + perror(path); + close(fdb); + return 0; + } + printf(" ... %s\n", path); + close(fdb); + return 1; } static void -sync_disks (void) +sync_disks(void) { - printf (_("\nSyncing disks.\n")); - sync (); - sleep (4); + printf(_("\nSyncing disks.\n")); + sync(); + sleep(4); /* What? */ } static void -xbsd_write_bootstrap (void) -{ - char *bootdir = BSD_LINUX_BOOTDIR; - char path[MAXPATHLEN]; - char *dkbasename; - struct xbsd_disklabel dl; - char *d, *p, *e; - int sector; - - if (xbsd_dlabel.d_type == BSD_DTYPE_SCSI) - dkbasename = "sd"; - else - dkbasename = "wd"; - - printf (_("Bootstrap: %sboot -> boot%s (%s): "), - dkbasename, dkbasename, dkbasename); - if (read_line ()) { - line_ptr[strlen (line_ptr)-1] = '\0'; - dkbasename = line_ptr; - } - snprintf (path, sizeof(path), "%s/%sboot", bootdir, dkbasename); - if (!xbsd_get_bootstrap (path, disklabelbuffer, (int) xbsd_dlabel.d_secsize)) - return; - - /* We need a backup of the disklabel (xbsd_dlabel might have changed). */ - d = &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE]; - bcopy (d, &dl, sizeof (struct xbsd_disklabel)); - - /* The disklabel will be overwritten by 0's from bootxx anyway */ - memset (d, 0, sizeof (struct xbsd_disklabel)); - - snprintf (path, sizeof(path), "%s/boot%s", bootdir, dkbasename); - if (!xbsd_get_bootstrap (path, &disklabelbuffer[xbsd_dlabel.d_secsize], +xbsd_write_bootstrap(void) +{ + char *bootdir = BSD_LINUX_BOOTDIR; + char path[MAXPATHLEN]; + char *dkbasename; + struct xbsd_disklabel dl; + char *d, *p, *e; + int sector; + + if (xbsd_dlabel.d_type == BSD_DTYPE_SCSI) + dkbasename = "sd"; + else + dkbasename = "wd"; + + printf(_("Bootstrap: %sboot -> boot%s (%s): "), + dkbasename, dkbasename, dkbasename); + if (read_line()) { + line_ptr[strlen(line_ptr)-1] = '\0'; + dkbasename = line_ptr; + } + snprintf(path, sizeof(path), "%s/%sboot", bootdir, dkbasename); + if (!xbsd_get_bootstrap(path, disklabelbuffer, (int) xbsd_dlabel.d_secsize)) + return; + +/* We need a backup of the disklabel (xbsd_dlabel might have changed). */ + d = &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE]; + bcopy(d, &dl, sizeof(struct xbsd_disklabel)); + +/* The disklabel will be overwritten by 0's from bootxx anyway */ + memset(d, 0, sizeof(struct xbsd_disklabel)); + + snprintf(path, sizeof(path), "%s/boot%s", bootdir, dkbasename); + if (!xbsd_get_bootstrap (path, &disklabelbuffer[xbsd_dlabel.d_secsize], (int) xbsd_dlabel.d_bbsize - xbsd_dlabel.d_secsize)) - return; + return; - e = d + sizeof (struct xbsd_disklabel); - for (p=d; p < e; p++) - if (*p) { - fprintf (stderr, _("Bootstrap overlaps with disk label!\n")); - exit ( EXIT_FAILURE ); - } + e = d + sizeof(struct xbsd_disklabel); + for (p = d; p < e; p++) + if (*p) { + fprintf(stderr, _("Bootstrap overlaps with disk label!\n")); + exit(EXIT_FAILURE); + } - bcopy (&dl, d, sizeof (struct xbsd_disklabel)); + bcopy(&dl, d, sizeof(struct xbsd_disklabel)); #if defined (__powerpc__) || defined (__hppa__) - sector = 0; + sector = 0; #elif defined (__alpha__) - sector = 0; - alpha_bootblock_checksum (disklabelbuffer); + sector = 0; + alpha_bootblock_checksum(disklabelbuffer); #else - sector = get_start_sect(xbsd_part); + sector = get_start_sect(xbsd_part); #endif - if (lseek (fd, sector * SECTOR_SIZE, SEEK_SET) == -1) - fdisk_fatal (unable_to_seek); - if (BSD_BBSIZE != write (fd, disklabelbuffer, BSD_BBSIZE)) - fdisk_fatal (unable_to_write); + if (lseek(fd, sector * SECTOR_SIZE, SEEK_SET) == -1) + fdisk_fatal(unable_to_seek); + if (BSD_BBSIZE != write(fd, disklabelbuffer, BSD_BBSIZE)) + fdisk_fatal(unable_to_write); #if defined (__alpha__) - printf (_("Bootstrap installed on %s.\n"), disk_device); + printf(_("Bootstrap installed on %s.\n"), disk_device); #else - printf (_("Bootstrap installed on %s.\n"), - partname (disk_device, xbsd_part_index+1, 0)); + printf(_("Bootstrap installed on %s.\n"), + partname (disk_device, xbsd_part_index+1, 0)); #endif - sync_disks (); + sync_disks(); } static void -xbsd_change_fstype (void) +xbsd_change_fstype(void) { - int i; + int i; - i = xbsd_get_part_index (xbsd_dlabel.d_npartitions); - xbsd_dlabel.d_partitions[i].p_fstype = read_hex (xbsd_fstypes); + i = xbsd_get_part_index(xbsd_dlabel.d_npartitions); + xbsd_dlabel.d_partitions[i].p_fstype = read_hex(xbsd_fstypes); } static int -xbsd_get_part_index (int max) +xbsd_get_part_index(int max) { - char prompt[256]; - char l; + char prompt[256]; + char l; - snprintf (prompt, sizeof(prompt), _("Partition (a-%c): "), 'a' + max - 1); - do - l = tolower (read_char (prompt)); - while (l < 'a' || l > 'a' + max - 1); - return l - 'a'; + snprintf(prompt, sizeof(prompt), _("Partition (a-%c): "), 'a' + max - 1); + do + l = tolower(read_char(prompt)); + while (l < 'a' || l > 'a' + max - 1); + return l - 'a'; } static int -xbsd_check_new_partition (int *i) { - +xbsd_check_new_partition(int *i) +{ /* room for more? various BSD flavours have different maxima */ if (xbsd_dlabel.d_npartitions == BSD_MAXPARTITIONS) { int t; @@ -1414,7 +1423,7 @@ xbsd_check_new_partition (int *i) { break; if (t == BSD_MAXPARTITIONS) { - fprintf (stderr, _("The maximum number of partitions " + fprintf(stderr, _("The maximum number of partitions " "has been created\n")); return 0; } @@ -1426,7 +1435,7 @@ xbsd_check_new_partition (int *i) { xbsd_dlabel.d_npartitions = (*i) + 1; if (xbsd_dlabel.d_partitions[*i].p_size != 0) { - fprintf (stderr, _("This partition already exists.\n")); + fprintf(stderr, _("This partition already exists.\n")); return 0; } @@ -1434,12 +1443,14 @@ xbsd_check_new_partition (int *i) { } static void -xbsd_list_types (void) { - list_types (xbsd_fstypes); +xbsd_list_types(void) +{ + list_types(xbsd_fstypes); } static u_short -xbsd_dkcksum (struct xbsd_disklabel *lp) { +xbsd_dkcksum(struct xbsd_disklabel *lp) +{ u_short *start, *end; u_short sum = 0; @@ -1451,67 +1462,68 @@ xbsd_dkcksum (struct xbsd_disklabel *lp) { } static int -xbsd_initlabel (struct partition *p, struct xbsd_disklabel *d) { +xbsd_initlabel(struct partition *p, struct xbsd_disklabel *d) +{ struct xbsd_partition *pp; - get_geometry (); - memset (d, 0, sizeof (struct xbsd_disklabel)); + get_geometry(); + memset(d, 0, sizeof(struct xbsd_disklabel)); - d -> d_magic = BSD_DISKMAGIC; + d->d_magic = BSD_DISKMAGIC; - if (strncmp (disk_device, "/dev/sd", 7) == 0) - d -> d_type = BSD_DTYPE_SCSI; + if (strncmp(disk_device, "/dev/sd", 7) == 0) + d->d_type = BSD_DTYPE_SCSI; else - d -> d_type = BSD_DTYPE_ST506; + d->d_type = BSD_DTYPE_ST506; #if 0 /* not used (at least not written to disk) by NetBSD/i386 1.0 */ - d -> d_subtype = BSD_DSTYPE_INDOSPART & pindex; + d->d_subtype = BSD_DSTYPE_INDOSPART & pindex; #endif #if !defined (__alpha__) - d -> d_flags = BSD_D_DOSPART; + d->d_flags = BSD_D_DOSPART; #else - d -> d_flags = 0; -#endif - d -> d_secsize = SECTOR_SIZE; /* bytes/sector */ - d -> d_nsectors = sectors; /* sectors/track */ - d -> d_ntracks = heads; /* tracks/cylinder (heads) */ - d -> d_ncylinders = cylinders; - d -> d_secpercyl = sectors * heads;/* sectors/cylinder */ - if (d -> d_secpercyl == 0) - d -> d_secpercyl = 1; /* avoid segfaults */ - d -> d_secperunit = d -> d_secpercyl * d -> d_ncylinders; - - d -> d_rpm = 3600; - d -> d_interleave = 1; - d -> d_trackskew = 0; - d -> d_cylskew = 0; - d -> d_headswitch = 0; - d -> d_trkseek = 0; - - d -> d_magic2 = BSD_DISKMAGIC; - d -> d_bbsize = BSD_BBSIZE; - d -> d_sbsize = BSD_SBSIZE; + d->d_flags = 0; +#endif + d->d_secsize = SECTOR_SIZE; /* bytes/sector */ + d->d_nsectors = sectors; /* sectors/track */ + d->d_ntracks = heads; /* tracks/cylinder (heads) */ + d->d_ncylinders = cylinders; + d->d_secpercyl = sectors * heads;/* sectors/cylinder */ + if (d->d_secpercyl == 0) + d->d_secpercyl = 1; /* avoid segfaults */ + d->d_secperunit = d->d_secpercyl * d->d_ncylinders; + + d->d_rpm = 3600; + d->d_interleave = 1; + d->d_trackskew = 0; + d->d_cylskew = 0; + d->d_headswitch = 0; + d->d_trkseek = 0; + + d->d_magic2 = BSD_DISKMAGIC; + d->d_bbsize = BSD_BBSIZE; + d->d_sbsize = BSD_SBSIZE; #if !defined (__alpha__) - d -> d_npartitions = 4; - pp = &d -> d_partitions[2]; /* Partition C should be + d->d_npartitions = 4; + pp = &d->d_partitions[2]; /* Partition C should be the NetBSD partition */ - pp -> p_offset = get_start_sect(p); - pp -> p_size = get_nr_sects(p); - pp -> p_fstype = BSD_FS_UNUSED; - pp = &d -> d_partitions[3]; /* Partition D should be + pp->p_offset = get_start_sect(p); + pp->p_size = get_nr_sects(p); + pp->p_fstype = BSD_FS_UNUSED; + pp = &d->d_partitions[3]; /* Partition D should be the whole disk */ - pp -> p_offset = 0; - pp -> p_size = d -> d_secperunit; - pp -> p_fstype = BSD_FS_UNUSED; + pp->p_offset = 0; + pp->p_size = d->d_secperunit; + pp->p_fstype = BSD_FS_UNUSED; #elif defined (__alpha__) - d -> d_npartitions = 3; - pp = &d -> d_partitions[2]; /* Partition C should be + d->d_npartitions = 3; + pp = &d->d_partitions[2]; /* Partition C should be the whole disk */ - pp -> p_offset = 0; - pp -> p_size = d -> d_secperunit; - pp -> p_fstype = BSD_FS_UNUSED; + pp->p_offset = 0; + pp->p_size = d->d_secperunit; + pp->p_fstype = BSD_FS_UNUSED; #endif return 1; @@ -1533,106 +1545,102 @@ xbsd_readlabel (struct partition *p, struct xbsd_disklabel *d) sector = 0; #endif - if (lseek (fd, sector * SECTOR_SIZE, SEEK_SET) == -1) - fdisk_fatal (unable_to_seek); - if (BSD_BBSIZE != read (fd, disklabelbuffer, BSD_BBSIZE)) - fdisk_fatal (unable_to_read); + if (lseek(fd, sector * SECTOR_SIZE, SEEK_SET) == -1) + fdisk_fatal(unable_to_seek); + if (BSD_BBSIZE != read(fd, disklabelbuffer, BSD_BBSIZE)) + fdisk_fatal(unable_to_read); - bcopy (&disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET], - d, sizeof (struct xbsd_disklabel)); + bcopy(&disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET], + d, sizeof(struct xbsd_disklabel)); - if (d -> d_magic != BSD_DISKMAGIC || d -> d_magic2 != BSD_DISKMAGIC) + if (d->d_magic != BSD_DISKMAGIC || d->d_magic2 != BSD_DISKMAGIC) return 0; - for (t = d -> d_npartitions; t < BSD_MAXPARTITIONS; t++) { - d -> d_partitions[t].p_size = 0; - d -> d_partitions[t].p_offset = 0; - d -> d_partitions[t].p_fstype = BSD_FS_UNUSED; + for (t = d->d_npartitions; t < BSD_MAXPARTITIONS; t++) { + d->d_partitions[t].p_size = 0; + d->d_partitions[t].p_offset = 0; + d->d_partitions[t].p_fstype = BSD_FS_UNUSED; } - if (d -> d_npartitions > BSD_MAXPARTITIONS) - fprintf (stderr, _("Warning: too many partitions " - "(%d, maximum is %d).\n"), - d -> d_npartitions, BSD_MAXPARTITIONS); + if (d->d_npartitions > BSD_MAXPARTITIONS) + fprintf(stderr, _("Warning: too many partitions " + "(%d, maximum is %d).\n"), + d->d_npartitions, BSD_MAXPARTITIONS); return 1; } static int xbsd_writelabel (struct partition *p, struct xbsd_disklabel *d) { - unsigned int sector; + unsigned int sector; #if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__) - sector = get_start_sect(p) + BSD_LABELSECTOR; + sector = get_start_sect(p) + BSD_LABELSECTOR; #else - sector = BSD_LABELSECTOR; + sector = BSD_LABELSECTOR; #endif - d -> d_checksum = 0; - d -> d_checksum = xbsd_dkcksum (d); + d->d_checksum = 0; + d->d_checksum = xbsd_dkcksum (d); - /* This is necessary if we want to write the bootstrap later, - otherwise we'd write the old disklabel with the bootstrap. - */ - bcopy (d, &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET], - sizeof (struct xbsd_disklabel)); + /* This is necessary if we want to write the bootstrap later, + otherwise we'd write the old disklabel with the bootstrap. + */ + bcopy(d, &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET], + sizeof(struct xbsd_disklabel)); #if defined (__alpha__) && BSD_LABELSECTOR == 0 - alpha_bootblock_checksum (disklabelbuffer); - if (lseek (fd, 0, SEEK_SET) == -1) - fdisk_fatal (unable_to_seek); - if (BSD_BBSIZE != write (fd, disklabelbuffer, BSD_BBSIZE)) - fdisk_fatal (unable_to_write); + alpha_bootblock_checksum (disklabelbuffer); + if (lseek(fd, 0, SEEK_SET) == -1) + fdisk_fatal(unable_to_seek); + if (BSD_BBSIZE != write(fd, disklabelbuffer, BSD_BBSIZE)) + fdisk_fatal(unable_to_write); #else - if (lseek (fd, sector * SECTOR_SIZE + BSD_LABELOFFSET, - SEEK_SET) == -1) - fdisk_fatal (unable_to_seek); - if (sizeof (struct xbsd_disklabel) != write (fd, d, sizeof (struct xbsd_disklabel))) - fdisk_fatal (unable_to_write); + if (lseek(fd, sector * SECTOR_SIZE + BSD_LABELOFFSET, SEEK_SET) == -1) + fdisk_fatal(unable_to_seek); + if (sizeof(struct xbsd_disklabel) != write(fd, d, sizeof(struct xbsd_disklabel))) + fdisk_fatal(unable_to_write); #endif - - sync_disks (); - - return 1; + sync_disks(); + return 1; } #if !defined (__alpha__) static int -xbsd_translate_fstype (int linux_type) -{ - switch (linux_type) - { - case 0x01: /* DOS 12-bit FAT */ - case 0x04: /* DOS 16-bit <32M */ - case 0x06: /* DOS 16-bit >=32M */ - case 0xe1: /* DOS access */ - case 0xe3: /* DOS R/O */ - case 0xf2: /* DOS secondary */ - return BSD_FS_MSDOS; - case 0x07: /* OS/2 HPFS */ - return BSD_FS_HPFS; - default: - return BSD_FS_OTHER; - } +xbsd_translate_fstype(int linux_type) +{ + switch (linux_type) { + case 0x01: /* DOS 12-bit FAT */ + case 0x04: /* DOS 16-bit <32M */ + case 0x06: /* DOS 16-bit >=32M */ + case 0xe1: /* DOS access */ + case 0xe3: /* DOS R/O */ + case 0xf2: /* DOS secondary */ + return BSD_FS_MSDOS; + case 0x07: /* OS/2 HPFS */ + return BSD_FS_HPFS; + default: + return BSD_FS_OTHER; + } } static void -xbsd_link_part (void) +xbsd_link_part(void) { - int k, i; - struct partition *p; + int k, i; + struct partition *p; - k = get_partition (1, partitions); + k = get_partition(1, partitions); - if (!xbsd_check_new_partition (&i)) - return; + if (!xbsd_check_new_partition(&i)) + return; - p = get_part_table(k); + p = get_part_table(k); - xbsd_dlabel.d_partitions[i].p_size = get_nr_sects(p); - xbsd_dlabel.d_partitions[i].p_offset = get_start_sect(p); - xbsd_dlabel.d_partitions[i].p_fstype = xbsd_translate_fstype(p->sys_ind); + xbsd_dlabel.d_partitions[i].p_size = get_nr_sects(p); + xbsd_dlabel.d_partitions[i].p_offset = get_start_sect(p); + xbsd_dlabel.d_partitions[i].p_fstype = xbsd_translate_fstype(p->sys_ind); } #endif @@ -1643,16 +1651,16 @@ typedef unsigned long long uint64_t; #endif static void -alpha_bootblock_checksum (char *boot) +alpha_bootblock_checksum(char *boot) { - uint64_t *dp, sum; - int i; + uint64_t *dp, sum; + int i; - dp = (uint64_t *)boot; - sum = 0; - for (i = 0; i < 63; i++) - sum += dp[i]; - dp[63] = sum; + dp = (uint64_t *)boot; + sum = 0; + for (i = 0; i < 63; i++) + sum += dp[i]; + dp[63] = sum; } #endif /* __alpha__ */ @@ -1660,13 +1668,15 @@ alpha_bootblock_checksum (char *boot) #if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL) static inline unsigned short -__swap16(unsigned short x) { +__swap16(unsigned short x) +{ return (((uint16_t)(x) & 0xFF) << 8) | (((uint16_t)(x) & 0xFF00) >> 8); } static inline uint32_t -__swap32(uint32_t x) { - return (((x & 0xFF) << 24) | +__swap32(uint32_t x) +{ + return (((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) | ((x & 0xFF000000) >> 24)); @@ -1687,34 +1697,40 @@ __swap32(uint32_t x) { */ -static int sgi_other_endian; -static int debug; -static short sgi_volumes=1; +static int sgi_other_endian; +static int debug; +static short sgi_volumes = 1; /* * only dealing with free blocks here */ -typedef struct { unsigned int first; unsigned int last; } freeblocks; +typedef struct { + unsigned int first; + unsigned int last; +} freeblocks; static freeblocks freelist[17]; /* 16 partitions can produce 17 vacant slots */ static void -setfreelist(int i, unsigned int f, unsigned int l) { +setfreelist(int i, unsigned int f, unsigned int l) +{ freelist[i].first = f; freelist[i].last = l; } static void -add2freelist(unsigned int f, unsigned int l) { - int i = 0; - for ( ; i < 17 ; i++) +add2freelist(unsigned int f, unsigned int l) +{ + int i; + for (i = 0; i < 17 ; i++) if (freelist[i].last == 0) break; setfreelist(i, f, l); } static void -clearfreelist(void) { +clearfreelist(void) +{ int i; for (i = 0; i < 17 ; i++) @@ -1722,7 +1738,8 @@ clearfreelist(void) { } static unsigned int -isinfreelist(unsigned int b) { +isinfreelist(unsigned int b) +{ int i; for (i = 0; i < 17 ; i++) @@ -1737,701 +1754,715 @@ isinfreelist(unsigned int b) { */ static const struct systypes sgi_sys_types[] = { -/* SGI_VOLHDR */ {"\x00" "SGI volhdr" }, -/* 0x01 */ {"\x01" "SGI trkrepl" }, -/* 0x02 */ {"\x02" "SGI secrepl" }, -/* SGI_SWAP */ {"\x03" "SGI raw" }, -/* 0x04 */ {"\x04" "SGI bsd" }, -/* 0x05 */ {"\x05" "SGI sysv" }, -/* ENTIRE_DISK */ {"\x06" "SGI volume" }, -/* SGI_EFS */ {"\x07" "SGI efs" }, -/* 0x08 */ {"\x08" "SGI lvol" }, -/* 0x09 */ {"\x09" "SGI rlvol" }, -/* SGI_XFS */ {"\x0a" "SGI xfs" }, -/* SGI_XFSLOG */ {"\x0b" "SGI xfslog" }, -/* SGI_XLV */ {"\x0c" "SGI xlv" }, -/* SGI_XVM */ {"\x0d" "SGI xvm" }, -/* LINUX_SWAP */ {"\x82" "Linux swap" }, -/* LINUX_NATIVE */ {"\x83" "Linux native" }, -/* LINUX_LVM */ {"\x8d" "Linux LVM" }, -/* LINUX_RAID */ {"\xfd" "Linux RAID" }, - { NULL } +/* SGI_VOLHDR */ { "\x00" "SGI volhdr" }, +/* 0x01 */ { "\x01" "SGI trkrepl" }, +/* 0x02 */ { "\x02" "SGI secrepl" }, +/* SGI_SWAP */ { "\x03" "SGI raw" }, +/* 0x04 */ { "\x04" "SGI bsd" }, +/* 0x05 */ { "\x05" "SGI sysv" }, +/* ENTIRE_DISK */ { "\x06" "SGI volume" }, +/* SGI_EFS */ { "\x07" "SGI efs" }, +/* 0x08 */ { "\x08" "SGI lvol" }, +/* 0x09 */ { "\x09" "SGI rlvol" }, +/* SGI_XFS */ { "\x0a" "SGI xfs" }, +/* SGI_XFSLOG */ { "\x0b" "SGI xfslog" }, +/* SGI_XLV */ { "\x0c" "SGI xlv" }, +/* SGI_XVM */ { "\x0d" "SGI xvm" }, +/* LINUX_SWAP */ { "\x82" "Linux swap" }, +/* LINUX_NATIVE */ { "\x83" "Linux native" }, +/* LINUX_LVM */ { "\x8d" "Linux LVM" }, +/* LINUX_RAID */ { "\xfd" "Linux RAID" }, + { NULL } }; static int -sgi_get_nsect(void) { - return SGI_SSWAP16(sgilabel->devparam.nsect); +sgi_get_nsect(void) +{ + return SGI_SSWAP16(sgilabel->devparam.nsect); } static int -sgi_get_ntrks(void) { - return SGI_SSWAP16(sgilabel->devparam.ntrks); +sgi_get_ntrks(void) +{ + return SGI_SSWAP16(sgilabel->devparam.ntrks); } static void -sgi_nolabel(void) { - sgilabel->magic = 0; - sgi_label = 0; - partitions = 4; +sgi_nolabel(void) +{ + sgilabel->magic = 0; + sgi_label = 0; + partitions = 4; } static unsigned int -two_s_complement_32bit_sum(unsigned int* base, int size /* in bytes */) { - int i=0; - unsigned int sum=0; +two_s_complement_32bit_sum(unsigned int* base, int size /* in bytes */) +{ + int i = 0; + unsigned int sum = 0; - size /= sizeof(unsigned int); - for (i = 0; i < size; i++) - sum -= SGI_SSWAP32(base[i]); - return sum; + size /= sizeof(unsigned int); + for (i = 0; i < size; i++) + sum -= SGI_SSWAP32(base[i]); + return sum; } static int -check_sgi_label(void) { - if (sizeof(sgilabel) > 512) { - fprintf(stderr, - _("According to MIPS Computer Systems, Inc the " - "Label must not contain more than 512 bytes\n")); - exit(1); - } - - if (sgilabel->magic != SGI_LABEL_MAGIC && - sgilabel->magic != SGI_LABEL_MAGIC_SWAPPED) { - sgi_label = 0; - sgi_other_endian = 0; - return 0; - } - - sgi_other_endian = (sgilabel->magic == SGI_LABEL_MAGIC_SWAPPED); - /* - * test for correct checksum - */ - if (two_s_complement_32bit_sum((unsigned int*)sgilabel, - sizeof(*sgilabel))) { +check_sgi_label(void) +{ + if (sizeof(sgilabel) > 512) { + fprintf(stderr, + _("According to MIPS Computer Systems, Inc the " + "Label must not contain more than 512 bytes\n")); + exit(1); + } + + if (sgilabel->magic != SGI_LABEL_MAGIC + && sgilabel->magic != SGI_LABEL_MAGIC_SWAPPED) { + sgi_label = 0; + sgi_other_endian = 0; + return 0; + } + + sgi_other_endian = (sgilabel->magic == SGI_LABEL_MAGIC_SWAPPED); + /* + * test for correct checksum + */ + if (two_s_complement_32bit_sum((unsigned int*)sgilabel, + sizeof(*sgilabel))) { fprintf(stderr, _("Detected sgi disklabel with wrong checksum.\n")); - } - update_units(); - sgi_label = 1; - partitions= 16; - sgi_volumes = 15; - return 1; + } + update_units(); + sgi_label = 1; + partitions = 16; + sgi_volumes = 15; + return 1; } static unsigned int -sgi_get_start_sector(int i) { - return SGI_SSWAP32(sgilabel->partitions[i].start_sector); +sgi_get_start_sector(int i) +{ + return SGI_SSWAP32(sgilabel->partitions[i].start_sector); } static unsigned int -sgi_get_num_sectors(int i) { - return SGI_SSWAP32(sgilabel->partitions[i].num_sectors); +sgi_get_num_sectors(int i) +{ + return SGI_SSWAP32(sgilabel->partitions[i].num_sectors); } static int sgi_get_sysid(int i) { - return SGI_SSWAP32(sgilabel->partitions[i].id); + return SGI_SSWAP32(sgilabel->partitions[i].id); } static int sgi_get_bootpartition(void) { - return SGI_SSWAP16(sgilabel->boot_part); + return SGI_SSWAP16(sgilabel->boot_part); } static int sgi_get_swappartition(void) { - return SGI_SSWAP16(sgilabel->swap_part); + return SGI_SSWAP16(sgilabel->swap_part); } static void -sgi_list_table(int xtra) { - int i, w, wd; - int kpi = 0; /* kernel partition ID */ - - if(xtra) { - printf(_("\nDisk %s (SGI disk label): %d heads, %d sectors\n" - "%d cylinders, %d physical cylinders\n" - "%d extra sects/cyl, interleave %d:1\n" - "%s\n" - "Units = %s of %d * 512 bytes\n\n"), - disk_device, heads, sectors, cylinders, - SGI_SSWAP16(sgiparam.pcylcount), - SGI_SSWAP16(sgiparam.sparecyl), - SGI_SSWAP16(sgiparam.ilfact), - (char *)sgilabel, - str_units(PLURAL), units_per_sector); - } else { - printf( _("\nDisk %s (SGI disk label): " - "%d heads, %d sectors, %d cylinders\n" - "Units = %s of %d * 512 bytes\n\n"), - disk_device, heads, sectors, cylinders, - str_units(PLURAL), units_per_sector ); - } +sgi_list_table(int xtra) +{ + int i, w, wd; + int kpi = 0; /* kernel partition ID */ + + if(xtra) { + printf(_("\nDisk %s (SGI disk label): %d heads, %d sectors\n" + "%d cylinders, %d physical cylinders\n" + "%d extra sects/cyl, interleave %d:1\n" + "%s\n" + "Units = %s of %d * 512 bytes\n\n"), + disk_device, heads, sectors, cylinders, + SGI_SSWAP16(sgiparam.pcylcount), + SGI_SSWAP16(sgiparam.sparecyl), + SGI_SSWAP16(sgiparam.ilfact), + (char *)sgilabel, + str_units(PLURAL), units_per_sector); + } else { + printf( _("\nDisk %s (SGI disk label): " + "%d heads, %d sectors, %d cylinders\n" + "Units = %s of %d * 512 bytes\n\n"), + disk_device, heads, sectors, cylinders, + str_units(PLURAL), units_per_sector ); + } - w = strlen(disk_device); - wd = strlen(_("Device")); - if (w < wd) + w = strlen(disk_device); + wd = strlen(_("Device")); + if (w < wd) w = wd; - printf(_("----- partitions -----\n" - "Pt# %*s Info Start End Sectors Id System\n"), - w + 2, _("Device")); - for (i = 0 ; i < partitions; i++) { - if( sgi_get_num_sectors(i) || debug ) { - uint32_t start = sgi_get_start_sector(i); - uint32_t len = sgi_get_num_sectors(i); - kpi++; /* only count nonempty partitions */ - printf( - "%2d: %s %4s %9ld %9ld %9ld %2x %s\n", -/* fdisk part number */ i+1, -/* device */ partname(disk_device, kpi, w+3), -/* flags */ (sgi_get_swappartition() == i) ? "swap" : -/* flags */ (sgi_get_bootpartition() == i) ? "boot" : " ", -/* start */ (long) scround(start), -/* end */ (long) scround(start+len)-1, -/* no odd flag on end */ (long) len, -/* type id */ sgi_get_sysid(i), -/* type name */ partition_type(sgi_get_sysid(i))); - } - } - printf(_("----- Bootinfo -----\nBootfile: %s\n" - "----- Directory Entries -----\n"), - sgilabel->boot_file); + printf(_("----- partitions -----\n" + "Pt# %*s Info Start End Sectors Id System\n"), + w + 2, _("Device")); + for (i = 0 ; i < partitions; i++) { + if( sgi_get_num_sectors(i) || debug ) { + uint32_t start = sgi_get_start_sector(i); + uint32_t len = sgi_get_num_sectors(i); + kpi++; /* only count nonempty partitions */ + printf( + "%2d: %s %4s %9ld %9ld %9ld %2x %s\n", +/* fdisk part number */ i+1, +/* device */ partname(disk_device, kpi, w+3), +/* flags */ (sgi_get_swappartition() == i) ? "swap" : +/* flags */ (sgi_get_bootpartition() == i) ? "boot" : " ", +/* start */ (long) scround(start), +/* end */ (long) scround(start+len)-1, +/* no odd flag on end */(long) len, +/* type id */ sgi_get_sysid(i), +/* type name */ partition_type(sgi_get_sysid(i))); + } + } + printf(_("----- Bootinfo -----\nBootfile: %s\n" + "----- Directory Entries -----\n"), + sgilabel->boot_file); for (i = 0 ; i < sgi_volumes; i++) { - if (sgilabel->directory[i].vol_file_size) { - uint32_t start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start); - uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size); - unsigned char*name = sgilabel->directory[i].vol_file_name; + if (sgilabel->directory[i].vol_file_size) { + uint32_t start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start); + uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size); + unsigned char *name = sgilabel->directory[i].vol_file_name; - printf(_("%2d: %-10s sector%5u size%8u\n"), - i, (char*)name, (unsigned int) start, (unsigned int) len); + printf(_("%2d: %-10s sector%5u size%8u\n"), + i, (char*)name, (unsigned int) start, (unsigned int) len); + } } - } } static void -sgi_set_bootpartition( int i ) +sgi_set_bootpartition(int i) { - sgilabel->boot_part = SGI_SSWAP16(((short)i)); + sgilabel->boot_part = SGI_SSWAP16(((short)i)); } static unsigned int -sgi_get_lastblock(void) { - return heads * sectors * cylinders; +sgi_get_lastblock(void) +{ + return heads * sectors * cylinders; } static void -sgi_set_swappartition( int i ) { - sgilabel->swap_part = SGI_SSWAP16(((short)i)); +sgi_set_swappartition(int i) +{ + sgilabel->swap_part = SGI_SSWAP16(((short)i)); } static int -sgi_check_bootfile(const char* aFile) { - - if (strlen(aFile) < 3) /* "/a\n" is minimum */ { - printf(_("\nInvalid Bootfile!\n" - "\tThe bootfile must be an absolute non-zero pathname,\n" - "\te.g. \"/unix\" or \"/unix.save\".\n")); - return 0; +sgi_check_bootfile(const char* aFile) +{ + if (strlen(aFile) < 3) /* "/a\n" is minimum */ { + printf(_("\nInvalid Bootfile!\n" + "\tThe bootfile must be an absolute non-zero pathname,\n" + "\te.g. \"/unix\" or \"/unix.save\".\n")); + return 0; } else { if (strlen(aFile) > 16) { printf(_("\n\tName of Bootfile too long: " - "16 bytes maximum.\n")); - return 0; + "16 bytes maximum.\n")); + return 0; } else { if (aFile[0] != '/') { printf(_("\n\tBootfile must have a " - "fully qualified pathname.\n")); - return 0; - } + "fully qualified pathname.\n")); + return 0; + } } - } + } if (strncmp(aFile, (char*)sgilabel->boot_file, 16)) { printf(_("\n\tBe aware, that the bootfile is not checked for existence.\n\t" "SGI's default is \"/unix\" and for backup \"/unix.save\".\n")); - /* filename is correct and did change */ - return 1; - } - return 0; /* filename did not change */ + /* filename is correct and did change */ + return 1; + } + return 0; /* filename did not change */ } static const char * -sgi_get_bootfile(void) { +sgi_get_bootfile(void) +{ return (char*)sgilabel->boot_file; } static void -sgi_set_bootfile(const char* aFile) { - int i = 0; +sgi_set_bootfile(const char* aFile) +{ + int i = 0; - if (sgi_check_bootfile(aFile)) { - while (i < 16) { - if ((aFile[i] != '\n') /* in principle caught again by next line */ - && (strlen(aFile) > i)) - sgilabel->boot_file[i] = aFile[i]; - else - sgilabel->boot_file[i] = 0; - i++; + if (sgi_check_bootfile(aFile)) { + while (i < 16) { + if ((aFile[i] != '\n') /* in principle caught again by next line */ + && (strlen(aFile) > i)) + sgilabel->boot_file[i] = aFile[i]; + else + sgilabel->boot_file[i] = 0; + i++; + } + printf(_("\n\tBootfile is changed to \"%s\".\n"), sgilabel->boot_file); } - printf(_("\n\tBootfile is changed to \"%s\".\n"), sgilabel->boot_file); - } } static void create_sgiinfo(void) { - /* I keep SGI's habit to write the sgilabel to the second block */ - sgilabel->directory[0].vol_file_start = SGI_SSWAP32(2); - sgilabel->directory[0].vol_file_size = SGI_SSWAP32(sizeof(sgiinfo)); - strncpy((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8); + /* I keep SGI's habit to write the sgilabel to the second block */ + sgilabel->directory[0].vol_file_start = SGI_SSWAP32(2); + sgilabel->directory[0].vol_file_size = SGI_SSWAP32(sizeof(sgiinfo)); + strncpy((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8); } static sgiinfo *fill_sgiinfo(void); static void -sgi_write_table(void) { - sgilabel->csum = 0; - sgilabel->csum = SGI_SSWAP32(two_s_complement_32bit_sum( - (unsigned int*)sgilabel, - sizeof(*sgilabel))); - assert(two_s_complement_32bit_sum( +sgi_write_table(void) +{ + sgilabel->csum = 0; + sgilabel->csum = SGI_SSWAP32(two_s_complement_32bit_sum( + (unsigned int*)sgilabel, sizeof(*sgilabel))); + assert(two_s_complement_32bit_sum( (unsigned int*)sgilabel, sizeof(*sgilabel)) == 0); - if (lseek(fd, 0, SEEK_SET) < 0) - fdisk_fatal(unable_to_seek); - if (write(fd, sgilabel, SECTOR_SIZE) != SECTOR_SIZE) - fdisk_fatal(unable_to_write); - if (! strncmp((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8)) { - /* - * keep this habit of first writing the "sgilabel". - * I never tested whether it works without (AN 981002). - */ - sgiinfo *info = fill_sgiinfo(); - int infostartblock = SGI_SSWAP32(sgilabel->directory[0].vol_file_start); - if (lseek(fd, infostartblock*SECTOR_SIZE, SEEK_SET) < 0) - fdisk_fatal(unable_to_seek); - if (write(fd, info, SECTOR_SIZE) != SECTOR_SIZE) - fdisk_fatal(unable_to_write); - free(info); - } + + if (lseek(fd, 0, SEEK_SET) < 0) + fdisk_fatal(unable_to_seek); + if (write(fd, sgilabel, SECTOR_SIZE) != SECTOR_SIZE) + fdisk_fatal(unable_to_write); + if (!strncmp((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8)) { + /* + * keep this habit of first writing the "sgilabel". + * I never tested whether it works without (AN 981002). + */ + sgiinfo *info = fill_sgiinfo(); + int infostartblock = SGI_SSWAP32(sgilabel->directory[0].vol_file_start); + if (lseek(fd, infostartblock*SECTOR_SIZE, SEEK_SET) < 0) + fdisk_fatal(unable_to_seek); + if (write(fd, info, SECTOR_SIZE) != SECTOR_SIZE) + fdisk_fatal(unable_to_write); + free(info); + } } static int -compare_start(int *x, int *y) { - /* - * sort according to start sectors - * and prefers largest partition: - * entry zero is entire disk entry - */ - unsigned int i = *x; - unsigned int j = *y; - unsigned int a = sgi_get_start_sector(i); - unsigned int b = sgi_get_start_sector(j); - unsigned int c = sgi_get_num_sectors(i); - unsigned int d = sgi_get_num_sectors(j); +compare_start(int *x, int *y) +{ + /* + * sort according to start sectors + * and prefers largest partition: + * entry zero is entire disk entry + */ + unsigned int i = *x; + unsigned int j = *y; + unsigned int a = sgi_get_start_sector(i); + unsigned int b = sgi_get_start_sector(j); + unsigned int c = sgi_get_num_sectors(i); + unsigned int d = sgi_get_num_sectors(j); - if (a == b) - return (d > c) ? 1 : (d == c) ? 0 : -1; - return (a > b) ? 1 : -1; + if (a == b) + return (d > c) ? 1 : (d == c) ? 0 : -1; + return (a > b) ? 1 : -1; } static int verify_sgi(int verbose) { - int Index[16]; /* list of valid partitions */ - int sortcount = 0; /* number of used partitions, i.e. non-zero lengths */ - int entire = 0, i = 0; - unsigned int start = 0; - long long gap = 0; /* count unused blocks */ - unsigned int lastblock = sgi_get_lastblock(); - - clearfreelist(); - for (i=0; i<16; i++) { - if (sgi_get_num_sectors(i) != 0) { - Index[sortcount++]=i; - if (sgi_get_sysid(i) == ENTIRE_DISK) { - if (entire++ == 1) { - if (verbose) - printf(_("More than one entire disk entry present.\n")); + int Index[16]; /* list of valid partitions */ + int sortcount = 0; /* number of used partitions, i.e. non-zero lengths */ + int entire = 0, i = 0; + unsigned int start = 0; + long long gap = 0; /* count unused blocks */ + unsigned int lastblock = sgi_get_lastblock(); + + clearfreelist(); + for (i = 0; i < 16; i++) { + if (sgi_get_num_sectors(i) != 0) { + Index[sortcount++] = i; + if (sgi_get_sysid(i) == ENTIRE_DISK) { + if (entire++ == 1) { + if (verbose) + printf(_("More than one entire disk entry present.\n")); + } + } } - } - } - } - if (sortcount == 0) { - if (verbose) - printf(_("No partitions defined\n")); - return (lastblock > 0) ? 1 : (lastblock == 0) ? 0 : -1; - } - qsort(Index, sortcount, sizeof(Index[0]), (void*)compare_start); - if (sgi_get_sysid(Index[0]) == ENTIRE_DISK) { - if ((Index[0] != 10) && verbose) - printf(_("IRIX likes when Partition 11 covers the entire disk.\n")); - if ((sgi_get_start_sector(Index[0]) != 0) && verbose) - printf(_("The entire disk partition should start " + } + if (sortcount == 0) { + if (verbose) + printf(_("No partitions defined\n")); + return (lastblock > 0) ? 1 : (lastblock == 0) ? 0 : -1; + } + qsort(Index, sortcount, sizeof(Index[0]), (void*)compare_start); + if (sgi_get_sysid(Index[0]) == ENTIRE_DISK) { + if ((Index[0] != 10) && verbose) + printf(_("IRIX likes when Partition 11 covers the entire disk.\n")); + if ((sgi_get_start_sector(Index[0]) != 0) && verbose) + printf(_("The entire disk partition should start " "at block 0,\n" "not at diskblock %d.\n"), - sgi_get_start_sector(Index[0])); + sgi_get_start_sector(Index[0])); if (debug) /* I do not understand how some disks fulfil it */ - if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose) - printf(_("The entire disk partition is only %d diskblock large,\n" - "but the disk is %d diskblocks long.\n"), - sgi_get_num_sectors(Index[0]), lastblock); + if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose) + printf(_("The entire disk partition is only %d diskblock large,\n" + "but the disk is %d diskblocks long.\n"), + sgi_get_num_sectors(Index[0]), lastblock); lastblock = sgi_get_num_sectors(Index[0]); - } else { - if (verbose) - printf(_("One Partition (#11) should cover the entire disk.\n")); - if (debug>2) - printf("sysid=%d\tpartition=%d\n", - sgi_get_sysid(Index[0]), Index[0]+1); - } - for (i=1, start=0; i<sortcount; i++) { - int cylsize = sgi_get_nsect() * sgi_get_ntrks(); - - if ((sgi_get_start_sector(Index[i]) % cylsize) != 0) { - if (debug) /* I do not understand how some disks fulfil it */ - if (verbose) - printf(_("Partition %d does not start on cylinder boundary.\n"), - Index[i]+1); - } - if (sgi_get_num_sectors(Index[i]) % cylsize != 0) { - if (debug) /* I do not understand how some disks fulfil it */ - if (verbose) - printf(_("Partition %d does not end on cylinder boundary.\n"), - Index[i]+1); - } - /* We cannot handle several "entire disk" entries. */ - if (sgi_get_sysid(Index[i]) == ENTIRE_DISK) continue; - if (start > sgi_get_start_sector(Index[i])) { - if (verbose) - printf(_("The Partition %d and %d overlap by %d sectors.\n"), - Index[i-1]+1, Index[i]+1, - start - sgi_get_start_sector(Index[i])); - if (gap > 0) gap = -gap; - if (gap == 0) gap = -1; - } - if (start < sgi_get_start_sector(Index[i])) { + } else { if (verbose) - printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"), - sgi_get_start_sector(Index[i]) - start, - start, sgi_get_start_sector(Index[i])-1); - gap += sgi_get_start_sector(Index[i]) - start; - add2freelist(start, sgi_get_start_sector(Index[i])); - } - start = sgi_get_start_sector(Index[i]) - + sgi_get_num_sectors(Index[i]); - if (debug > 1) { + printf(_("One Partition (#11) should cover the entire disk.\n")); + if (debug > 2) + printf("sysid=%d\tpartition=%d\n", + sgi_get_sysid(Index[0]), Index[0]+1); + } + for (i = 1, start = 0; i < sortcount; i++) { + int cylsize = sgi_get_nsect() * sgi_get_ntrks(); + + if ((sgi_get_start_sector(Index[i]) % cylsize) != 0) { + if (debug) /* I do not understand how some disks fulfil it */ + if (verbose) + printf(_("Partition %d does not start on cylinder boundary.\n"), + Index[i]+1); + } + if (sgi_get_num_sectors(Index[i]) % cylsize != 0) { + if (debug) /* I do not understand how some disks fulfil it */ + if (verbose) + printf(_("Partition %d does not end on cylinder boundary.\n"), + Index[i]+1); + } + /* We cannot handle several "entire disk" entries. */ + if (sgi_get_sysid(Index[i]) == ENTIRE_DISK) continue; + if (start > sgi_get_start_sector(Index[i])) { + if (verbose) + printf(_("The Partition %d and %d overlap by %d sectors.\n"), + Index[i-1]+1, Index[i]+1, + start - sgi_get_start_sector(Index[i])); + if (gap > 0) gap = -gap; + if (gap == 0) gap = -1; + } + if (start < sgi_get_start_sector(Index[i])) { + if (verbose) + printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"), + sgi_get_start_sector(Index[i]) - start, + start, sgi_get_start_sector(Index[i])-1); + gap += sgi_get_start_sector(Index[i]) - start; + add2freelist(start, sgi_get_start_sector(Index[i])); + } + start = sgi_get_start_sector(Index[i]) + + sgi_get_num_sectors(Index[i]); + if (debug > 1) { + if (verbose) + printf("%2d:%12d\t%12d\t%12d\n", Index[i], + sgi_get_start_sector(Index[i]), + sgi_get_num_sectors(Index[i]), + sgi_get_sysid(Index[i])); + } + } + if (start < lastblock) { if (verbose) - printf("%2d:%12d\t%12d\t%12d\n", Index[i], - sgi_get_start_sector(Index[i]), - sgi_get_num_sectors(Index[i]), - sgi_get_sysid(Index[i])); - } - } - if (start < lastblock) { - if (verbose) - printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"), - lastblock - start, start, lastblock-1); - gap += lastblock - start; - add2freelist(start, lastblock); - } - /* - * Done with arithmetics - * Go for details now - */ - if (verbose) { - if (!sgi_get_num_sectors(sgi_get_bootpartition())) { - printf(_("\nThe boot partition does not exist.\n")); - } - if (!sgi_get_num_sectors(sgi_get_swappartition())) { - printf(_("\nThe swap partition does not exist.\n")); - } else { - if ((sgi_get_sysid(sgi_get_swappartition()) != SGI_SWAP) - && (sgi_get_sysid(sgi_get_swappartition()) != LINUX_SWAP)) - printf(_("\nThe swap partition has no swap type.\n")); + printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"), + lastblock - start, start, lastblock-1); + gap += lastblock - start; + add2freelist(start, lastblock); } - if (sgi_check_bootfile("/unix")) - printf(_("\tYou have chosen an unusual boot file name.\n")); - } - return (gap > 0) ? 1 : (gap == 0) ? 0 : -1; + /* + * Done with arithmetics + * Go for details now + */ + if (verbose) { + if (!sgi_get_num_sectors(sgi_get_bootpartition())) { + printf(_("\nThe boot partition does not exist.\n")); + } + if (!sgi_get_num_sectors(sgi_get_swappartition())) { + printf(_("\nThe swap partition does not exist.\n")); + } else { + if ((sgi_get_sysid(sgi_get_swappartition()) != SGI_SWAP) + && (sgi_get_sysid(sgi_get_swappartition()) != LINUX_SWAP)) + printf(_("\nThe swap partition has no swap type.\n")); + } + if (sgi_check_bootfile("/unix")) + printf(_("\tYou have chosen an unusual boot file name.\n")); + } + return (gap > 0) ? 1 : (gap == 0) ? 0 : -1; } static int -sgi_gaps(void) { - /* - * returned value is: - * = 0 : disk is properly filled to the rim - * < 0 : there is an overlap - * > 0 : there is still some vacant space - */ - return verify_sgi(0); +sgi_gaps(void) +{ + /* + * returned value is: + * = 0 : disk is properly filled to the rim + * < 0 : there is an overlap + * > 0 : there is still some vacant space + */ + return verify_sgi(0); } static void -sgi_change_sysid( int i, int sys ) +sgi_change_sysid(int i, int sys) { - if( sgi_get_num_sectors(i) == 0 ) /* caught already before, ... */ - { - printf(_("Sorry You may change the Tag of non-empty partitions.\n")); - return; - } - if( ((sys != ENTIRE_DISK ) && (sys != SGI_VOLHDR)) - && (sgi_get_start_sector(i)<1) ) - { - read_chars( - _("It is highly recommended that the partition at offset 0\n" - "is of type \"SGI volhdr\", the IRIX system will rely on it to\n" - "retrieve from its directory standalone tools like sash and fx.\n" - "Only the \"SGI volume\" entire disk section may violate this.\n" - "Type YES if you are sure about tagging this partition differently.\n")); - if (strcmp (line_ptr, _("YES\n"))) - return; - } - sgilabel->partitions[i].id = SGI_SSWAP32(sys); + if( sgi_get_num_sectors(i) == 0 ) { /* caught already before, ... */ + printf(_("Sorry You may change the Tag of non-empty partitions.\n")); + return; + } + if (((sys != ENTIRE_DISK ) && (sys != SGI_VOLHDR)) + && (sgi_get_start_sector(i) < 1) ) { + read_chars( + _("It is highly recommended that the partition at offset 0\n" + "is of type \"SGI volhdr\", the IRIX system will rely on it to\n" + "retrieve from its directory standalone tools like sash and fx.\n" + "Only the \"SGI volume\" entire disk section may violate this.\n" + "Type YES if you are sure about tagging this partition differently.\n")); + if (strcmp(line_ptr, _("YES\n"))) + return; + } + sgilabel->partitions[i].id = SGI_SSWAP32(sys); } /* returns partition index of first entry marked as entire disk */ static int -sgi_entire(void) { - int i; +sgi_entire(void) +{ + int i; - for(i=0; i<16; i++) - if(sgi_get_sysid(i) == SGI_VOLUME) - return i; - return -1; + for (i = 0; i < 16; i++) + if (sgi_get_sysid(i) == SGI_VOLUME) + return i; + return -1; } static void -sgi_set_partition(int i, unsigned int start, unsigned int length, int sys) { - - sgilabel->partitions[i].id = SGI_SSWAP32(sys); - sgilabel->partitions[i].num_sectors = SGI_SSWAP32(length); - sgilabel->partitions[i].start_sector = SGI_SSWAP32(start); - set_changed(i); - if (sgi_gaps() < 0) /* rebuild freelist */ - printf(_("Do You know, You got a partition overlap on the disk?\n")); +sgi_set_partition(int i, unsigned int start, unsigned int length, int sys) +{ + sgilabel->partitions[i].id = SGI_SSWAP32(sys); + sgilabel->partitions[i].num_sectors = SGI_SSWAP32(length); + sgilabel->partitions[i].start_sector = SGI_SSWAP32(start); + set_changed(i); + if (sgi_gaps() < 0) /* rebuild freelist */ + printf(_("Do You know, You got a partition overlap on the disk?\n")); } static void -sgi_set_entire(void) { - int n; +sgi_set_entire(void) +{ + int n; - for(n=10; n < partitions; n++) { - if(!sgi_get_num_sectors(n) ) { - sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME); - break; + for (n = 10; n < partitions; n++) { + if(!sgi_get_num_sectors(n) ) { + sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME); + break; + } } - } } static void sgi_set_volhdr(void) { - int n; - for( n=8; n<partitions; n++ ) - { - if(!sgi_get_num_sectors( n ) ) - { - /* - * 5 cylinders is an arbitrary value I like - * IRIX 5.3 stored files in the volume header - * (like sash, symmon, fx, ide) with ca. 3200 - * sectors. - */ - if( heads * sectors * 5 < sgi_get_lastblock() ) - sgi_set_partition( n, 0, heads * sectors * 5, SGI_VOLHDR ); - break; + int n; + + for (n = 8; n < partitions; n++) { + if (!sgi_get_num_sectors(n)) { + /* + * 5 cylinders is an arbitrary value I like + * IRIX 5.3 stored files in the volume header + * (like sash, symmon, fx, ide) with ca. 3200 + * sectors. + */ + if (heads * sectors * 5 < sgi_get_lastblock()) + sgi_set_partition(n, 0, heads * sectors * 5, SGI_VOLHDR); + break; + } } - } } static void -sgi_delete_partition( int i ) +sgi_delete_partition(int i) { - sgi_set_partition( i, 0, 0, 0 ); + sgi_set_partition(i, 0, 0, 0); } static void -sgi_add_partition( int n, int sys ) -{ - char mesg[256]; - unsigned int first=0, last=0; - - if( n == 10 ) { - sys = SGI_VOLUME; - } else if ( n == 8 ) { - sys = 0; - } - if(sgi_get_num_sectors(n)) { - printf(_("Partition %d is already defined. Delete " - "it before re-adding it.\n"), n + 1); - return; - } - if( (sgi_entire() == -1) && (sys != SGI_VOLUME) ) { - printf(_("Attempting to generate entire disk entry automatically.\n")); - sgi_set_entire(); - sgi_set_volhdr(); - } - if( (sgi_gaps() == 0) && (sys != SGI_VOLUME) ) { - printf(_("The entire disk is already covered with partitions.\n")); - return; - } - if(sgi_gaps() < 0) { - printf(_("You got a partition overlap on the disk. Fix it first!\n")); - return; - } - snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR)); - for(;;) { - if(sys == SGI_VOLUME) { - last = sgi_get_lastblock(); - first = read_int(0, 0, last-1, 0, mesg); - if( first != 0 ) { - printf(_("It is highly recommended that eleventh partition\n" - "covers the entire disk and is of type `SGI volume'\n")); - } - } else { - first = freelist[0].first; - last = freelist[0].last; - first = read_int(scround(first), scround(first), scround(last)-1, - 0, mesg); +sgi_add_partition(int n, int sys) +{ + char mesg[256]; + unsigned int first = 0, last = 0; + + if (n == 10) { + sys = SGI_VOLUME; + } else if (n == 8) { + sys = 0; + } + if(sgi_get_num_sectors(n)) { + printf(_("Partition %d is already defined. Delete " + "it before re-adding it.\n"), n + 1); + return; + } + if ((sgi_entire() == -1) && (sys != SGI_VOLUME)) { + printf(_("Attempting to generate entire disk entry automatically.\n")); + sgi_set_entire(); + sgi_set_volhdr(); + } + if ((sgi_gaps() == 0) && (sys != SGI_VOLUME)) { + printf(_("The entire disk is already covered with partitions.\n")); + return; } + if (sgi_gaps() < 0) { + printf(_("You got a partition overlap on the disk. Fix it first!\n")); + return; + } + snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR)); + while (1) { + if(sys == SGI_VOLUME) { + last = sgi_get_lastblock(); + first = read_int(0, 0, last-1, 0, mesg); + if (first != 0) { + printf(_("It is highly recommended that eleventh partition\n" + "covers the entire disk and is of type `SGI volume'\n")); + } + } else { + first = freelist[0].first; + last = freelist[0].last; + first = read_int(scround(first), scround(first), scround(last)-1, + 0, mesg); + } + if (display_in_cyl_units) + first *= units_per_sector; + else + first = first; /* align to cylinder if you know how ... */ + if(!last ) + last = isinfreelist(first); + if(last == 0) { + printf(_("You will get a partition overlap on the disk. " + "Fix it first!\n")); + } else + break; + } + snprintf(mesg, sizeof(mesg), _(" Last %s"), str_units(SINGULAR)); + last = read_int(scround(first), scround(last)-1, scround(last)-1, + scround(first), mesg)+1; if (display_in_cyl_units) - first *= units_per_sector; + last *= units_per_sector; else - first = first; /* align to cylinder if you know how ... */ - if( !last ) - last = isinfreelist(first); - if( last == 0 ) { - printf(_("You will get a partition overlap on the disk. " - "Fix it first!\n")); - } else - break; - } - snprintf(mesg, sizeof(mesg), _(" Last %s"), str_units(SINGULAR)); - last = read_int(scround(first), scround(last)-1, scround(last)-1, - scround(first), mesg)+1; - if (display_in_cyl_units) - last *= units_per_sector; - else - last = last; /* align to cylinder if You know how ... */ - if( (sys == SGI_VOLUME) && ( first != 0 || last != sgi_get_lastblock() ) ) - printf(_("It is highly recommended that eleventh partition\n" - "covers the entire disk and is of type `SGI volume'\n")); - sgi_set_partition( n, first, last-first, sys ); + last = last; /* align to cylinder if You know how ... */ + if ( (sys == SGI_VOLUME) && (first != 0 || last != sgi_get_lastblock() ) ) + printf(_("It is highly recommended that eleventh partition\n" + "covers the entire disk and is of type `SGI volume'\n")); + sgi_set_partition(n, first, last-first, sys); } #ifdef CONFIG_FEATURE_FDISK_ADVANCED static void create_sgilabel(void) { - struct hd_geometry geometry; - struct { - unsigned int start; - unsigned int nsect; - int sysid; - } old[4]; - int i=0; - long longsectors; /* the number of sectors on the device */ - int res; /* the result from the ioctl */ - int sec_fac; /* the sector factor */ - - sec_fac = sector_size / 512; /* determine the sector factor */ - - fprintf( stderr, - _("Building a new SGI disklabel. Changes will remain in memory only,\n" - "until you decide to write them. After that, of course, the previous\n" - "content will be unrecoverably lost.\n\n")); - - sgi_other_endian = (BYTE_ORDER == LITTLE_ENDIAN); - res = ioctl(fd, BLKGETSIZE, &longsectors); - if (!ioctl(fd, HDIO_GETGEO, &geometry)) { - heads = geometry.heads; - sectors = geometry.sectors; - if (res == 0) { - /* the get device size ioctl was successful */ - cylinders = longsectors / (heads * sectors); - cylinders /= sec_fac; - } else { - /* otherwise print error and use truncated version */ - cylinders = geometry.cylinders; - fprintf(stderr, - _("Warning: BLKGETSIZE ioctl failed on %s. " - "Using geometry cylinder value of %d.\n" - "This value may be truncated for devices" - " > 33.8 GB.\n"), disk_device, cylinders); - } - } - for (i = 0; i < 4; i++) { - old[i].sysid = 0; - if(valid_part_table_flag(MBRbuffer)) { - if(get_part_table(i)->sys_ind) { - old[i].sysid = get_part_table(i)->sys_ind; - old[i].start = get_start_sect(get_part_table(i)); - old[i].nsect = get_nr_sects(get_part_table(i)); - printf(_("Trying to keep parameters of partition %d.\n"), i); - if (debug) - printf(_("ID=%02x\tSTART=%d\tLENGTH=%d\n"), - old[i].sysid, old[i].start, old[i].nsect); - } - } - } - - memset(MBRbuffer, 0, sizeof(MBRbuffer)); - sgilabel->magic = SGI_SSWAP32(SGI_LABEL_MAGIC); - sgilabel->boot_part = SGI_SSWAP16(0); - sgilabel->swap_part = SGI_SSWAP16(1); - - /* sizeof(sgilabel->boot_file) = 16 > 6 */ - memset(sgilabel->boot_file, 0, 16); - strcpy((char*)sgilabel->boot_file, "/unix"); - - sgilabel->devparam.skew = (0); - sgilabel->devparam.gap1 = (0); - sgilabel->devparam.gap2 = (0); - sgilabel->devparam.sparecyl = (0); - sgilabel->devparam.pcylcount = SGI_SSWAP16(geometry.cylinders); - sgilabel->devparam.head_vol0 = SGI_SSWAP16(0); - sgilabel->devparam.ntrks = SGI_SSWAP16(geometry.heads); + struct hd_geometry geometry; + struct { + unsigned int start; + unsigned int nsect; + int sysid; + } old[4]; + int i = 0; + long longsectors; /* the number of sectors on the device */ + int res; /* the result from the ioctl */ + int sec_fac; /* the sector factor */ + + sec_fac = sector_size / 512; /* determine the sector factor */ + + fprintf( stderr, + _("Building a new SGI disklabel. Changes will remain in memory only,\n" + "until you decide to write them. After that, of course, the previous\n" + "content will be unrecoverably lost.\n\n")); + + sgi_other_endian = (BYTE_ORDER == LITTLE_ENDIAN); + res = ioctl(fd, BLKGETSIZE, &longsectors); + if (!ioctl(fd, HDIO_GETGEO, &geometry)) { + heads = geometry.heads; + sectors = geometry.sectors; + if (res == 0) { + /* the get device size ioctl was successful */ + cylinders = longsectors / (heads * sectors); + cylinders /= sec_fac; + } else { + /* otherwise print error and use truncated version */ + cylinders = geometry.cylinders; + fprintf(stderr, + _("Warning: BLKGETSIZE ioctl failed on %s. " + "Using geometry cylinder value of %d.\n" + "This value may be truncated for devices" + " > 33.8 GB.\n"), disk_device, cylinders); + } + } + for (i = 0; i < 4; i++) { + old[i].sysid = 0; + if (valid_part_table_flag(MBRbuffer)) { + if(get_part_table(i)->sys_ind) { + old[i].sysid = get_part_table(i)->sys_ind; + old[i].start = get_start_sect(get_part_table(i)); + old[i].nsect = get_nr_sects(get_part_table(i)); + printf(_("Trying to keep parameters of partition %d.\n"), i); + if (debug) + printf(_("ID=%02x\tSTART=%d\tLENGTH=%d\n"), + old[i].sysid, old[i].start, old[i].nsect); + } + } + } + + memset(MBRbuffer, 0, sizeof(MBRbuffer)); + sgilabel->magic = SGI_SSWAP32(SGI_LABEL_MAGIC); + sgilabel->boot_part = SGI_SSWAP16(0); + sgilabel->swap_part = SGI_SSWAP16(1); + + /* sizeof(sgilabel->boot_file) = 16 > 6 */ + memset(sgilabel->boot_file, 0, 16); + strcpy((char*)sgilabel->boot_file, "/unix"); + + sgilabel->devparam.skew = (0); + sgilabel->devparam.gap1 = (0); + sgilabel->devparam.gap2 = (0); + sgilabel->devparam.sparecyl = (0); + sgilabel->devparam.pcylcount = SGI_SSWAP16(geometry.cylinders); + sgilabel->devparam.head_vol0 = SGI_SSWAP16(0); + sgilabel->devparam.ntrks = SGI_SSWAP16(geometry.heads); /* tracks/cylinder (heads) */ - sgilabel->devparam.cmd_tag_queue_depth = (0); - sgilabel->devparam.unused0 = (0); - sgilabel->devparam.unused1 = SGI_SSWAP16(0); - sgilabel->devparam.nsect = SGI_SSWAP16(geometry.sectors); + sgilabel->devparam.cmd_tag_queue_depth = (0); + sgilabel->devparam.unused0 = (0); + sgilabel->devparam.unused1 = SGI_SSWAP16(0); + sgilabel->devparam.nsect = SGI_SSWAP16(geometry.sectors); /* sectors/track */ - sgilabel->devparam.bytes = SGI_SSWAP16(512); - sgilabel->devparam.ilfact = SGI_SSWAP16(1); - sgilabel->devparam.flags = SGI_SSWAP32(TRACK_FWD| + sgilabel->devparam.bytes = SGI_SSWAP16(512); + sgilabel->devparam.ilfact = SGI_SSWAP16(1); + sgilabel->devparam.flags = SGI_SSWAP32(TRACK_FWD| IGNORE_ERRORS|RESEEK); - sgilabel->devparam.datarate = SGI_SSWAP32(0); - sgilabel->devparam.retries_on_error = SGI_SSWAP32(1); - sgilabel->devparam.ms_per_word = SGI_SSWAP32(0); - sgilabel->devparam.xylogics_gap1 = SGI_SSWAP16(0); - sgilabel->devparam.xylogics_syncdelay = SGI_SSWAP16(0); - sgilabel->devparam.xylogics_readdelay = SGI_SSWAP16(0); - sgilabel->devparam.xylogics_gap2 = SGI_SSWAP16(0); - sgilabel->devparam.xylogics_readgate = SGI_SSWAP16(0); - sgilabel->devparam.xylogics_writecont = SGI_SSWAP16(0); - memset( &(sgilabel->directory), 0, sizeof(struct volume_directory)*15 ); - memset( &(sgilabel->partitions), 0, sizeof(struct sgi_partition)*16 ); - sgi_label = 1; - partitions = 16; - sgi_volumes = 15; - sgi_set_entire(); - sgi_set_volhdr(); - for (i = 0; i < 4; i++) { - if(old[i].sysid) { - sgi_set_partition(i, old[i].start, old[i].nsect, old[i].sysid); - } - } + sgilabel->devparam.datarate = SGI_SSWAP32(0); + sgilabel->devparam.retries_on_error = SGI_SSWAP32(1); + sgilabel->devparam.ms_per_word = SGI_SSWAP32(0); + sgilabel->devparam.xylogics_gap1 = SGI_SSWAP16(0); + sgilabel->devparam.xylogics_syncdelay = SGI_SSWAP16(0); + sgilabel->devparam.xylogics_readdelay = SGI_SSWAP16(0); + sgilabel->devparam.xylogics_gap2 = SGI_SSWAP16(0); + sgilabel->devparam.xylogics_readgate = SGI_SSWAP16(0); + sgilabel->devparam.xylogics_writecont = SGI_SSWAP16(0); + memset( &(sgilabel->directory), 0, sizeof(struct volume_directory)*15 ); + memset( &(sgilabel->partitions), 0, sizeof(struct sgi_partition)*16 ); + sgi_label = 1; + partitions = 16; + sgi_volumes = 15; + sgi_set_entire(); + sgi_set_volhdr(); + for (i = 0; i < 4; i++) { + if(old[i].sysid) { + sgi_set_partition(i, old[i].start, old[i].nsect, old[i].sysid); + } + } } static void sgi_set_xcyl(void) { - /* do nothing in the beginning */ + /* do nothing in the beginning */ } #endif /* CONFIG_FEATURE_FDISK_ADVANCED */ @@ -2441,18 +2472,18 @@ sgi_set_xcyl(void) static sgiinfo * fill_sgiinfo(void) { - sgiinfo *info = calloc(1, sizeof(sgiinfo)); - - info->magic=SGI_SSWAP32(SGI_INFO_MAGIC); - info->b1=SGI_SSWAP32(-1); - info->b2=SGI_SSWAP16(-1); - info->b3=SGI_SSWAP16(1); - /* You may want to replace this string !!!!!!! */ - strcpy( (char*)info->scsi_string, "IBM OEM 0662S12 3 30" ); - strcpy( (char*)info->serial, "0000" ); - info->check1816 = SGI_SSWAP16(18*256 +16 ); - strcpy( (char*)info->installer, "Sfx version 5.3, Oct 18, 1994" ); - return info; + sgiinfo *info = calloc(1, sizeof(sgiinfo)); + + info->magic = SGI_SSWAP32(SGI_INFO_MAGIC); + info->b1 = SGI_SSWAP32(-1); + info->b2 = SGI_SSWAP16(-1); + info->b3 = SGI_SSWAP16(1); + /* You may want to replace this string !!!!!!! */ + strcpy( (char*)info->scsi_string, "IBM OEM 0662S12 3 30" ); + strcpy( (char*)info->serial, "0000" ); + info->check1816 = SGI_SSWAP16(18*256 +16 ); + strcpy( (char*)info->installer, "Sfx version 5.3, Oct 18, 1994" ); + return info; } #endif /* SGI_LABEL */ @@ -2471,9 +2502,9 @@ fill_sgiinfo(void) */ -static int sun_other_endian; -static int scsi_disk; -static int floppy; +static int sun_other_endian; +static int scsi_disk; +static int floppy; #ifndef IDE0_MAJOR #define IDE0_MAJOR 3 @@ -2482,19 +2513,21 @@ static int floppy; #define IDE1_MAJOR 22 #endif -static void guess_device_type(void) { +static void +guess_device_type(void) +{ struct stat bootstat; - if (fstat (fd, &bootstat) < 0) { + if (fstat(fd, &bootstat) < 0) { scsi_disk = 0; floppy = 0; } else if (S_ISBLK(bootstat.st_mode) - && (major(bootstat.st_rdev) == IDE0_MAJOR || - major(bootstat.st_rdev) == IDE1_MAJOR)) { + && (major(bootstat.st_rdev) == IDE0_MAJOR || + major(bootstat.st_rdev) == IDE1_MAJOR)) { scsi_disk = 0; floppy = 0; } else if (S_ISBLK(bootstat.st_mode) - && major(bootstat.st_rdev) == FLOPPY_MAJOR) { + && major(bootstat.st_rdev) == FLOPPY_MAJOR) { scsi_disk = 0; floppy = 1; } else { @@ -2504,26 +2537,27 @@ static void guess_device_type(void) { } static const struct systypes sun_sys_types[] = { -/* 0 */ {"\x00" "Empty" }, -/* 1 */ {"\x01" "Boot" }, -/* 2 */ {"\x02" "SunOS root" }, -/* SUNOS_SWAP */ {"\x03" "SunOS swap" }, -/* 4 */ {"\x04" "SunOS usr" }, -/* WHOLE_DISK */ {"\x05" "Whole disk" }, -/* 6 */ {"\x06" "SunOS stand" }, -/* 7 */ {"\x07" "SunOS var" }, -/* 8 */ {"\x08" "SunOS home" }, -/* LINUX_SWAP */ {"\x82" "Linux swap" }, -/* LINUX_NATIVE */ {"\x83" "Linux native" }, -/* 0x8e */ {"\x8e" "Linux LVM" }, + { "\x00" "Empty" }, /* 0 */ + { "\x01" "Boot" }, /* 1 */ + { "\x02" "SunOS root" }, /* 2 */ + { "\x03" "SunOS swap" }, /* SUNOS_SWAP */ + { "\x04" "SunOS usr" }, /* 4 */ + { "\x05" "Whole disk" }, /* WHOLE_DISK */ + { "\x06" "SunOS stand" }, /* 6 */ + { "\x07" "SunOS var" }, /* 7 */ + { "\x08" "SunOS home" }, /* 8 */ + { "\x82" "Linux swap" }, /* LINUX_SWAP */ + { "\x83" "Linux native" }, /* LINUX_NATIVE */ + { "\x8e" "Linux LVM" }, /* 0x8e */ /* New (2.2.x) raid partition with autodetect using persistent superblock */ -/* 0xfd */ {"\xfd" "Linux raid autodetect" }, - { NULL } + { "\xfd" "Linux raid autodetect" }, /* 0xfd */ + { NULL } }; static void -set_sun_partition(int i, uint start, uint stop, int sysid) { +set_sun_partition(int i, uint start, uint stop, int sysid) +{ sunlabel->infos[i].id = sysid; sunlabel->partitions[i].start_cylinder = SUN_SSWAP32(start / (heads * sectors)); @@ -2533,19 +2567,21 @@ set_sun_partition(int i, uint start, uint stop, int sysid) { } static void -sun_nolabel(void) { +sun_nolabel(void) +{ sun_label = 0; sunlabel->magic = 0; partitions = 4; } static int -check_sun_label(void) { +check_sun_label(void) +{ unsigned short *ush; int csum; - if (sunlabel->magic != SUN_LABEL_MAGIC && - sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED) { + if (sunlabel->magic != SUN_LABEL_MAGIC + && sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED) { sun_label = 0; sun_other_endian = 0; return 0; @@ -2580,98 +2616,101 @@ static const struct sun_predefined_drives { unsigned short nsect; unsigned short rspeed; } sun_drives[] = { -{"Quantum","ProDrive 80S",1,832,2,834,6,34,3662}, -{"Quantum","ProDrive 105S",1,974,2,1019,6,35,3662}, -{"CDC","Wren IV 94171-344",3,1545,2,1549,9,46,3600}, -{"IBM","DPES-31080",0,4901,2,4903,4,108,5400}, -{"IBM","DORS-32160",0,1015,2,1017,67,62,5400}, -{"IBM","DNES-318350",0,11199,2,11474,10,320,7200}, -{"SEAGATE","ST34371",0,3880,2,3882,16,135,7228}, -{"","SUN0104",1,974,2,1019,6,35,3662}, -{"","SUN0207",4,1254,2,1272,9,36,3600}, -{"","SUN0327",3,1545,2,1549,9,46,3600}, -{"","SUN0340",0,1538,2,1544,6,72,4200}, -{"","SUN0424",2,1151,2,2500,9,80,4400}, -{"","SUN0535",0,1866,2,2500,7,80,5400}, -{"","SUN0669",5,1614,2,1632,15,54,3600}, -{"","SUN1.0G",5,1703,2,1931,15,80,3597}, -{"","SUN1.05",0,2036,2,2038,14,72,5400}, -{"","SUN1.3G",6,1965,2,3500,17,80,5400}, -{"","SUN2.1G",0,2733,2,3500,19,80,5400}, -{"IOMEGA","Jaz",0,1019,2,1021,64,32,5394}, + { "Quantum","ProDrive 80S",1,832,2,834,6,34,3662}, + { "Quantum","ProDrive 105S",1,974,2,1019,6,35,3662}, + { "CDC","Wren IV 94171-344",3,1545,2,1549,9,46,3600}, + { "IBM","DPES-31080",0,4901,2,4903,4,108,5400}, + { "IBM","DORS-32160",0,1015,2,1017,67,62,5400}, + { "IBM","DNES-318350",0,11199,2,11474,10,320,7200}, + { "SEAGATE","ST34371",0,3880,2,3882,16,135,7228}, + { "","SUN0104",1,974,2,1019,6,35,3662}, + { "","SUN0207",4,1254,2,1272,9,36,3600}, + { "","SUN0327",3,1545,2,1549,9,46,3600}, + { "","SUN0340",0,1538,2,1544,6,72,4200}, + { "","SUN0424",2,1151,2,2500,9,80,4400}, + { "","SUN0535",0,1866,2,2500,7,80,5400}, + { "","SUN0669",5,1614,2,1632,15,54,3600}, + { "","SUN1.0G",5,1703,2,1931,15,80,3597}, + { "","SUN1.05",0,2036,2,2038,14,72,5400}, + { "","SUN1.3G",6,1965,2,3500,17,80,5400}, + { "","SUN2.1G",0,2733,2,3500,19,80,5400}, + { "IOMEGA","Jaz",0,1019,2,1021,64,32,5394}, }; static const struct sun_predefined_drives * -sun_autoconfigure_scsi(void) { - const struct sun_predefined_drives *p = NULL; +sun_autoconfigure_scsi(void) +{ + const struct sun_predefined_drives *p = NULL; #ifdef SCSI_IOCTL_GET_IDLUN - unsigned int id[2]; - char buffer[2048]; - char buffer2[2048]; - FILE *pfd; - char *vendor; - char *model; - char *q; - int i; - - if (!ioctl(fd, SCSI_IOCTL_GET_IDLUN, &id)) { - sprintf(buffer, - "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n", + unsigned int id[2]; + char buffer[2048]; + char buffer2[2048]; + FILE *pfd; + char *vendor; + char *model; + char *q; + int i; + + if (!ioctl(fd, SCSI_IOCTL_GET_IDLUN, &id)) { + sprintf(buffer, + "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n", #if 0 - ((id[0]>>24)&0xff)-/*PROC_SCSI_SCSI+PROC_SCSI_FILE*/33, + ((id[0]>>24)&0xff)-/*PROC_SCSI_SCSI+PROC_SCSI_FILE*/33, #else - /* This is very wrong (works only if you have one HBA), - but I haven't found a way how to get hostno - from the current kernel */ - 0, -#endif - (id[0]>>16)&0xff, - id[0]&0xff, - (id[0]>>8)&0xff); - pfd = fopen("/proc/scsi/scsi","r"); - if (pfd) { - while (fgets(buffer2,2048,pfd)) { - if (!strcmp(buffer, buffer2)) { - if (fgets(buffer2,2048,pfd)) { - q = strstr(buffer2,"Vendor: "); - if (q) { - q += 8; - vendor = q; - q = strstr(q," "); - *q++ = 0; /* truncate vendor name */ - q = strstr(q,"Model: "); - if (q) { - *q = 0; - q += 7; - model = q; - q = strstr(q," Rev: "); - if (q) { - *q = 0; - for (i = 0; i < SIZE(sun_drives); i++) { - if (*sun_drives[i].vendor && strcasecmp(sun_drives[i].vendor, vendor)) - continue; - if (!strstr(model, sun_drives[i].model)) - continue; - printf(_("Autoconfigure found a %s%s%s\n"),sun_drives[i].vendor,(*sun_drives[i].vendor) ? " " : "",sun_drives[i].model); - p = sun_drives + i; + /* This is very wrong (works only if you have one HBA), + but I haven't found a way how to get hostno + from the current kernel */ + 0, +#endif + (id[0]>>16) & 0xff, + id[0] & 0xff, + (id[0]>>8) & 0xff + ); + pfd = fopen("/proc/scsi/scsi","r"); + if (pfd) { + while (fgets(buffer2, 2048, pfd)) { + if (!strcmp(buffer, buffer2)) { + if (fgets(buffer2,2048,pfd)) { + q = strstr(buffer2,"Vendor: "); + if (q) { + q += 8; + vendor = q; + q = strstr(q," "); + *q++ = 0; /* truncate vendor name */ + q = strstr(q,"Model: "); + if (q) { + *q = 0; + q += 7; + model = q; + q = strstr(q," Rev: "); + if (q) { + *q = 0; + for (i = 0; i < SIZE(sun_drives); i++) { + if (*sun_drives[i].vendor && strcasecmp(sun_drives[i].vendor, vendor)) + continue; + if (!strstr(model, sun_drives[i].model)) + continue; + printf(_("Autoconfigure found a %s%s%s\n"),sun_drives[i].vendor,(*sun_drives[i].vendor) ? " " : "",sun_drives[i].model); + p = sun_drives + i; + break; + } + } + } + } + } break; - } } - } } - } - break; + fclose(pfd); } - } - fclose(pfd); } - } #endif - return p; + return p; } -static void create_sunlabel(void) +static void +create_sunlabel(void) { struct hd_geometry geometry; unsigned int ndiv; @@ -2680,9 +2719,9 @@ static void create_sunlabel(void) const struct sun_predefined_drives *p = NULL; fprintf(stderr, - _("Building a new sun 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")); + _("Building a new sun 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")); #if BYTE_ORDER == LITTLE_ENDIAN sun_other_endian = 1; #else @@ -2691,113 +2730,103 @@ static void create_sunlabel(void) memset(MBRbuffer, 0, sizeof(MBRbuffer)); sunlabel->magic = SUN_SSWAP16(SUN_LABEL_MAGIC); if (!floppy) { - puts(_("Drive type\n" + puts(_("Drive type\n" " ? auto configure\n" " 0 custom (with hardware detected defaults)")); - for (i = 0; i < SIZE(sun_drives); i++) { - printf(" %c %s%s%s\n", - i + 'a', sun_drives[i].vendor, - (*sun_drives[i].vendor) ? " " : "", - sun_drives[i].model); - } - for (;;) { - c = read_char(_("Select type (? for auto, 0 for custom): ")); - if (c >= 'a' && c < 'a' + SIZE(sun_drives)) { - p = sun_drives + c - 'a'; - break; - } else if (c >= 'A' && c < 'A' + SIZE(sun_drives)) { - p = sun_drives + c - 'A'; - break; - } else if (c == '0') { - break; - } else if (c == '?' && scsi_disk) { - p = sun_autoconfigure_scsi(); - if (!p) - printf(_("Autoconfigure failed.\n")); - else - break; + for (i = 0; i < SIZE(sun_drives); i++) { + printf(" %c %s%s%s\n", + i + 'a', sun_drives[i].vendor, + (*sun_drives[i].vendor) ? " " : "", + sun_drives[i].model); + } + while (1) { + c = read_char(_("Select type (? for auto, 0 for custom): ")); + if (c >= 'a' && c < 'a' + SIZE(sun_drives)) { + p = sun_drives + c - 'a'; + break; + } else if (c >= 'A' && c < 'A' + SIZE(sun_drives)) { + p = sun_drives + c - 'A'; + break; + } else if (c == '0') { + break; + } else if (c == '?' && scsi_disk) { + p = sun_autoconfigure_scsi(); + if (!p) + printf(_("Autoconfigure failed.\n")); + else + break; + } } - } } if (!p || floppy) { - if (!ioctl(fd, HDIO_GETGEO, &geometry)) { - heads = geometry.heads; - sectors = geometry.sectors; - cylinders = geometry.cylinders; - } else { - heads = 0; - sectors = 0; - cylinders = 0; - } - if (floppy) { - sunlabel->nacyl = 0; - sunlabel->pcylcount = SUN_SSWAP16(cylinders); - sunlabel->rspeed = SUN_SSWAP16(300); - sunlabel->ilfact = SUN_SSWAP16(1); - sunlabel->sparecyl = 0; - } else { - heads = read_int(1,heads,1024,0,_("Heads")); - sectors = read_int(1,sectors,1024,0,_("Sectors/track")); + if (!ioctl(fd, HDIO_GETGEO, &geometry)) { + heads = geometry.heads; + sectors = geometry.sectors; + cylinders = geometry.cylinders; + } else { + heads = 0; + sectors = 0; + cylinders = 0; + } + if (floppy) { + sunlabel->nacyl = 0; + sunlabel->pcylcount = SUN_SSWAP16(cylinders); + sunlabel->rspeed = SUN_SSWAP16(300); + sunlabel->ilfact = SUN_SSWAP16(1); + sunlabel->sparecyl = 0; + } else { + heads = read_int(1,heads,1024,0,_("Heads")); + sectors = read_int(1,sectors,1024,0,_("Sectors/track")); if (cylinders) - cylinders = read_int(1,cylinders-2,65535,0,_("Cylinders")); + cylinders = read_int(1,cylinders-2,65535,0,_("Cylinders")); else - cylinders = read_int(1,0,65535,0,_("Cylinders")); - sunlabel->nacyl = - SUN_SSWAP16(read_int(0,2,65535,0, - _("Alternate cylinders"))); - sunlabel->pcylcount = - SUN_SSWAP16(read_int(0,cylinders+SUN_SSWAP16(sunlabel->nacyl), - 65535,0,_("Physical cylinders"))); - sunlabel->rspeed = - SUN_SSWAP16(read_int(1,5400,100000,0, - _("Rotation speed (rpm)"))); - sunlabel->ilfact = - SUN_SSWAP16(read_int(1,1,32,0,_("Interleave factor"))); - sunlabel->sparecyl = - SUN_SSWAP16(read_int(0,0,sectors,0, - _("Extra sectors per cylinder"))); - } + cylinders = read_int(1,0,65535,0,_("Cylinders")); + sunlabel->nacyl = SUN_SSWAP16(read_int(0,2,65535,0, _("Alternate cylinders"))); + sunlabel->pcylcount = SUN_SSWAP16(read_int(0,cylinders+SUN_SSWAP16(sunlabel->nacyl), 65535,0, _("Physical cylinders"))); + sunlabel->rspeed = SUN_SSWAP16(read_int(1,5400,100000,0, _("Rotation speed (rpm)"))); + sunlabel->ilfact = SUN_SSWAP16(read_int(1,1,32,0, _("Interleave factor"))); + sunlabel->sparecyl = SUN_SSWAP16(read_int(0,0,sectors,0, _("Extra sectors per cylinder"))); + } } else { - sunlabel->sparecyl = SUN_SSWAP16(p->sparecyl); - sunlabel->ncyl = SUN_SSWAP16(p->ncyl); - sunlabel->nacyl = SUN_SSWAP16(p->nacyl); - sunlabel->pcylcount = SUN_SSWAP16(p->pcylcount); - sunlabel->ntrks = SUN_SSWAP16(p->ntrks); - sunlabel->nsect = SUN_SSWAP16(p->nsect); - sunlabel->rspeed = SUN_SSWAP16(p->rspeed); - sunlabel->ilfact = SUN_SSWAP16(1); - cylinders = p->ncyl; - heads = p->ntrks; - sectors = p->nsect; - puts(_("You may change all the disk params from the x menu")); + sunlabel->sparecyl = SUN_SSWAP16(p->sparecyl); + sunlabel->ncyl = SUN_SSWAP16(p->ncyl); + sunlabel->nacyl = SUN_SSWAP16(p->nacyl); + sunlabel->pcylcount = SUN_SSWAP16(p->pcylcount); + sunlabel->ntrks = SUN_SSWAP16(p->ntrks); + sunlabel->nsect = SUN_SSWAP16(p->nsect); + sunlabel->rspeed = SUN_SSWAP16(p->rspeed); + sunlabel->ilfact = SUN_SSWAP16(1); + cylinders = p->ncyl; + heads = p->ntrks; + sectors = p->nsect; + puts(_("You may change all the disk params from the x menu")); } snprintf((char *)(sunlabel->info), sizeof(sunlabel->info), - "%s%s%s cyl %d alt %d hd %d sec %d", - p ? p->vendor : "", (p && *p->vendor) ? " " : "", - p ? p->model - : (floppy ? _("3,5\" floppy") : _("Linux custom")), + "%s%s%s cyl %d alt %d hd %d sec %d", + p ? p->vendor : "", (p && *p->vendor) ? " " : "", + p ? p->model : (floppy ? _("3,5\" floppy") : _("Linux custom")), cylinders, SUN_SSWAP16(sunlabel->nacyl), heads, sectors); sunlabel->ntrks = SUN_SSWAP16(heads); sunlabel->nsect = SUN_SSWAP16(sectors); sunlabel->ncyl = SUN_SSWAP16(cylinders); if (floppy) - set_sun_partition(0, 0, cylinders * heads * sectors, LINUX_NATIVE); + set_sun_partition(0, 0, cylinders * heads * sectors, LINUX_NATIVE); else { - if (cylinders * heads * sectors >= 150 * 2048) { - ndiv = cylinders - (50 * 2048 / (heads * sectors)); /* 50M swap */ - } else - ndiv = cylinders * 2 / 3; - set_sun_partition(0, 0, ndiv * heads * sectors, LINUX_NATIVE); - set_sun_partition(1, ndiv * heads * sectors, cylinders * heads * sectors, LINUX_SWAP); - sunlabel->infos[1].flags |= 0x01; /* Not mountable */ + if (cylinders * heads * sectors >= 150 * 2048) { + ndiv = cylinders - (50 * 2048 / (heads * sectors)); /* 50M swap */ + } else + ndiv = cylinders * 2 / 3; + set_sun_partition(0, 0, ndiv * heads * sectors, LINUX_NATIVE); + set_sun_partition(1, ndiv * heads * sectors, cylinders * heads * sectors, LINUX_SWAP); + sunlabel->infos[1].flags |= 0x01; /* Not mountable */ } set_sun_partition(2, 0, cylinders * heads * sectors, WHOLE_DISK); { unsigned short *ush = (unsigned short *)sunlabel; unsigned short csum = 0; - while(ush < (unsigned short *)(&sunlabel->csum)) + while (ush < (unsigned short *)(&sunlabel->csum)) csum ^= *ush++; sunlabel->csum = csum; } @@ -2808,21 +2837,26 @@ static void create_sunlabel(void) } static void -toggle_sunflags(int i, unsigned char mask) { +toggle_sunflags(int i, unsigned char mask) +{ if (sunlabel->infos[i].flags & mask) sunlabel->infos[i].flags &= ~mask; - else sunlabel->infos[i].flags |= mask; + else + sunlabel->infos[i].flags |= mask; set_changed(i); } static void -fetch_sun(uint *starts, uint *lens, uint *start, uint *stop) { +fetch_sun(uint *starts, uint *lens, uint *start, uint *stop) +{ int i, continuous = 1; - *start = 0; *stop = cylinders * heads * sectors; + + *start = 0; + *stop = cylinders * heads * sectors; for (i = 0; i < partitions; i++) { if (sunlabel->partitions[i].num_sectors - && sunlabel->infos[i].id - && sunlabel->infos[i].id != WHOLE_DISK) { + && sunlabel->infos[i].id + && sunlabel->infos[i].id != WHOLE_DISK) { starts[i] = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * heads * sectors; lens[i] = SUN_SSWAP32(sunlabel->partitions[i].num_sectors); if (continuous) { @@ -2845,77 +2879,80 @@ fetch_sun(uint *starts, uint *lens, uint *start, uint *stop) { static uint *verify_sun_starts; static int -verify_sun_cmp(int *a, int *b) { - if (*a == -1) return 1; - if (*b == -1) return -1; - if (verify_sun_starts[*a] > verify_sun_starts[*b]) return 1; - return -1; +verify_sun_cmp(int *a, int *b) +{ + if (*a == -1) return 1; + if (*b == -1) return -1; + if (verify_sun_starts[*a] > verify_sun_starts[*b]) return 1; + return -1; } static void -verify_sun(void) { - uint starts[8], lens[8], start, stop; - int i,j,k,starto,endo; - int array[8]; - - verify_sun_starts = starts; - fetch_sun(starts,lens,&start,&stop); - for (k = 0; k < 7; k++) { - for (i = 0; i < 8; i++) { - if (k && (lens[i] % (heads * sectors))) { - printf(_("Partition %d doesn't end on cylinder boundary\n"), i+1); - } - if (lens[i]) { - for (j = 0; j < i; j++) - if (lens[j]) { - if (starts[j] == starts[i]+lens[i]) { - starts[j] = starts[i]; lens[j] += lens[i]; - lens[i] = 0; - } else if (starts[i] == starts[j]+lens[j]){ - lens[j] += lens[i]; - lens[i] = 0; - } else if (!k) { - if (starts[i] < starts[j]+lens[j] && - starts[j] < starts[i]+lens[i]) { - starto = starts[i]; - if (starts[j] > starto) - starto = starts[j]; - endo = starts[i]+lens[i]; - if (starts[j]+lens[j] < endo) - endo = starts[j]+lens[j]; - printf(_("Partition %d overlaps with others in " - "sectors %d-%d\n"), i+1, starto, endo); - } +verify_sun(void) +{ + uint starts[8], lens[8], start, stop; + int i,j,k,starto,endo; + int array[8]; + + verify_sun_starts = starts; + fetch_sun(starts,lens,&start,&stop); + for (k = 0; k < 7; k++) { + for (i = 0; i < 8; i++) { + if (k && (lens[i] % (heads * sectors))) { + printf(_("Partition %d doesn't end on cylinder boundary\n"), i+1); } - } - } + if (lens[i]) { + for (j = 0; j < i; j++) + if (lens[j]) { + if (starts[j] == starts[i]+lens[i]) { + starts[j] = starts[i]; lens[j] += lens[i]; + lens[i] = 0; + } else if (starts[i] == starts[j]+lens[j]){ + lens[j] += lens[i]; + lens[i] = 0; + } else if (!k) { + if (starts[i] < starts[j]+lens[j] + && starts[j] < starts[i]+lens[i]) { + starto = starts[i]; + if (starts[j] > starto) + starto = starts[j]; + endo = starts[i]+lens[i]; + if (starts[j]+lens[j] < endo) + endo = starts[j]+lens[j]; + printf(_("Partition %d overlaps with others in " + "sectors %d-%d\n"), i+1, starto, endo); + } + } + } + } + } } - } - for (i = 0; i < 8; i++) { - if (lens[i]) - array[i] = i; - else - array[i] = -1; - } - qsort(array,SIZE(array),sizeof(array[0]), - (int (*)(const void *,const void *)) verify_sun_cmp); - if (array[0] == -1) { - printf(_("No partitions defined\n")); - return; - } - stop = cylinders * heads * sectors; - if (starts[array[0]]) - printf(_("Unused gap - sectors 0-%d\n"),starts[array[0]]); - for (i = 0; i < 7 && array[i+1] != -1; i++) { - printf(_("Unused gap - sectors %d-%d\n"),starts[array[i]]+lens[array[i]],starts[array[i+1]]); - } - start = starts[array[i]]+lens[array[i]]; - if (start < stop) - printf(_("Unused gap - sectors %d-%d\n"),start,stop); + for (i = 0; i < 8; i++) { + if (lens[i]) + array[i] = i; + else + array[i] = -1; + } + qsort(array,SIZE(array),sizeof(array[0]), + (int (*)(const void *,const void *)) verify_sun_cmp); + if (array[0] == -1) { + printf(_("No partitions defined\n")); + return; + } + stop = cylinders * heads * sectors; + if (starts[array[0]]) + printf(_("Unused gap - sectors 0-%d\n"),starts[array[0]]); + for (i = 0; i < 7 && array[i+1] != -1; i++) { + printf(_("Unused gap - sectors %d-%d\n"),starts[array[i]]+lens[array[i]],starts[array[i+1]]); + } + start = starts[array[i]] + lens[array[i]]; + if (start < stop) + printf(_("Unused gap - sectors %d-%d\n"),start,stop); } static void -add_sun_partition(int n, int sys) { +add_sun_partition(int n, int sys) +{ uint start, stop, stop2; uint starts[8], lens[8]; int whole_disk = 0; @@ -2935,12 +2972,12 @@ add_sun_partition(int n, int sys) { whole_disk = 1; else { printf(_("Other partitions already cover the whole disk.\nDelete " - "some/shrink them before retry.\n")); + "some/shrink them before retry.\n")); return; } } snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR)); - for (;;) { + while (1) { if (whole_disk) first = read_int(0, 0, 0, 0, mesg); else @@ -2952,7 +2989,7 @@ add_sun_partition(int n, int sys) { /* Starting sector has to be properly aligned */ first = (first + heads * sectors - 1) / (heads * sectors); if (n == 2 && first != 0) - printf ("\ + printf("\ It is highly recommended that the third partition covers the whole disk\n\ and is of type `Whole disk'\n"); /* ewt asks to add: "don't start a partition at cyl 0" @@ -2972,13 +3009,12 @@ and is of type `Whole disk'\n"); starting at block 0 in an md, or the label will be trashed. */ for (i = 0; i < partitions; i++) - if (lens[i] && starts[i] <= first - && starts[i] + lens[i] > first) + if (lens[i] && starts[i] <= first && starts[i] + lens[i] > first) break; if (i < partitions && !whole_disk) { if (n == 2 && !first) { - whole_disk = 1; - break; + whole_disk = 1; + break; } printf(_("Sector %d is already allocated\n"), first); } else @@ -2991,8 +3027,8 @@ and is of type `Whole disk'\n"); stop = starts[i]; } snprintf(mesg, sizeof(mesg), - _("Last %s or +size or +sizeM or +sizeK"), - str_units(SINGULAR)); + _("Last %s or +size or +sizeM or +sizeK"), + str_units(SINGULAR)); if (whole_disk) last = read_int(scround(stop2), scround(stop2), scround(stop2), 0, mesg); @@ -3006,51 +3042,55 @@ and is of type `Whole disk'\n"); last *= units_per_sector; if (n == 2 && !first) { if (last >= stop2) { - whole_disk = 1; - last = stop2; + whole_disk = 1; + last = stop2; } else if (last > stop) { - printf ( - _("You haven't covered the whole disk with the 3rd partition, but your value\n" - "%d %s covers some other partition. Your entry has been changed\n" - "to %d %s\n"), - scround(last), str_units(SINGULAR), - scround(stop), str_units(SINGULAR)); - last = stop; + printf(_("You haven't covered the whole disk with " + "the 3rd partition, but your value\n" + "%d %s covers some other partition. " + "Your entry has been changed\n" + "to %d %s\n"), + scround(last), str_units(SINGULAR), + scround(stop), str_units(SINGULAR)); + last = stop; } } else if (!whole_disk && last > stop) last = stop; - if (whole_disk) sys = WHOLE_DISK; + if (whole_disk) + sys = WHOLE_DISK; set_sun_partition(n, first, last, sys); } static void -sun_delete_partition(int i) { +sun_delete_partition(int i) +{ unsigned int nsec; - if (i == 2 && sunlabel->infos[i].id == WHOLE_DISK && - !sunlabel->partitions[i].start_cylinder && - (nsec = SUN_SSWAP32(sunlabel->partitions[i].num_sectors)) - == heads * sectors * cylinders) + if (i == 2 + && sunlabel->infos[i].id == WHOLE_DISK + && !sunlabel->partitions[i].start_cylinder + && (nsec = SUN_SSWAP32(sunlabel->partitions[i].num_sectors)) == heads * sectors * cylinders) printf(_("If you want to maintain SunOS/Solaris compatibility, " - "consider leaving this\n" - "partition as Whole disk (5), starting at 0, with %u " - "sectors\n"), nsec); + "consider leaving this\n" + "partition as Whole disk (5), starting at 0, with %u " + "sectors\n"), nsec); sunlabel->infos[i].id = 0; sunlabel->partitions[i].num_sectors = 0; } static void -sun_change_sysid(int i, int sys) { +sun_change_sysid(int i, int sys) +{ if (sys == LINUX_SWAP && !sunlabel->partitions[i].start_cylinder) { - read_chars( - _("It is highly recommended that the partition at offset 0\n" - "is UFS, EXT2FS filesystem or SunOS swap. Putting Linux swap\n" - "there may destroy your partition table and bootblock.\n" - "Type YES if you're very sure you would like that partition\n" - "tagged with 82 (Linux swap): ")); - if (strcmp (line_ptr, _("YES\n"))) - return; + read_chars( + _("It is highly recommended that the partition at offset 0\n" + "is UFS, EXT2FS filesystem or SunOS swap. Putting Linux swap\n" + "there may destroy your partition table and bootblock.\n" + "Type YES if you're very sure you would like that partition\n" + "tagged with 82 (Linux swap): ")); + if (strcmp (line_ptr, _("YES\n"))) + return; } switch (sys) { case SUNOS_SWAP: @@ -3068,7 +3108,8 @@ sun_change_sysid(int i, int sys) { } static void -sun_list_table(int xtra) { +sun_list_table(int xtra) +{ int i, w; w = strlen(disk_device); @@ -3079,36 +3120,35 @@ sun_list_table(int xtra) { "%d extra sects/cyl, interleave %d:1\n" "%s\n" "Units = %s of %d * 512 bytes\n\n"), - disk_device, heads, sectors, SUN_SSWAP16(sunlabel->rspeed), - cylinders, SUN_SSWAP16(sunlabel->nacyl), - SUN_SSWAP16(sunlabel->pcylcount), - SUN_SSWAP16(sunlabel->sparecyl), - SUN_SSWAP16(sunlabel->ilfact), - (char *)sunlabel, - str_units(PLURAL), units_per_sector); + disk_device, heads, sectors, SUN_SSWAP16(sunlabel->rspeed), + cylinders, SUN_SSWAP16(sunlabel->nacyl), + SUN_SSWAP16(sunlabel->pcylcount), + SUN_SSWAP16(sunlabel->sparecyl), + SUN_SSWAP16(sunlabel->ilfact), + (char *)sunlabel, + str_units(PLURAL), units_per_sector); else printf( _("\nDisk %s (Sun disk label): %d heads, %d sectors, %d cylinders\n" "Units = %s of %d * 512 bytes\n\n"), - disk_device, heads, sectors, cylinders, - str_units(PLURAL), units_per_sector); + disk_device, heads, sectors, cylinders, + str_units(PLURAL), units_per_sector); printf(_("%*s Flag Start End Blocks Id System\n"), - w + 1, _("Device")); + w + 1, _("Device")); for (i = 0 ; i < partitions; i++) { if (sunlabel->partitions[i].num_sectors) { uint32_t start = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * heads * sectors; uint32_t len = SUN_SSWAP32(sunlabel->partitions[i].num_sectors); - printf( - "%s %c%c %9ld %9ld %9ld%c %2x %s\n", -/* device */ partname(disk_device, i+1, w), -/* flags */ (sunlabel->infos[i].flags & 0x01) ? 'u' : ' ', - (sunlabel->infos[i].flags & 0x10) ? 'r' : ' ', -/* start */ (long) scround(start), -/* end */ (long) scround(start+len), -/* odd flag on end */ (long) len / 2, len & 1 ? '+' : ' ', -/* type id */ sunlabel->infos[i].id, -/* type name */ partition_type(sunlabel->infos[i].id)); + printf("%s %c%c %9ld %9ld %9ld%c %2x %s\n", + partname(disk_device, i+1, w), /* device */ + (sunlabel->infos[i].flags & 0x01) ? 'u' : ' ', /* flags */ + (sunlabel->infos[i].flags & 0x10) ? 'r' : ' ', + (long) scround(start), /* start */ + (long) scround(start+len), /* end */ + (long) len / 2, len & 1 ? '+' : ' ', /* odd flag on end */ + sunlabel->infos[i].id, /* type id */ + partition_type(sunlabel->infos[i].id)); /* type name */ } } } @@ -3116,52 +3156,59 @@ sun_list_table(int xtra) { #ifdef CONFIG_FEATURE_FDISK_ADVANCED static void -sun_set_alt_cyl(void) { +sun_set_alt_cyl(void) +{ sunlabel->nacyl = SUN_SSWAP16(read_int(0,SUN_SSWAP16(sunlabel->nacyl), 65535, 0, - _("Number of alternate cylinders"))); + _("Number of alternate cylinders"))); } static void -sun_set_ncyl(int cyl) { +sun_set_ncyl(int cyl) +{ sunlabel->ncyl = SUN_SSWAP16(cyl); } static void -sun_set_xcyl(void) { +sun_set_xcyl(void) +{ sunlabel->sparecyl = SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->sparecyl), sectors, 0, - _("Extra sectors per cylinder"))); + _("Extra sectors per cylinder"))); } static void -sun_set_ilfact(void) { +sun_set_ilfact(void) +{ sunlabel->ilfact = SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->ilfact), 32, 0, - _("Interleave factor"))); + _("Interleave factor"))); } static void -sun_set_rspeed(void) { +sun_set_rspeed(void) +{ sunlabel->rspeed = SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->rspeed), 100000, 0, - _("Rotation speed (rpm)"))); + _("Rotation speed (rpm)"))); } static void -sun_set_pcylcount(void) { +sun_set_pcylcount(void) +{ sunlabel->pcylcount = SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->pcylcount), 65535, 0, - _("Number of physical cylinders"))); + _("Number of physical cylinders"))); } #endif /* CONFIG_FEATURE_FDISK_ADVANCED */ static void -sun_write_table(void) { +sun_write_table(void) +{ unsigned short *ush = (unsigned short *)sunlabel; unsigned short csum = 0; - while(ush < (unsigned short *)(&sunlabel->csum)) + while (ush < (unsigned short *)(&sunlabel->csum)) csum ^= *ush++; sunlabel->csum = csum; if (lseek(fd, 0, SEEK_SET) < 0) @@ -3174,104 +3221,104 @@ sun_write_table(void) { /* 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 */ + { "\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 + { "\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 + { "\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 + { "\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 */ + { "\xf1" "SpeedStor" }, + { "\xf4" "SpeedStor" }, /* SpeedStor large partition */ + { "\xfe" "LANstep" }, /* SpeedStor >1024 cyl. or LANstep */ + { "\xff" "BBT" }, /* Xenix Bad Block Table */ #endif { 0 } }; @@ -3280,14 +3327,16 @@ static const struct systypes i386_sys_types[] = { /* A valid partition table sector ends in 0x55 0xaa */ static unsigned int -part_table_flag(const char *b) { +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) { +write_part_table_flag(char *b) +{ b[510] = 0x55; b[511] = 0xaa; } @@ -3295,7 +3344,8 @@ write_part_table_flag(char *b) { /* 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 int val) +{ cp[0] = (val & 0xff); cp[1] = ((val >> 8) & 0xff); cp[2] = ((val >> 16) & 0xff); @@ -3304,32 +3354,37 @@ store4_little_endian(unsigned char *cp, unsigned int val) { #endif /* CONFIG_FEATURE_FDISK_WRITABLE */ static unsigned int -read4_little_endian(const unsigned char *cp) { +read4_little_endian(const unsigned char *cp) +{ return (uint)(cp[0]) + ((uint)(cp[1]) << 8) + ((uint)(cp[2]) << 16) + ((uint)(cp[3]) << 24); } #ifdef CONFIG_FEATURE_FDISK_WRITABLE static void -set_start_sect(struct partition *p, unsigned int start_sect) { +set_start_sect(struct partition *p, unsigned int start_sect) +{ store4_little_endian(p->start4, start_sect); } #endif static int32_t -get_start_sect(const struct partition *p) { +get_start_sect(const struct partition *p) +{ return read4_little_endian(p->start4); } #ifdef CONFIG_FEATURE_FDISK_WRITABLE static void -set_nr_sects(struct partition *p, int32_t nr_sects) { +set_nr_sects(struct partition *p, int32_t nr_sects) +{ store4_little_endian(p->size4, nr_sects); } #endif static int32_t -get_nr_sects(const struct partition *p) { +get_nr_sects(const struct partition *p) +{ return read4_little_endian(p->size4); } @@ -3337,9 +3392,9 @@ get_nr_sects(const struct partition *p) { static int type_open = O_RDWR; -static int ext_index, /* the prime extended partition */ - listing, /* no aborts for fdisk -l */ - dos_compatible_flag = ~0; +static int ext_index; /* the prime extended partition */ +static int listing; /* no aborts for fdisk -l */ +static int dos_compatible_flag = ~0; #ifdef CONFIG_FEATURE_FDISK_WRITABLE static int dos_changed; static int nowarn; /* no warnings for fdisk -l/-s */ @@ -3347,9 +3402,9 @@ static int nowarn; /* no warnings for fdisk -l/-s */ -static uint user_cylinders, user_heads, user_sectors; -static uint pt_heads, pt_sectors; -static uint kern_heads, kern_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 */ @@ -3358,7 +3413,8 @@ static unsigned long long total_number_of_sectors; static jmp_buf listingbuf; -static void fdisk_fatal(enum failure why) { +static void fdisk_fatal(enum failure why) +{ const char *message; if (listing) { @@ -3367,23 +3423,23 @@ static void fdisk_fatal(enum failure why) { } switch (why) { - case unable_to_open: - message = "Unable to open %s\n"; - break; - case unable_to_read: - message = "Unable to read %s\n"; - break; - case unable_to_seek: - message = "Unable to seek on %s\n"; - break; - case unable_to_write: - message = "Unable to write %s\n"; - break; - case ioctl_error: - message = "BLKGETSIZE ioctl failed on %s\n"; - break; - default: - message = "Fatal error\n"; + case unable_to_open: + message = "Unable to open %s\n"; + break; + case unable_to_read: + message = "Unable to read %s\n"; + break; + case unable_to_seek: + message = "Unable to seek on %s\n"; + break; + case unable_to_write: + message = "Unable to write %s\n"; + break; + case ioctl_error: + message = "BLKGETSIZE ioctl failed on %s\n"; + break; + default: + message = "Fatal error\n"; } fputc('\n', stderr); @@ -3392,7 +3448,8 @@ static void fdisk_fatal(enum failure why) { } static void -seek_sector(off_t secno) { +seek_sector(off_t secno) +{ off_t offset = secno * sector_size; if (lseek(fd, offset, SEEK_SET) == (off_t) -1) fdisk_fatal(unable_to_seek); @@ -3400,7 +3457,8 @@ seek_sector(off_t secno) { #ifdef CONFIG_FEATURE_FDISK_WRITABLE static void -write_sector(off_t secno, char *buf) { +write_sector(off_t secno, char *buf) +{ seek_sector(secno); if (write(fd, buf, sector_size) != sector_size) fdisk_fatal(unable_to_write); @@ -3409,8 +3467,8 @@ write_sector(off_t secno, char *buf) { /* Allocate a buffer and read a partition table sector */ static void -read_pte(struct pte *pe, off_t offset) { - +read_pte(struct pte *pe, off_t offset) +{ pe->offset = offset; pe->sectorbuffer = (char *) xmalloc(sector_size); seek_sector(offset); @@ -3423,7 +3481,8 @@ read_pte(struct pte *pe, off_t offset) { } static unsigned int -get_partition_start(const struct pte *pe) { +get_partition_start(const struct pte *pe) +{ return pe->offset + get_start_sect(pe->part_table); } @@ -3435,7 +3494,8 @@ get_partition_start(const struct pte *pe) { * for "is probably nondos partition". */ static int -is_dos_partition(int t) { +is_dos_partition(int t) +{ return (t == 1 || t == 4 || t == 6 || t == 0x0b || t == 0x0c || t == 0x0e || t == 0x11 || t == 0x12 || t == 0x14 || t == 0x16 || @@ -3444,78 +3504,79 @@ is_dos_partition(int t) { } static void -menu(void) { +menu(void) +{ #ifdef CONFIG_FEATURE_SUN_LABEL if (sun_label) { - 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")); + 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(_("\tx\textra functionality (experts only)")); #endif } else #endif #ifdef CONFIG_FEATURE_SGI_LABEL if (sgi_label) { - 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")); + 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 #endif #ifdef CONFIG_FEATURE_AIX_LABEL if (aix_label) { - 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 */ + 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 #endif { - 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")); + 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)")); + puts(_("\tx\textra functionality (experts only)")); #endif } } @@ -3524,88 +3585,90 @@ menu(void) { #ifdef CONFIG_FEATURE_FDISK_ADVANCED static void -xmenu(void) { +xmenu(void) +{ #ifdef CONFIG_FEATURE_SUN_LABEL if (sun_label) { - 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*/ + 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 #endif #ifdef CONFIG_FEATURE_SGI_LABEL if (sgi_label) { - 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")); + 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 #endif #ifdef CONFIG_FEATURE_AIX_LABEL if (aix_label) { - 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")); + 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 #endif { - 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 */ + 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 */ -#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(_("\tg\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")); } } #endif /* ADVANCED mode */ #ifdef CONFIG_FEATURE_FDISK_WRITABLE static const struct systypes * -get_sys_types(void) { +get_sys_types(void) +{ return ( #ifdef CONFIG_FEATURE_SUN_LABEL sun_label ? sun_sys_types : @@ -3624,7 +3687,7 @@ static const char *partition_type(unsigned char type) int i; const struct systypes *types = get_sys_types(); - for (i=0; types[i].name; i++) + for (i = 0; types[i].name; i++) if ((unsigned char )types[i].name[0] == type) return types[i].name + 1; @@ -3634,7 +3697,8 @@ static const char *partition_type(unsigned char type) #ifdef CONFIG_FEATURE_FDISK_WRITABLE static int -get_sysid(int i) { +get_sysid(int i) +{ return ( #ifdef CONFIG_FEATURE_SUN_LABEL sun_label ? sunlabel->infos[i].id : @@ -3672,14 +3736,16 @@ void list_types(const struct systypes *sys) #endif /* CONFIG_FEATURE_FDISK_WRITABLE */ static int -is_cleared_partition(const struct partition *p) { +is_cleared_partition(const struct partition *p) +{ return !(!p || p->boot_ind || p->head || p->sector || p->cyl || p->sys_ind || p->end_head || p->end_sector || p->end_cyl || get_start_sect(p) || get_nr_sects(p)); } static void -clear_partition(struct partition *p) { +clear_partition(struct partition *p) +{ if (!p) return; memset(p, 0, sizeof(struct partition)); @@ -3687,7 +3753,8 @@ clear_partition(struct partition *p) { #ifdef CONFIG_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, off_t start, off_t stop, int sysid) +{ struct partition *p; off_t offset; @@ -3713,7 +3780,8 @@ set_partition(int i, int doext, off_t start, off_t stop, int sysid) { #endif static int -test_c(const char **m, const char *mesg) { +test_c(const char **m, const char *mesg) +{ int val = 0; if (!*m) fprintf(stderr, _("You must set")); @@ -3726,7 +3794,8 @@ test_c(const char **m, const char *mesg) { } static int -warn_geometry(void) { +warn_geometry(void) +{ const char *m = NULL; int prev = 0; @@ -3760,7 +3829,8 @@ static void update_units(void) #ifdef CONFIG_FEATURE_FDISK_WRITABLE static void -warn_cylinders(void) { +warn_cylinders(void) +{ if (dos_label && cylinders > 1024 && !nowarn) fprintf(stderr, _("\n" "The number of cylinders for this disk is set to %d.\n" @@ -3774,7 +3844,8 @@ warn_cylinders(void) { #endif static void -read_extended(int ext) { +read_extended(int ext) +{ int i; struct pte *pex; struct partition *p, *q; @@ -3790,7 +3861,7 @@ read_extended(int ext) { return; } - while (IS_EXTENDED (p->sys_ind)) { + while (IS_EXTENDED(p->sys_ind)) { struct pte *pe = &ptes[partitions]; if (partitions >= MAXIMUM_PARTS) { @@ -3815,7 +3886,7 @@ read_extended(int ext) { q = p = pt_offset(pe->sectorbuffer, 0); for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) { - if (IS_EXTENDED (p->sys_ind)) { + if (IS_EXTENDED(p->sys_ind)) { if (pe->ext_pointer) fprintf(stderr, _("Warning: extra link " @@ -3859,7 +3930,7 @@ read_extended(int ext) { struct pte *pe = &ptes[i]; if (!get_nr_sects(pe->part_table) && - (partitions > 5 || ptes[4].part_table->sys_ind)) { + (partitions > 5 || ptes[4].part_table->sys_ind)) { printf("omitting empty partition (%d)\n", i+1); delete_partition(i); goto remove; /* numbering changed */ @@ -3870,7 +3941,8 @@ read_extended(int ext) { #ifdef CONFIG_FEATURE_FDISK_WRITABLE static void -create_doslabel(void) { +create_doslabel(void) +{ int i; fprintf(stderr, @@ -3903,20 +3975,22 @@ create_doslabel(void) { #endif /* CONFIG_FEATURE_FDISK_WRITABLE */ static void -get_sectorsize(void) { - if (!user_set_sector_size && - get_kernel_revision() >= MAKE_VERSION(2,3,3)) { +get_sectorsize(void) +{ + if (!user_set_sector_size + && get_kernel_revision() >= MAKE_VERSION(2,3,3)) { int arg; if (ioctl(fd, BLKSSZGET, &arg) == 0) sector_size = arg; if (sector_size != DEFAULT_SECTOR_SIZE) printf(_("Note: sector size is %d (not %d)\n"), - sector_size, DEFAULT_SECTOR_SIZE); + sector_size, DEFAULT_SECTOR_SIZE); } } static inline void -get_kernel_geometry(void) { +get_kernel_geometry(void) +{ struct hd_geometry geometry; if (!ioctl(fd, HDIO_GETGEO, &geometry)) { @@ -3927,7 +4001,8 @@ get_kernel_geometry(void) { } static void -get_partition_table_geometry(void) { +get_partition_table_geometry(void) +{ const unsigned char *bufp = (const unsigned char *)MBRbuffer; struct partition *p; int i, h, s, hh, ss; @@ -3938,7 +4013,7 @@ get_partition_table_geometry(void) { return; hh = ss = 0; - for (i=0; i<4; i++) { + for (i = 0; i < 4; i++) { p = pt_offset(bufp, i); if (p->sys_ind != 0) { h = p->end_head + 1; @@ -3958,8 +4033,9 @@ get_partition_table_geometry(void) { } } -void -get_geometry(void) { +static void +get_geometry(void) +{ int sec_fac; unsigned long long bytes; /* really u64 */ @@ -4008,8 +4084,9 @@ get_geometry(void) { * 0: found or created label * 1: I/O error */ -int -get_boot(enum action what) { +static int +get_boot(enum action what) +{ int i; partitions = 4; @@ -4038,13 +4115,13 @@ get_boot(enum action what) { goto got_dos_table; /* skip reading disk */ if ((fd = open(disk_device, type_open)) < 0) { - if ((fd = open(disk_device, O_RDONLY)) < 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")); + if ((fd = open(disk_device, O_RDONLY)) < 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")); } if (512 != read(fd, MBRbuffer, 512)) { @@ -4091,14 +4168,14 @@ get_boot(enum action what) { #endif #ifdef CONFIG_FEATURE_FDISK_WRITABLE -got_dos_table: + got_dos_table: #endif if (!valid_part_table_flag(MBRbuffer)) { #ifndef CONFIG_FEATURE_FDISK_WRITABLE return -1; #else - switch(what) { + switch (what) { case fdisk: fprintf(stderr, _("Device contains neither a valid DOS " @@ -4134,7 +4211,7 @@ got_dos_table: for (i = 0; i < 4; i++) { struct pte *pe = &ptes[i]; - if (IS_EXTENDED (pe->part_table->sys_ind)) { + if (IS_EXTENDED(pe->part_table->sys_ind)) { if (partitions != 4) fprintf(stderr, _("Ignoring extra extended " "partition %d\n"), i + 1); @@ -4188,62 +4265,61 @@ read_int(uint low, uint dflt, uint high, uint base, char *mesg) snprintf(ms, mslen, _("%s (%u-%u, default %u): "), mesg, low, high, dflt); else - snprintf(ms, mslen, "%s (%u-%u): ", - mesg, low, high); + snprintf(ms, mslen, "%s (%u-%u): ", mesg, low, high); while (1) { int use_default = default_ok; /* ask question and read answer */ while (read_chars(ms) != '\n' && !isdigit(*line_ptr) - && *line_ptr != '-' && *line_ptr != '+') + && *line_ptr != '-' && *line_ptr != '+') continue; if (*line_ptr == '+' || *line_ptr == '-') { - int minus = (*line_ptr == '-'); - int absolute = 0; + int minus = (*line_ptr == '-'); + int absolute = 0; - i = atoi(line_ptr+1); + i = atoi(line_ptr+1); - while (isdigit(*++line_ptr)) - use_default = 0; + while (isdigit(*++line_ptr)) + use_default = 0; - switch (*line_ptr) { - case 'c': - case 'C': - if (!display_in_cyl_units) - i *= heads * sectors; - break; - case 'K': - absolute = 1024; - break; - case 'k': - absolute = 1000; - break; - case 'm': - case 'M': - absolute = 1000000; - break; - case 'g': - case 'G': - absolute = 1000000000; - break; - default: - break; - } - if (absolute) { - unsigned long long bytes; - unsigned long unit; - - bytes = (unsigned long long) i * absolute; - unit = sector_size * units_per_sector; - bytes += unit/2; /* round */ - bytes /= unit; - i = bytes; + switch (*line_ptr) { + case 'c': + case 'C': + if (!display_in_cyl_units) + i *= heads * sectors; + break; + case 'K': + absolute = 1024; + break; + case 'k': + absolute = 1000; + break; + case 'm': + case 'M': + absolute = 1000000; + break; + case 'g': + case 'G': + absolute = 1000000000; + break; + default: + break; + } + if (absolute) { + unsigned long long bytes; + unsigned long unit; + + bytes = (unsigned long long) i * absolute; + unit = sector_size * units_per_sector; + bytes += unit/2; /* round */ + bytes /= unit; + i = bytes; } - if (minus) - i = -i; - i += base; + if (minus) + i = -i; + i += base; } else { i = atoi(line_ptr); while (isdigit(*line_ptr)) { @@ -4261,8 +4337,9 @@ read_int(uint low, uint dflt, uint high, uint base, char *mesg) return i; } -int -get_partition(int warn, int max) { +static int +get_partition(int warn, int max) +{ struct pte *pe; int i; @@ -4272,12 +4349,12 @@ get_partition(int warn, int max) { if (warn) { if ((!sun_label && !sgi_label && !pe->part_table->sys_ind) #ifdef CONFIG_FEATURE_SUN_LABEL - || (sun_label && + || (sun_label && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id)) #endif #ifdef CONFIG_FEATURE_SGI_LABEL - || (sgi_label && (!sgi_get_num_sectors(i))) + || (sgi_label && (!sgi_get_num_sectors(i))) #endif ) fprintf(stderr, @@ -4288,7 +4365,8 @@ get_partition(int warn, int max) { } static int -get_existing_partition(int warn, int max) { +get_existing_partition(int warn, int max) +{ int pno = -1; int i; @@ -4314,7 +4392,8 @@ get_existing_partition(int warn, int max) { } static int -get_nonexisting_partition(int warn, int max) { +get_nonexisting_partition(int warn, int max) +{ int pno = -1; int i; @@ -4349,11 +4428,12 @@ void change_units(void) } static void -toggle_active(int i) { +toggle_active(int i) +{ struct pte *pe = &ptes[i]; struct partition *p = pe->part_table; - if (IS_EXTENDED (p->sys_ind) && !p->boot_ind) + if (IS_EXTENDED(p->sys_ind) && !p->boot_ind) fprintf(stderr, _("WARNING: Partition %d is an extended partition\n"), i + 1); @@ -4362,7 +4442,8 @@ toggle_active(int i) { } static void -toggle_dos_compatibility_flag(void) { +toggle_dos_compatibility_flag(void) +{ dos_compatible_flag = ~dos_compatible_flag; if (dos_compatible_flag) { sector_offset = sectors; @@ -4375,7 +4456,8 @@ toggle_dos_compatibility_flag(void) { } static void -delete_partition(int i) { +delete_partition(int i) +{ struct pte *pe = &ptes[i]; struct partition *p = pe->part_table; struct partition *q = pe->ext_pointer; @@ -4402,7 +4484,7 @@ delete_partition(int i) { #endif if (i < 4) { - if (IS_EXTENDED (p->sys_ind) && i == ext_index) { + if (IS_EXTENDED(p->sys_ind) && i == ext_index) { partitions = 4; ptes[ext_index].ext_pointer = NULL; extended_offset = 0; @@ -4432,8 +4514,8 @@ delete_partition(int i) { if (pe->part_table) /* prevent SEGFAULT */ set_start_sect(pe->part_table, - get_partition_start(pe) - - extended_offset); + get_partition_start(pe) - + extended_offset); pe->offset = extended_offset; pe->changed = 1; } @@ -4451,7 +4533,8 @@ delete_partition(int i) { } static void -change_sysid(void) { +change_sysid(void) +{ int i, sys, origsys; struct partition *p; @@ -4460,7 +4543,7 @@ change_sysid(void) { let the user select a partition, since get_existing_partition() only works for Linux like partition tables. */ if (!sgi_label) { - i = get_existing_partition(0, partitions); + i = get_existing_partition(0, partitions); } else { i = get_partition(0, partitions); } @@ -4481,17 +4564,17 @@ change_sysid(void) { if (!sys && !sgi_label && !sun_label) { 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")); + "(but not to Linux). Having partitions of\n" + "type 0 is probably unwise. You can delete\n" + "a partition using the `d' command.\n")); /* break; */ } if (!sun_label && !sgi_label) { - if (IS_EXTENDED (sys) != IS_EXTENDED (p->sys_ind)) { + 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")); + " an extended one or vice versa\n" + "Delete it first.\n")); break; } } @@ -4500,17 +4583,17 @@ change_sysid(void) { #ifdef CONFIG_FEATURE_SUN_LABEL if (sun_label && i == 2 && sys != WHOLE_DISK) printf(_("Consider leaving partition 3 " - "as Whole disk (5),\n" - "as SunOS/Solaris expects it and " - "even Linux likes it.\n\n")); + "as Whole disk (5),\n" + "as SunOS/Solaris expects it and " + "even Linux likes it.\n\n")); #endif #ifdef CONFIG_FEATURE_SGI_LABEL if (sgi_label && ((i == 10 && sys != ENTIRE_DISK) || (i == 8 && sys != 0))) printf(_("Consider leaving partition 9 " - "as volume header (0),\nand " - "partition 11 as entire volume (6)" - "as IRIX expects it.\n\n")); + "as volume header (0),\nand " + "partition 11 as entire volume (6)" + "as IRIX expects it.\n\n")); #endif if (sys == origsys) break; @@ -4525,12 +4608,12 @@ change_sysid(void) { } else #endif p->sys_ind = sys; - printf (_("Changed system type of partition %d " + 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) || - is_dos_partition(sys)) + is_dos_partition(sys)) dos_changed = 1; break; } @@ -4544,8 +4627,10 @@ change_sysid(void) { * 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) { - int spc = heads * sectors; +static void +long2chs(ulong ls, uint *c, uint *h, uint *s) +{ + int spc = heads * sectors; *c = ls / spc; ls = ls % spc; @@ -4553,11 +4638,13 @@ static void long2chs(ulong ls, uint *c, uint *h, uint *s) { *s = ls % sectors + 1; /* sectors count from 1 */ } -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 */ +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 */ if (!heads || !sectors || (partition >= 4)) return; /* do not check extended partitions */ @@ -4617,24 +4704,25 @@ static void check_consistency(const struct partition *p, int partition) { } static void -list_disk_geometry(void) { +list_disk_geometry(void) +{ long long bytes = (total_number_of_sectors << 9); long megabytes = bytes/1000000; if (megabytes < 10000) printf(_("\nDisk %s: %ld MB, %lld bytes\n"), - disk_device, megabytes, bytes); + disk_device, megabytes, bytes); else printf(_("\nDisk %s: %ld.%ld GB, %lld bytes\n"), - disk_device, megabytes/1000, (megabytes/100)%10, bytes); + disk_device, megabytes/1000, (megabytes/100)%10, bytes); printf(_("%d heads, %d sectors/track, %d cylinders"), - heads, sectors, cylinders); + heads, sectors, cylinders); if (units_per_sector == 1) printf(_(", total %llu sectors"), - total_number_of_sectors / (sector_size/512)); + total_number_of_sectors / (sector_size/512)); printf(_("\nUnits = %s of %d * %d = %d bytes\n\n"), - str_units(PLURAL), - units_per_sector, sector_size, units_per_sector * sector_size); + str_units(PLURAL), + units_per_sector, sector_size, units_per_sector * sector_size); } /* @@ -4643,7 +4731,8 @@ list_disk_geometry(void) { * Two separate checks: primary and logical partitions. */ static int -wrong_p_order(int *prev) { +wrong_p_order(int *prev) +{ const struct pte *pe; const struct partition *p; off_t last_p_start_pos = 0, p_start_pos; @@ -4686,7 +4775,8 @@ wrong_p_order(int *prev) { * may help. */ static void -fix_chain_of_logicals(void) { +fix_chain_of_logicals(void) +{ int j, oj, ojj, sj, sjj; struct partition *pj,*pjj,tmp; @@ -4704,9 +4794,9 @@ fix_chain_of_logicals(void) { pjj = ptes[j+1].part_table; set_start_sect(pjj, get_start_sect(pjj)+ojj-oj); set_start_sect(ptes[j-1].ext_pointer, - ojj-extended_offset); + ojj-extended_offset); set_start_sect(ptes[j].ext_pointer, - oj-extended_offset); + oj-extended_offset); goto stage1; } } @@ -4737,7 +4827,8 @@ fix_chain_of_logicals(void) { static void -fix_partition_table_order(void) { +fix_partition_table_order(void) +{ struct pte *pei, *pek; int i,k; @@ -4776,7 +4867,8 @@ fix_partition_table_order(void) { #endif static void -list_table(int xtra) { +list_table(int xtra) +{ const struct partition *p; int i, w; @@ -4813,7 +4905,7 @@ list_table(int xtra) { w = 5; printf(_("%*s Boot Start End Blocks Id System\n"), - w+1, _("Device")); + w+1, _("Device")); for (i = 0; i < partitions; i++) { const struct pte *pe = &ptes[i]; @@ -4831,7 +4923,7 @@ list_table(int xtra) { if (sector_size > 1024) pblocks *= (sector_size / 1024); printf( - "%s %c %11llu %11llu %11llu%c %2x %s\n", + "%s %c %11llu %11llu %11llu%c %2x %s\n", partname(disk_device, i+1, w+2), /* boot flag */ !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG ? '*' : '?', @@ -4855,7 +4947,8 @@ list_table(int xtra) { #ifdef CONFIG_FEATURE_FDISK_ADVANCED static void -x_list_table(int extend) { +x_list_table(int extend) +{ const struct pte *pe; const struct partition *p; int i; @@ -4883,14 +4976,15 @@ x_list_table(int extend) { #ifdef CONFIG_FEATURE_FDISK_WRITABLE static void -fill_bounds(off_t *first, off_t *last) { +fill_bounds(off_t *first, off_t *last) +{ int i; const struct pte *pe = &ptes[0]; const struct partition *p; for (i = 0; i < partitions; pe++,i++) { p = pe->part_table; - if (!p->sys_ind || IS_EXTENDED (p->sys_ind)) { + if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) { first[i] = 0xffffffff; last[i] = 0; } else { @@ -4901,7 +4995,8 @@ fill_bounds(off_t *first, off_t *last) { } static void -check(int n, uint h, uint s, uint c, off_t start) { +check(int n, uint h, uint s, uint c, off_t start) +{ off_t total, real_s, real_c; real_s = sector(s) - 1; @@ -4926,7 +5021,8 @@ check(int n, uint h, uint s, uint c, off_t start) { } static void -verify(void) { +verify(void) +{ int i, j; uint total = 1; off_t first[partitions], last[partitions]; @@ -4953,7 +5049,7 @@ verify(void) { struct pte *pe = &ptes[i]; p = pe->part_table; - if (p->sys_ind && !IS_EXTENDED (p->sys_ind)) { + 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 " @@ -5002,7 +5098,8 @@ verify(void) { } static void -add_partition(int n, int sys) { +add_partition(int n, int sys) +{ char mesg[256]; /* 48 does not suffice in Japanese */ int i, readed = 0; struct partition *p = ptes[n].part_table; @@ -5047,7 +5144,7 @@ add_partition(int n, int sys) { if (start == ptes[i].offset) start += sector_offset; - lastplusoff = last[i] + ((n<4) ? 0 : sector_offset); + lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset); if (start >= first[i] && start <= lastplusoff) start = lastplusoff + 1; } @@ -5115,7 +5212,7 @@ add_partition(int n, int sys) { if (n > 4) set_partition(n - 1, 1, ptes[n].offset, stop, EXTENDED); - if (IS_EXTENDED (sys)) { + if (IS_EXTENDED(sys)) { struct pte *pe4 = &ptes[4]; struct pte *pen = &ptes[n]; @@ -5131,7 +5228,8 @@ add_partition(int n, int sys) { } static void -add_logical(void) { +add_logical(void) +{ if (partitions > 5 || ptes[4].part_table->sys_ind) { struct pte *pe = &ptes[partitions]; @@ -5146,7 +5244,8 @@ add_logical(void) { } static void -new_partition(void) { +new_partition(void) +{ int i, free_primary = 0; if (warn_geometry()) @@ -5178,10 +5277,10 @@ new_partition(void) { for (i = 0; i < 4; i++) free_primary += !ptes[i].part_table->sys_ind; - if (!free_primary && partitions >= MAXIMUM_PARTS) { + if (!free_primary && partitions >= MAXIMUM_PARTS) { printf(_("The maximum number of partitions has been created\n")); return; - } + } if (!free_primary) { if (extended_offset) @@ -5220,11 +5319,12 @@ new_partition(void) { } static void -write_table(void) { +write_table(void) +{ int i; if (dos_label) { - for (i=0; i<3; i++) + for (i = 0; i < 3; i++) if (ptes[i].changed) ptes[3].changed = 1; for (i = 3; i < partitions; i++) { @@ -5243,10 +5343,10 @@ write_table(void) { } #endif #ifdef CONFIG_FEATURE_SUN_LABEL - else if (sun_label) { + else if (sun_label) { int needw = 0; - for (i=0; i<8; i++) + for (i = 0; i < 8; i++) if (ptes[i].changed) needw = 1; if (needw) @@ -5258,8 +5358,9 @@ write_table(void) { reread_partition_table(1); } -void -reread_partition_table(int leave) { +static void +reread_partition_table(int leave) +{ int error = 0; int i; @@ -5288,7 +5389,7 @@ reread_partition_table(int leave) { } if (dos_changed) - printf( + 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")); @@ -5307,9 +5408,9 @@ reread_partition_table(int leave) { #ifdef CONFIG_FEATURE_FDISK_ADVANCED #define MAX_PER_LINE 16 static void -print_buffer(char pbuffer[]) { - int i, - l; +print_buffer(char *pbuffer) +{ + int i,l; for (i = 0, l = 0; i < sector_size; i++, l++) { if (l == 0) @@ -5327,7 +5428,8 @@ print_buffer(char pbuffer[]) { static void -print_raw(void) { +print_raw(void) +{ int i; printf(_("Device: %s\n"), disk_device); @@ -5341,20 +5443,21 @@ print_raw(void) { } static void -move_begin(int i) { +move_begin(int i) +{ struct pte *pe = &ptes[i]; struct partition *p = pe->part_table; off_t new, first; if (warn_geometry()) return; - if (!p->sys_ind || !get_nr_sects(p) || IS_EXTENDED (p->sys_ind)) { + if (!p->sys_ind || !get_nr_sects(p) || IS_EXTENDED(p->sys_ind)) { 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; @@ -5365,10 +5468,11 @@ move_begin(int i) { } static void -xselect(void) { +xselect(void) +{ char c; - while(1) { + while (1) { putchar('\n'); c = tolower(read_char(_("Expert command (m for help): "))); switch (c) { @@ -5385,7 +5489,7 @@ xselect(void) { case 'c': user_cylinders = cylinders = read_int(1, cylinders, 1048576, 0, - _("Number of cylinders")); + _("Number of cylinders")); #ifdef CONFIG_FEATURE_SUN_LABEL if (sun_label) sun_set_ncyl(cylinders); @@ -5421,7 +5525,7 @@ xselect(void) { break; case 'h': user_heads = heads = read_int(1, heads, 256, 0, - _("Number of heads")); + _("Number of heads")); update_units(); break; case 'i': @@ -5481,7 +5585,8 @@ xselect(void) { #endif /* ADVANCED mode */ static int -is_ide_cdrom_or_tape(const char *device) { +is_ide_cdrom_or_tape(const char *device) +{ FILE *procf; char buf[100]; struct stat statbuf; @@ -5514,7 +5619,8 @@ is_ide_cdrom_or_tape(const char *device) { } static void -try(const char *device, int user_specified) { +try(const char *device, int user_specified) +{ int gb; disk_device = device; @@ -5536,7 +5642,7 @@ try(const char *device, int user_specified) { #endif fprintf(stderr, _("Disk %s doesn't contain a valid " - "partition table\n"), device); + "partition table\n"), device); close(fd); } else { close(fd); @@ -5560,7 +5666,8 @@ try(const char *device, int user_specified) { /* for fdisk -l: try all things in /proc/partitions that look like a partition name (do not end in a digit) */ static void -tryprocpt(void) { +tryprocpt(void) +{ FILE *procpt; char line[100], ptname[100], devname[120], *s; int ma, mi, sz; @@ -5568,8 +5675,8 @@ tryprocpt(void) { procpt = bb_wfopen(PROC_PARTITIONS, "r"); while (fgets(line, sizeof(line), procpt)) { - if (sscanf (line, " %d %d %d %[^\n ]", - &ma, &mi, &sz, ptname) != 4) + if (sscanf(line, " %d %d %d %[^\n ]", + &ma, &mi, &sz, ptname) != 4) continue; for (s = ptname; *s; s++); if (isdigit(s[-1])) @@ -5584,12 +5691,14 @@ tryprocpt(void) { #ifdef CONFIG_FEATURE_FDISK_WRITABLE static void -unknown_command(int c) { +unknown_command(int 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; @@ -5620,7 +5729,7 @@ int fdisk_main(int argc, char **argv) { */ sector_size = atoi(optarg); if (sector_size != 512 && sector_size != 1024 && - sector_size != 2048) + sector_size != 2048) bb_show_usage(); sector_offset = 2; user_set_sector_size = 1; @@ -5682,7 +5791,7 @@ int fdisk_main(int argc, char **argv) { (void)&k; #endif listing = 1; - for (k=optind; k<argc; k++) + for (k = optind; k < argc; k++) try(argv[k], 1); } else { /* we no longer have default device names */ @@ -5735,7 +5844,7 @@ int fdisk_main(int argc, char **argv) { /* OSF label, and no DOS label */ printf(_("Detected an OSF/1 disklabel on %s, entering " "disklabel mode.\n"), - disk_device); + disk_device); bselect(); osf_label = 0; /* If we return we may want to make an empty DOS label? */ @@ -5766,9 +5875,9 @@ int fdisk_main(int argc, char **argv) { #ifdef CONFIG_FEATURE_SGI_LABEL if (sgi_label) { printf(_("\nThe current boot file is: %s\n"), - sgi_get_bootfile()); + sgi_get_bootfile()); if (read_chars(_("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); |