fdisk applet by Vladimir N. Oleynik
authorGlenn L McGrath <bug1@ihug.co.nz>
Tue, 26 Nov 2002 22:00:21 +0000 (22:00 -0000)
committerGlenn L McGrath <bug1@ihug.co.nz>
Tue, 26 Nov 2002 22:00:21 +0000 (22:00 -0000)
AUTHORS
docs/busybox_footer.pod
docs/busybox_header.pod
include/applets.h
include/usage.h
util-linux/Makefile.in
util-linux/config.in
util-linux/fdisk.c [new file with mode: 0644]

diff --git a/AUTHORS b/AUTHORS
index 40b925bd69160fd6e1411caf013120257172522e..7ec7d4966c17e4eb2cc6e9cfeff4e67f437306d2 100644 (file)
--- a/AUTHORS
+++ b/AUTHORS
@@ -67,7 +67,8 @@ Glenn McGrath <bug1@optushome.com.au>
     ar, dpkg, dpkg-deb
 
 Vladimir Oleynik <dzo@simtreas.ru>
-    cmdedit; xargs(current); ports: ash, crond, stty, traceroute, telnetd, top;
+    cmdedit; xargs(current);
+    ports: ash, crond, fdisk, stty, traceroute, telnetd, top;
     locale, various fixes
     and irreconcilable critic of everything not perfect.
 
index 1506768c481caa29c502309df08dcde9eea1dec2..7c53cced5224b53cce635789d5c814cf9504ecbd 100644 (file)
@@ -113,7 +113,8 @@ Glenn McGrath <bug1@netconnect.com.au>
 
 Vladimir Oleynik <dzo@simtreas.ru>
 
-    cmdedit, xargs(current); ports: ash, crond, stty, traceroute, telnetd, top;
+    cmdedit, xargs(current);
+    ports: ash, crond, fdisk, stty, traceroute, telnetd, top;
     locale, various fixes
     and irreconcilable critic of everything not perfect.
 
@@ -167,4 +168,4 @@ Enrique Zanardi <ezanardi@ull.es>
 
 =cut
 
-# $Id: busybox_footer.pod,v 1.8 2002/11/10 21:47:15 bug1 Exp $
+# $Id: busybox_footer.pod,v 1.9 2002/11/26 22:00:19 bug1 Exp $
index 2b289bd1ad009f261219af10f9c63040d8ac9052..a684cc1945279955e4111a4e7c6dd7cded1ef9a9 100644 (file)
@@ -58,10 +58,10 @@ Currently defined functions include:
    addgroup, adduser, adjtimex, ar, awk,  basename,  busybox,  cat,  chgrp,
 chmod, chown, chroot, chvt, clear, cmp,  cp,  cpio,  crond,  crontab,  cut,
 date, dc, dd, deallocvt,  deluser,  df,  dirname,  dmesg,  dos2unix,  dpkg,
-dpkg-deb, du, dumpkmap, dutmp, echo, expr,  false,  fbset,  fdflush,  find,
-free, freeramdisk, fsck.minix, getopt, getty,  grep,  gunzip,  gzip,  halt,
-head, hostid, hostname, id, ifconfig, init, insmod, kill,  killall,  klogd,
-length, ln,  loadacm,  loadfont,  loadkmap,  logger,  logname,  ls,  lsmod,
+dpkg-deb, du, dumpkmap, dutmp, echo, expr, false,  fbset,  fdflush,  fdisk,
+find, free, freeramdisk, fsck.minix, getopt,  getty,  grep,  gunzip,  gzip,
+halt, head, hostid, hostname, id, ifconfig, init,  insmod,  kill,  killall,
+klogd, length, ln, loadacm, loadfont, loadkmap, logger, logname, ls, lsmod,
 makedevs, md5sum, mkdir, mkfifo, mkfs.minix, mknod, mkswap,  mktemp,  more,
 mount, mt, mv, nc, netstat, nslookup, ping, pivot_root,  poweroff,  printf,
 ps, pwd, rdate, readlink, reboot, renice, reset, rm, rmdir,  rmmod,  route,
index e8bcb0e4b9967c12a63e4340b7207e09621aa75f..a85a8bfcb2ed0e31ff5dec09030749321dc2cc91 100644 (file)
 #ifdef CONFIG_FDFLUSH
        APPLET(fdflush, fdflush_main, _BB_DIR_BIN, _BB_SUID_NEVER)
 #endif
+#ifdef CONFIG_FDISK
+       APPLET(fdisk, fdisk_main, _BB_DIR_SBIN, _BB_SUID_NEVER)
+#endif
 #ifdef CONFIG_FIND
        APPLET(find, find_main, _BB_DIR_USR_BIN, _BB_SUID_NEVER)
 #endif
index 3677dff7a5fb24ea89fa1d8e85fbcc57baa8668b..568899b6db3d7de987bfae7573d6fc05833398f2 100644 (file)
 #define fdflush_full_usage \
        "Forces floppy disk drive to detect disk change"
 
+#define fdisk_trivial_usage \
+       "[-l] [-v] [-b SSZ] [-u] DISK"
+#define fdisk_full_usage \
+       "Change partition table\n" \
+       "Options:\n" \
+       "-l  List partition table(s)\n" \
+       "-u  Give Start and End in sector (instead of cylinder) units\n" \
+       "-s PARTITION  Give partition size(s) in blocks\n" \
+       "-b 2048: (for certain MO disks) use 2048-byte sectors\n" \
+       "-v            Give fdisk version\n"
+
 #ifdef CONFIG_FEATURE_FIND_TYPE
   #define USAGE_FIND_TYPE(a) a
 #else
index 03012fb6efa6634dd0b9cb37efde8ca4858b1154..4e18714254a68bc685243ec878cf2108cd821388 100644 (file)
@@ -26,6 +26,7 @@ UTILLINUX-:=
 UTILLINUX-$(CONFIG_DMESG)              += dmesg.o
 UTILLINUX-$(CONFIG_FBSET)              += fbset.o
 UTILLINUX-$(CONFIG_FDFLUSH)            += fdflush.o
+UTILLINUX-$(CONFIG_FDISK)               += fdisk.o
 UTILLINUX-$(CONFIG_FREERAMDISK)        += freeramdisk.o
 UTILLINUX-$(CONFIG_FSCK_MINIX) += fsck_minix.o
 UTILLINUX-$(CONFIG_GETOPT)             += getopt.o
index 25d0c5ad4237ef0e9d19d6a6cd1abfa2fd9ed360..e6d46639cc5079340f08835b56ff6cc5e11407c5 100644 (file)
@@ -14,6 +14,14 @@ if [ "$CONFIG_FBSET" = "y" ]; then
     bool '  Turn on fbset readmode support'    CONFIG_FEATURE_FBSET_READMODE
 fi
 bool 'fdflush'             CONFIG_FDFLUSH
+bool 'fdisk'                CONFIG_FDISK
+if [ "$CONFIG_FDISK" = "y" ]; then
+    bool '  Support AIX disklabels'        CONFIG_FEATURE_AIX_LABEL
+    bool '  Support SGI disklabels'        CONFIG_FEATURE_SGI_LABEL
+    bool '  Support SUN disklabels'        CONFIG_FEATURE_SUN_LABEL
+    bool '  Support BSD disklabels'        CONFIG_FEATURE_OSF_LABEL
+    bool '  Support expext mode'           CONFIG_FEATURE_FDISK_ADVANCED
+fi
 bool 'freeramdisk'         CONFIG_FREERAMDISK
 bool 'fsck_minix'          CONFIG_FSCK_MINIX
 bool 'mkfs_minix'          CONFIG_MKFS_MINIX
diff --git a/util-linux/fdisk.c b/util-linux/fdisk.c
new file mode 100644 (file)
index 0000000..ea8400c
--- /dev/null
@@ -0,0 +1,5899 @@
+/* fdisk.c -- Partition table manipulator for Linux.
+ *
+ * Copyright (C) 1992  A. V. Le Blanc (LeBlanc@mcc.ac.uk)
+ *
+ * This program is free software.  You can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation: either version 1 or
+ * (at your option) any later version.
+ *
+ * For detailed old history, see older versions.
+ * Contributions before 2001 by faith@cs.unc.edu, Michael Bischoff,
+ * LeBlanc@mcc.ac.uk, martin@cs.unc.edu, leisner@sdsp.mc.xerox.com,
+ * esr@snark.thyrsus.com, aeb@cwi.nl, quinlan@yggdrasil.com,
+ * fasten@cs.bonn.edu, orschaer@cip.informatik.uni-erlangen.de,
+ * jj@sunsite.mff.cuni.cz, fasten@shw.com, ANeuper@GUUG.de,
+ * kgw@suse.de, kalium@gmx.de, dhuggins@linuxcare.com,
+ * michal@ellpspace.math.ualberta.ca and probably others.
+ *
+ * Vladimir Oleynik <dzo@simtreas.ru> 2001,2002 Busybox port
+ */
+
+#define UTIL_LINUX_VERSION "2.11w"
+
+#define PROC_PARTITIONS "/proc/partitions"
+
+#include <sys/types.h>
+#include <sys/stat.h>           /* stat */
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <setjmp.h>
+#include <assert.h>             /* assert */
+#include <getopt.h>
+
+#include <endian.h>
+#define u_char  unsigned char
+#include <scsi/scsi.h>          /* SCSI_IOCTL_GET_IDLUN */
+#undef u_char
+
+#ifdef HAVE_blkpg_h
+#include <linux/blkpg.h>
+#endif
+
+#include <sys/ioctl.h>
+#include <sys/param.h>
+
+#include <linux/types.h>        /* for __u32, __u16, __u8, __s16 */
+#include <linux/major.h>        /* FLOPPY_MAJOR */
+
+#include <sys/utsname.h>
+
+#include "busybox.h"
+
+#define MAKE_VERSION(p,q,r)     (65536*(p) + 256*(q) + (r))
+
+#define DKTYPENAMES
+
+#define _(Text) Text
+
+#define BLKRRPART  _IO(0x12,95)    /* re-read partition table */
+#define BLKGETSIZE _IO(0x12,96)    /* return device size */
+#define BLKFLSBUF  _IO(0x12,97)    /* flush buffer cache */
+#define BLKSSZGET  _IO(0x12,104)   /* get block device sector size */
+
+
+/*
+   fdisk.h
+*/
+
+#define DEFAULT_SECTOR_SIZE     512
+#define MAX_SECTOR_SIZE 2048
+#define SECTOR_SIZE     512     /* still used in BSD code */
+#define MAXIMUM_PARTS   60
+
+#define ACTIVE_FLAG     0x80
+
+#define EXTENDED        0x05
+#define WIN98_EXTENDED  0x0f
+#define LINUX_PARTITION 0x81
+#define LINUX_SWAP      0x82
+#define LINUX_NATIVE    0x83
+#define LINUX_EXTENDED  0x85
+#define LINUX_LVM       0x8e
+#define LINUX_RAID      0xfd
+
+#define SUNOS_SWAP 3
+#define WHOLE_DISK 5
+
+#define IS_EXTENDED(i) \
+       ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
+
+#define SIZE(a) (sizeof(a)/sizeof((a)[0]))
+
+#define cround(n)       (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
+#define scround(x)      (((x)+units_per_sector-1)/units_per_sector)
+
+#if defined(__GNUC__) || defined(HAS_LONG_LONG)
+typedef long long ext2_loff_t;
+#else
+typedef long      ext2_loff_t;
+#endif
+
+/* including <linux/hdreg.h> also fails */
+struct hd_geometry {
+      unsigned char heads;
+      unsigned char sectors;
+      unsigned short cylinders;
+      unsigned long start;
+};
+
+#define HDIO_GETGEO             0x0301  /* get device geometry */
+
+
+struct systypes {
+       const unsigned char *name;
+};
+
+
+/*
+ * Raw disk label. For DOS-type partition tables the MBR,
+ * with descriptions of the primary partitions.
+ */
+static char MBRbuffer[MAX_SECTOR_SIZE];
+
+#ifdef CONFIG_FEATURE_SUN_LABEL
+static int     sun_label;                  /* looking at sun disklabel */
+#else
+#define sun_label 0
+#define check_sun_label() 0
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+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 */
+#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;
+#else
+#define osf_label 0
+#endif
+
+#define dos_label (!sun_label && !sgi_label && !aix_label && !osf_label)
+
+static uint heads, sectors, cylinders;
+static void update_units(void);
+
+static const char *partition_type(unsigned char type);
+
+/*
+ * return partition name - uses static storage unless buf is supplied
+ */
+static const char *
+partname(const char *dev, int pno, int lth) {
+       static char buffer[80];
+       const char *p;
+       int w, wp;
+       int bufsiz;
+       char *bufp;
+
+       bufp = buffer;
+       bufsiz = sizeof(buffer);
+
+       w = strlen(dev);
+       p = "";
+
+       if (isdigit(dev[w-1]))
+               p = "p";
+
+       /* devfs kludge - note: fdisk partition names are not supposed
+          to equal kernel names, so there is no reason to do this */
+       if (strcmp (dev + w - 4, "disc") == 0) {
+               w -= 4;
+               p = "part";
+       }
+
+       wp = strlen(p);
+
+       if (lth) {
+               snprintf(bufp, bufsiz, "%*.*s%s%-2u",
+                        lth-wp-2, w, dev, p, pno);
+       } else {
+               snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
+       }
+       return bufp;
+}
+
+struct partition {
+       unsigned char boot_ind;         /* 0x80 - active */
+       unsigned char head;             /* starting head */
+       unsigned char sector;           /* starting sector */
+       unsigned char cyl;              /* starting cylinder */
+       unsigned char sys_ind;          /* What partition type */
+       unsigned char end_head;         /* end head */
+       unsigned char end_sector;       /* end sector */
+       unsigned char end_cyl;          /* end cylinder */
+       unsigned char start4[4];        /* starting sector counting from 0 */
+       unsigned char size4[4];         /* nr of sectors in partition */
+};
+
+enum failure {
+       ioctl_error, unable_to_open, unable_to_read, unable_to_seek,
+       unable_to_write
+};
+
+enum action {fdisk, require, try_only, create_empty_dos, create_empty_sun};
+
+struct geom {
+       unsigned int heads;
+       unsigned int sectors;
+       unsigned int cylinders;
+};
+
+static const char *disk_device;
+static char *line_ptr;
+static int fd;                  /* the disk */
+static int partitions = 4;      /* maximum partition + 1 */
+static uint display_in_cyl_units = 1;
+static uint units_per_sector = 1;
+static void change_units(void);
+static void fdisk_fatal(enum failure why) __attribute__ ((noreturn));
+static void get_geometry(struct geom *);
+static int get_boot(enum action what);
+static int  get_partition(int warn, int max);
+static void list_types(const struct systypes *sys);
+static void reread_partition_table(int leave);
+static int valid_part_table_flag(const unsigned char *b);
+static uint read_int(uint low, uint dflt, uint high, uint base, char *mesg);
+
+#define PLURAL   0
+#define SINGULAR 1
+
+#define hex_val(c)      ({ \
+                               char _c = (c); \
+                               isdigit(_c) ? _c - '0' : \
+                               tolower(_c) + 10 - 'a'; \
+                       })
+
+
+#define LINE_LENGTH     800
+#define pt_offset(b, n) ((struct partition *)((b) + 0x1be + \
+                               (n) * sizeof(struct partition)))
+#define sector(s)       ((s) & 0x3f)
+#define cylinder(s, c)  ((c) | (((s) & 0xc0) << 2))
+
+#define hsc2sector(h,s,c) (sector(s) - 1 + sectors * \
+                               ((h) + heads * cylinder(s,c)))
+#define set_hsc(h,s,c,sector) { \
+                               s = sector % sectors + 1;       \
+                               sector /= sectors;      \
+                               h = sector % heads;     \
+                               sector /= heads;        \
+                               c = sector & 0xff;      \
+                               s |= (sector >> 2) & 0xc0;      \
+                       }
+
+
+static unsigned int get_start_sect(const struct partition *p);
+static unsigned int get_nr_sects(const struct partition *p);
+
+/*
+ * per partition table entry data
+ *
+ * The four primary partitions have the same sectorbuffer (MBRbuffer)
+ * and have NULL ext_pointer.
+ * Each logical partition table entry has two pointers, one for the
+ * partition and one link to the next one.
+ */
+static struct pte {
+       struct partition *part_table;   /* points into sectorbuffer */
+       struct partition *ext_pointer;  /* points into sectorbuffer */
+       char changed;           /* boolean */
+       uint offset;            /* disk sector number */
+       char *sectorbuffer;     /* disk sector contents */
+} ptes[MAXIMUM_PARTS];
+
+static char  line_buffer[LINE_LENGTH];
+
+static void
+set_all_unchanged(void) {
+       int i;
+
+       for (i = 0; i < MAXIMUM_PARTS; i++)
+               ptes[i].changed = 0;
+}
+
+static void
+set_changed(int i) {
+       ptes[i].changed = 1;
+}
+
+
+#if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_OSF_LABEL)
+static struct partition *
+get_part_table(int i) {
+       return ptes[i].part_table;
+}
+#endif
+
+static const char *
+str_units(int n) {      /* n==1: use singular */
+       if (n == 1)
+               return display_in_cyl_units ? _("cylinder") : _("sector");
+       else
+               return display_in_cyl_units ? _("cylinders") : _("sectors");
+}
+
+/* read line; return 0 or first char */
+static int
+read_line(void)
+{
+       static int got_eof = 0;
+
+       fflush (stdout);         /* requested by niles@scyld.com */
+       line_ptr = line_buffer;
+       if (!fgets(line_buffer, LINE_LENGTH, stdin)) {
+               if (feof(stdin))
+                       got_eof++;      /* user typed ^D ? */
+               if (got_eof >= 3) {
+                       fflush(stdout);
+                       fprintf(stderr, _("\ngot EOF thrice - exiting..\n"));
+                       exit(1);
+               }
+               return 0;
+       }
+       while (*line_ptr && !isgraph(*line_ptr))
+               line_ptr++;
+       return *line_ptr;
+}
+
+static char
+read_char(const char *mesg)
+{
+       do {
+               fputs(mesg, stdout);
+       } while (!read_line());
+       return *line_ptr;
+}
+
+static char
+read_chars(const char *mesg)
+{
+       fputs(mesg, stdout);
+       if (!read_line()) {
+               *line_ptr = '\n';
+               line_ptr[1] = 0;
+       }
+       return *line_ptr;
+}
+
+static int
+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;
+          }
+       }
+}
+
+#ifdef CONFIG_FEATURE_AIX_LABEL
+/*
+ * Copyright (C) Andreas Neuper, Sep 1998.
+ *      This file may be redistributed under
+ *      the terms of the GNU Public License.
+ */
+
+typedef struct {
+       unsigned int   magic;        /* expect AIX_LABEL_MAGIC */
+       unsigned int   fillbytes1[124];
+       unsigned int   physical_volume_id;
+       unsigned int   fillbytes2[124];
+} aix_partition;
+
+#define AIX_LABEL_MAGIC         0xc9c2d4c1
+#define AIX_LABEL_MAGIC_SWAPPED 0xc1d4c2c9
+#define AIX_INFO_MAGIC          0x00072959
+#define AIX_INFO_MAGIC_SWAPPED  0x59290700
+
+#define aixlabel ((aix_partition *)MBRbuffer)
+
+
+/*
+  Changes:
+  Sat Mar 20 09:51:38 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+       Internationalization
+*/
+
+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).")
+    );
+}
+
+static void
+aix_nolabel( void )
+{
+    aixlabel->magic = 0;
+    aix_label = 0;
+    partitions = 4;
+    memset( MBRbuffer, 0, sizeof(MBRbuffer) );  /* avoid fdisk cores */
+    return;
+}
+
+static int
+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;
+}
+#endif  /* AIX_LABEL */
+
+#ifdef CONFIG_FEATURE_OSF_LABEL
+/*
+ * Copyright (c) 1987, 1988 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by the University of
+ *      California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#ifndef BSD_DISKMAGIC
+#define BSD_DISKMAGIC     ((__u32) 0x82564557)
+#endif
+
+#ifndef BSD_MAXPARTITIONS
+#define BSD_MAXPARTITIONS 16
+#endif
+
+#define BSD_LINUX_BOOTDIR "/usr/ucb/mdec"
+
+#if defined (i386) || defined (__sparc__) || defined (__arm__) || defined (__mips__) || defined (__s390__) || defined (__sh__) || defined(__x86_64__)
+#define BSD_LABELSECTOR   1
+#define BSD_LABELOFFSET   0
+#elif defined (__alpha__) || defined (__powerpc__) || defined (__ia64__) || defined (__hppa__)
+#define BSD_LABELSECTOR   0
+#define BSD_LABELOFFSET   64
+#else
+#error unknown architecture
+#endif
+
+#define BSD_BBSIZE        8192          /* size of boot area, with label */
+#define BSD_SBSIZE        8192          /* max size of fs superblock */
+
+struct xbsd_disklabel {
+       __u32   d_magic;                /* the magic number */
+       __s16   d_type;                 /* drive type */
+       __s16   d_subtype;              /* controller/d_type specific */
+       char    d_typename[16];         /* type name, e.g. "eagle" */
+       char    d_packname[16];                 /* pack identifier */
+                       /* disk geometry: */
+       __u32   d_secsize;              /* # of bytes per sector */
+       __u32   d_nsectors;             /* # of data sectors per track */
+       __u32   d_ntracks;              /* # of tracks per cylinder */
+       __u32   d_ncylinders;           /* # of data cylinders per unit */
+       __u32   d_secpercyl;            /* # of data sectors per cylinder */
+       __u32   d_secperunit;           /* # of data sectors per unit */
+       /*
+        * Spares (bad sector replacements) below
+        * are not counted in d_nsectors or d_secpercyl.
+        * Spare sectors are assumed to be physical sectors
+        * which occupy space at the end of each track and/or cylinder.
+        */
+       __u16   d_sparespertrack;       /* # of spare sectors per track */
+       __u16   d_sparespercyl;         /* # of spare sectors per cylinder */
+       /*
+        * Alternate cylinders include maintenance, replacement,
+        * configuration description areas, etc.
+        */
+       __u32   d_acylinders;           /* # of alt. cylinders per unit */
+
+                       /* hardware characteristics: */
+       /*
+        * d_interleave, d_trackskew and d_cylskew describe perturbations
+        * in the media format used to compensate for a slow controller.
+        * Interleave is physical sector interleave, set up by the formatter
+        * or controller when formatting.  When interleaving is in use,
+        * logically adjacent sectors are not physically contiguous,
+        * but instead are separated by some number of sectors.
+        * It is specified as the ratio of physical sectors traversed
+        * per logical sector.  Thus an interleave of 1:1 implies contiguous
+        * layout, while 2:1 implies that logical sector 0 is separated
+        * by one sector from logical sector 1.
+        * d_trackskew is the offset of sector 0 on track N
+        * relative to sector 0 on track N-1 on the same cylinder.
+        * Finally, d_cylskew is the offset of sector 0 on cylinder N
+        * relative to sector 0 on cylinder N-1.
+        */
+       __u16   d_rpm;                  /* rotational speed */
+       __u16   d_interleave;           /* hardware sector interleave */
+       __u16   d_trackskew;            /* sector 0 skew, per track */
+       __u16   d_cylskew;              /* sector 0 skew, per cylinder */
+       __u32   d_headswitch;           /* head switch time, usec */
+       __u32   d_trkseek;              /* track-to-track seek, usec */
+       __u32   d_flags;                /* generic flags */
+#define NDDATA 5
+       __u32   d_drivedata[NDDATA];    /* drive-type specific information */
+#define NSPARE 5
+       __u32   d_spare[NSPARE];        /* reserved for future use */
+       __u32   d_magic2;               /* the magic number (again) */
+       __u16   d_checksum;             /* xor of data incl. partitions */
+                       /* filesystem and partition information: */
+       __u16   d_npartitions;          /* number of partitions in following */
+       __u32   d_bbsize;               /* size of boot area at sn0, bytes */
+       __u32   d_sbsize;               /* max size of fs superblock, bytes */
+       struct xbsd_partition    {      /* the partition table */
+               __u32   p_size;         /* number of sectors in partition */
+               __u32   p_offset;       /* starting sector */
+               __u32   p_fsize;        /* filesystem basic fragment size */
+               __u8    p_fstype;       /* filesystem type, see below */
+               __u8    p_frag;         /* filesystem fragments per block */
+               __u16   p_cpg;          /* filesystem cylinders per group */
+       } d_partitions[BSD_MAXPARTITIONS]; /* actually may be more */
+};
+
+/* d_type values: */
+#define BSD_DTYPE_SMD           1               /* SMD, XSMD; VAX hp/up */
+#define BSD_DTYPE_MSCP          2               /* MSCP */
+#define BSD_DTYPE_DEC           3               /* other DEC (rk, rl) */
+#define BSD_DTYPE_SCSI          4               /* SCSI */
+#define BSD_DTYPE_ESDI          5               /* ESDI interface */
+#define BSD_DTYPE_ST506         6               /* ST506 etc. */
+#define BSD_DTYPE_HPIB          7               /* CS/80 on HP-IB */
+#define BSD_DTYPE_HPFL          8               /* HP Fiber-link */
+#define BSD_DTYPE_FLOPPY        10              /* floppy */
+
+/* d_subtype values: */
+#define BSD_DSTYPE_INDOSPART    0x8             /* is inside dos partition */
+#define BSD_DSTYPE_DOSPART(s)   ((s) & 3)       /* dos partition number */
+#define BSD_DSTYPE_GEOMETRY     0x10            /* drive params in label */
+
+#ifdef DKTYPENAMES
+static const char * const xbsd_dktypenames[] = {
+       "unknown",
+       "SMD",
+       "MSCP",
+       "old DEC",
+       "SCSI",
+       "ESDI",
+       "ST506",
+       "HP-IB",
+       "HP-FL",
+       "type 9",
+       "floppy",
+       0
+};
+#define BSD_DKMAXTYPES  (sizeof(xbsd_dktypenames) / sizeof(xbsd_dktypenames[0]) - 1)
+#endif
+
+/*
+ * Filesystem type and version.
+ * Used to interpret other filesystem-specific
+ * per-partition information.
+ */
+#define BSD_FS_UNUSED   0               /* unused */
+#define BSD_FS_SWAP     1               /* swap */
+#define BSD_FS_V6       2               /* Sixth Edition */
+#define BSD_FS_V7       3               /* Seventh Edition */
+#define BSD_FS_SYSV     4               /* System V */
+#define BSD_FS_V71K     5               /* V7 with 1K blocks (4.1, 2.9) */
+#define BSD_FS_V8       6               /* Eighth Edition, 4K blocks */
+#define BSD_FS_BSDFFS   7               /* 4.2BSD fast file system */
+#define BSD_FS_BSDLFS   9               /* 4.4BSD log-structured file system */
+#define BSD_FS_OTHER    10              /* in use, but unknown/unsupported */
+#define BSD_FS_HPFS     11              /* OS/2 high-performance file system */
+#define BSD_FS_ISO9660  12              /* ISO-9660 filesystem (cdrom) */
+#define BSD_FS_ISOFS    BSD_FS_ISO9660
+#define BSD_FS_BOOT     13              /* partition contains bootstrap */
+#define BSD_FS_ADOS     14              /* AmigaDOS fast file system */
+#define BSD_FS_HFS      15              /* Macintosh HFS */
+#define BSD_FS_ADVFS    16              /* Digital Unix AdvFS */
+
+/* this is annoying, but it's also the way it is :-( */
+#ifdef __alpha__
+#define BSD_FS_EXT2     8               /* ext2 file system */
+#else
+#define BSD_FS_MSDOS    8               /* MS-DOS file system */
+#endif
+
+#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"},
+#ifdef __alpha__
+/* BSD_FS_EXT2    */   {"\x08" "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 }
+};
+#define BSD_FSMAXTYPES (SIZE(xbsd_fstypes)-1)
+
+#endif
+
+/*
+ * flags shared by various drives:
+ */
+#define BSD_D_REMOVABLE 0x01            /* removable media */
+#define BSD_D_ECC       0x02            /* supports ECC */
+#define BSD_D_BADSECT   0x04            /* supports bad sector forw. */
+#define BSD_D_RAMDISK   0x08            /* disk emulator */
+#define BSD_D_CHAIN     0x10            /* can do back-back transfers */
+#define BSD_D_DOSPART   0x20            /* within MSDOS partition */
+
+#endif /* OSF_LABEL */
+
+/*
+ * Copyright (C) Andreas Neuper, Sep 1998.
+ *      This file may be modified and redistributed under
+ *      the terms of the GNU Public License.
+ */
+
+struct device_parameter { /* 48 bytes */
+       unsigned char  skew;
+       unsigned char  gap1;
+       unsigned char  gap2;
+       unsigned char  sparecyl;
+       unsigned short pcylcount;
+       unsigned short head_vol0;
+       unsigned short ntrks;   /* tracks in cyl 0 or vol 0 */
+       unsigned char  cmd_tag_queue_depth;
+       unsigned char  unused0;
+       unsigned short unused1;
+       unsigned short nsect;   /* sectors/tracks in cyl 0 or vol 0 */
+       unsigned short bytes;
+       unsigned short ilfact;
+       unsigned int   flags;           /* controller flags */
+       unsigned int   datarate;
+       unsigned int   retries_on_error;
+       unsigned int   ms_per_word;
+       unsigned short xylogics_gap1;
+       unsigned short xylogics_syncdelay;
+       unsigned short xylogics_readdelay;
+       unsigned short xylogics_gap2;
+       unsigned short xylogics_readgate;
+       unsigned short xylogics_writecont;
+};
+
+#define SGI_VOLHDR      0x00
+/* 1 and 2 were used for drive types no longer supported by SGI */
+#define SGI_SWAP        0x03
+/* 4 and 5 were for filesystem types SGI haven't ever supported on MIPS CPUs */
+#define SGI_VOLUME      0x06
+#define SGI_EFS         0x07
+#define SGI_LVOL        0x08
+#define SGI_RLVOL       0x09
+#define SGI_XFS         0x0a
+#define SGI_XFSLOG      0x0b
+#define SGI_XLV         0x0c
+#define SGI_XVM         0x0d
+#define ENTIRE_DISK     SGI_VOLUME
+/*
+ * controller flags
+ */
+#define SECTOR_SLIP     0x01
+#define SECTOR_FWD      0x02
+#define TRACK_FWD       0x04
+#define TRACK_MULTIVOL  0x08
+#define IGNORE_ERRORS   0x10
+#define RESEEK          0x20
+#define ENABLE_CMDTAGQ  0x40
+
+typedef struct {
+       unsigned int   magic;            /* expect SGI_LABEL_MAGIC */
+       unsigned short boot_part;        /* active boot partition */
+       unsigned short swap_part;        /* active swap partition */
+       unsigned char  boot_file[16];    /* name of the bootfile */
+       struct device_parameter devparam;       /*  1 * 48 bytes */
+       struct volume_directory {               /* 15 * 16 bytes */
+               unsigned char vol_file_name[8]; /* a character array */
+               unsigned int  vol_file_start;   /* number of logical block */
+               unsigned int  vol_file_size;    /* number of bytes */
+       } directory[15];
+       struct sgi_partition {                  /* 16 * 12 bytes */
+               unsigned int num_sectors;       /* number of blocks */
+               unsigned int start_sector;      /* must be cylinder aligned */
+               unsigned int id;
+       } partitions[16];
+       unsigned int   csum;
+       unsigned int   fillbytes;
+} sgi_partition;
+
+typedef struct {
+       unsigned int   magic;           /* looks like a magic number */
+       unsigned int   a2;
+       unsigned int   a3;
+       unsigned int   a4;
+       unsigned int   b1;
+       unsigned short b2;
+       unsigned short b3;
+       unsigned int   c[16];
+       unsigned short d[3];
+       unsigned char  scsi_string[50];
+       unsigned char  serial[137];
+       unsigned short check1816;
+       unsigned char  installer[225];
+} sgiinfo;
+
+#define SGI_LABEL_MAGIC         0x0be5a941
+#define SGI_LABEL_MAGIC_SWAPPED 0x41a9e50b
+#define SGI_INFO_MAGIC          0x00072959
+#define SGI_INFO_MAGIC_SWAPPED  0x59290700
+#define SGI_SSWAP16(x) (sgi_other_endian ? __swap16(x) \
+                                : (__u16)(x))
+#define SGI_SSWAP32(x) (sgi_other_endian ? __swap32(x) \
+                                : (__u32)(x))
+
+#define sgilabel ((sgi_partition *)MBRbuffer)
+#define sgiparam (sgilabel->devparam)
+
+typedef struct {
+       unsigned char info[128];   /* Informative text string */
+       unsigned char spare0[14];
+       struct sun_info {
+               unsigned char spare1;
+               unsigned char id;
+               unsigned char spare2;
+               unsigned char flags;
+       } infos[8];
+       unsigned char spare1[246]; /* Boot information etc. */
+       unsigned short rspeed;     /* Disk rotational speed */
+       unsigned short pcylcount;  /* Physical cylinder count */
+       unsigned short sparecyl;   /* extra sects per cylinder */
+       unsigned char spare2[4];   /* More magic... */
+       unsigned short ilfact;     /* Interleave factor */
+       unsigned short ncyl;       /* Data cylinder count */
+       unsigned short nacyl;      /* Alt. cylinder count */
+       unsigned short ntrks;      /* Tracks per cylinder */
+       unsigned short nsect;      /* Sectors per track */
+       unsigned char spare3[4];   /* Even more magic... */
+       struct sun_partition {
+               __u32 start_cylinder;
+               __u32 num_sectors;
+       } partitions[8];
+       unsigned short magic;      /* Magic number */
+       unsigned short csum;       /* Label xor'd checksum */
+} sun_partition;
+
+#define SUN_LABEL_MAGIC          0xDABE
+#define SUN_LABEL_MAGIC_SWAPPED  0xBEDA
+#define sunlabel ((sun_partition *)MBRbuffer)
+#define SUN_SSWAP16(x) (sun_other_endian ? __swap16(x) \
+                                : (__u16)(x))
+#define SUN_SSWAP32(x) (sun_other_endian ? __swap32(x) \
+                                : (__u32)(x))
+
+/*
+ * llseek.c -- stub calling the llseek system call
+ *
+ * Copyright (C) 1994 Remy Card.  This file may be redistributed
+ * under the terms of the GNU Public License.
+ */
+
+
+#ifdef __linux__
+
+#ifdef HAVE_LLSEEK
+#include <syscall.h>
+
+#else   /* HAVE_LLSEEK */
+
+#if defined(__alpha__) || defined(__ia64__)
+
+#define my_llseek lseek
+
+#else
+#include <linux/unistd.h>       /* for __NR__llseek */
+
+static int _llseek (unsigned int, unsigned long,
+                  unsigned long, ext2_loff_t *, unsigned int);
+
+#ifdef __NR__llseek
+
+static _syscall5(int,_llseek,unsigned int,f_d,unsigned long,offset_high,
+                unsigned long, offset_low,ext2_loff_t *,result,
+                unsigned int, origin)
+
+#else
+
+/* no __NR__llseek on compilation machine - might give it explicitly */
+static int _llseek (unsigned int f_d, unsigned long oh,
+                   unsigned long ol, ext2_loff_t *result,
+                   unsigned int origin) {
+       errno = ENOSYS;
+       return -1;
+}
+
+#endif
+
+static ext2_loff_t my_llseek (unsigned int f_d, ext2_loff_t offset,
+               unsigned int origin)
+{
+       ext2_loff_t result;
+       int retval;
+
+       retval = _llseek (f_d, ((unsigned long long) offset) >> 32,
+                       ((unsigned long long) offset) & 0xffffffff,
+                       &result, origin);
+       return (retval == -1 ? (ext2_loff_t) retval : result);
+}
+
+#endif /* __alpha__ */
+
+#endif  /* HAVE_LLSEEK */
+
+static ext2_loff_t ext2_llseek (unsigned int f_d, ext2_loff_t offset,
+                        unsigned int origin)
+{
+       ext2_loff_t result;
+       static int do_compat = 0;
+
+       if (!do_compat) {
+               result = my_llseek (f_d, offset, origin);
+               if (!(result == -1 && errno == ENOSYS))
+                       return result;
+
+               /*
+                * Just in case this code runs on top of an old kernel
+                * which does not support the llseek system call
+                */
+               do_compat = 1;
+               /*
+                * Now try ordinary lseek.
+                */
+       }
+
+       if ((sizeof(off_t) >= sizeof(ext2_loff_t)) ||
+           (offset < ((ext2_loff_t) 1 << ((sizeof(off_t)*8) -1))))
+               return lseek(f_d, (off_t) offset, origin);
+
+       errno = EINVAL;
+       return -1;
+}
+
+#else /* !linux */
+
+static ext2_loff_t ext2_llseek (unsigned int f_d, ext2_loff_t offset,
+                        unsigned int origin)
+{
+       if ((sizeof(off_t) < sizeof(ext2_loff_t)) &&
+           (offset >= ((ext2_loff_t) 1 << ((sizeof(off_t)*8) -1)))) {
+               errno = EINVAL;
+               return -1;
+       }
+       return lseek (f_d, (off_t) offset, origin);
+}
+
+#endif  /* linux */
+
+
+#ifdef CONFIG_FEATURE_OSF_LABEL
+/*
+   Changes:
+   19990319 - Arnaldo Carvalho de Melo <acme@conectiva.com.br> - i18n/nls
+
+   20000101 - David Huggins-Daines <dhuggins@linuxcare.com> - Better
+   support for OSF/1 disklabels on Alpha.
+   Also fixed unaligned accesses in alpha_bootblock_checksum()
+*/
+
+#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,
+                           int pindex);
+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);
+#endif
+
+#if !defined (__alpha__)
+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
+
+#if defined (__alpha__)
+/* We access this through a u_int64_t * when checksumming */
+static char disklabelbuffer[BSD_BBSIZE] __attribute__((aligned(8)));
+#else
+static char disklabelbuffer[BSD_BBSIZE];
+#endif
+
+static struct xbsd_disklabel xbsd_dlabel;
+
+#define bsd_cround(n) \
+       (display_in_cyl_units ? ((n)/xbsd_dlabel.d_secpercyl) + 1 : (n))
+
+/*
+ * Test whether the whole disk has BSD disk label magic.
+ *
+ * Note: often reformatting with DOS-type label leaves the BSD magic,
+ * 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)
+               return 0;
+       return 1;
+}
+
+static void xbsd_print_disklabel(int);
+
+static int
+btrydev (char * dev) {
+       if (xbsd_readlabel (NULL, &xbsd_dlabel) == 0)
+               return -1;
+       printf(_("\nBSD label for device: %s\n"), dev);
+       xbsd_print_disklabel (0);
+       return 0;
+}
+
+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"));
+#if !defined (__alpha__)
+  puts (_("\tx\tlink BSD partition to non-BSD partition"));
+#endif
+}
+
+#if !defined (__alpha__)
+static int
+hidden(int type) {
+       return type ^ 0x10;
+}
+
+static int
+is_bsd_partition_type(int type) {
+       return (type == FREEBSD_PARTITION ||
+               type == hidden(FREEBSD_PARTITION) ||
+               type == NETBSD_PARTITION ||
+               type == hidden(NETBSD_PARTITION));
+}
+#endif
+
+static 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;
+  }
+
+#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 !defined (__alpha__)
+      case 'x':
+       xbsd_link_part ();
+       break;
+#endif
+      default:
+       bmenu ();
+       break;
+    }
+  }
+}
+
+static void
+xbsd_delete_part (void)
+{
+  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--;
+}
+
+static void
+xbsd_new_part (void)
+{
+  uint begin, end;
+  char mesg[256];
+  int i;
+
+  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;
+#else
+  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);
+
+  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);
+
+  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;
+}
+
+static void
+xbsd_print_disklabel (int show_all) {
+  struct xbsd_disklabel *lp = &xbsd_dlabel;
+  struct xbsd_partition *pp;
+  FILE *f = stdout;
+  int i, j;
+
+  if (show_all) {
+#if defined (__alpha__)
+    fprintf(f, "# %s:\n", disk_device);
+#else
+    fprintf(f, "# %s:\n", partname(disk_device, xbsd_part_index+1, 0));
+#endif
+    if ((unsigned) lp->d_type < BSD_DKMAXTYPES)
+      fprintf(f, _("type: %s\n"), xbsd_dktypenames[lp->d_type]);
+    else
+      fprintf(f, _("type: %d\n"), lp->d_type);
+    fprintf(f, _("disk: %.*s\n"), (int) sizeof(lp->d_typename), lp->d_typename);
+    fprintf(f, _("label: %.*s\n"), (int) sizeof(lp->d_packname), lp->d_packname);
+    fprintf(f, _("flags:"));
+    if (lp->d_flags & BSD_D_REMOVABLE)
+      fprintf(f, _(" removable"));
+    if (lp->d_flags & BSD_D_ECC)
+      fprintf(f, _(" ecc"));
+    if (lp->d_flags & BSD_D_BADSECT)
+      fprintf(f, _(" badsect"));
+    fprintf(f, "\n");
+    /* On various machines the fields of *lp are short/int/long */
+    /* In order to avoid problems, we cast them all to long. */
+    fprintf(f, _("bytes/sector: %ld\n"), (long) lp->d_secsize);
+    fprintf(f, _("sectors/track: %ld\n"), (long) lp->d_nsectors);
+    fprintf(f, _("tracks/cylinder: %ld\n"), (long) lp->d_ntracks);
+    fprintf(f, _("sectors/cylinder: %ld\n"), (long) lp->d_secpercyl);
+    fprintf(f, _("cylinders: %ld\n"), (long) lp->d_ncylinders);
+    fprintf(f, _("rpm: %d\n"), lp->d_rpm);
+    fprintf(f, _("interleave: %d\n"), lp->d_interleave);
+    fprintf(f, _("trackskew: %d\n"), lp->d_trackskew);
+    fprintf(f, _("cylinderskew: %d\n"), lp->d_cylskew);
+    fprintf(f, _("headswitch: %ld\t\t# milliseconds\n"),
+           (long) lp->d_headswitch);
+    fprintf(f, _("track-to-track seek: %ld\t# milliseconds\n"),
+           (long) lp->d_trkseek);
+    fprintf(f, _("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++)
+      fprintf(f, "%ld ", (long) lp->d_drivedata[j]);
+  }
+  fprintf (f, _("\n%d partitions:\n"), lp->d_npartitions);
+  fprintf (f, _("#       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) {
+       fprintf(f, "  %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 {
+       fprintf(f, "  %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)
+       fprintf(f, "%8.8s", xbsd_fstypes[pp->p_fstype].name);
+      else
+       fprintf(f, "%8x", pp->p_fstype);
+      switch (pp->p_fstype) {
+       case BSD_FS_UNUSED:
+         fprintf(f, "    %5ld %5ld %5.5s ",
+                 (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, "");
+         break;
+
+       case BSD_FS_BSDFFS:
+         fprintf(f, "    %5ld %5ld %5d ",
+                 (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag,
+                 pp->p_cpg);
+         break;
+
+       default:
+         fprintf(f, "%22.22s", "");
+         break;
+      }
+      fprintf(f, "\n");
+    }
+  }
+}
+
+static void
+xbsd_write_disklabel (void) {
+#if defined (__alpha__)
+       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);
+#endif
+       reread_partition_table(0);      /* no exit yet */
+}
+
+static int
+xbsd_create_disklabel (void) {
+       char c;
+
+#if defined (__alpha__)
+       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));
+#endif
+
+       while (1) {
+               c = read_char (_("Do you want to create a disklabel? (y/n) "));
+               if (c == 'y' || c == 'Y') {
+                       if (xbsd_initlabel (
+#if defined (__alpha__) || defined (__powerpc__) || defined (__hppa__)
+                               NULL, &xbsd_dlabel, 0
+#else
+                               xbsd_part, &xbsd_dlabel, xbsd_part_index
+#endif
+                               ) == 1) {
+                               xbsd_print_disklabel (1);
+                               return 1;
+                       } else
+                               return 0;
+               } else if (c == 'n')
+                       return 0;
+       }
+}
+
+static int
+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);
+}
+
+static void
+xbsd_edit_disklabel (void)
+{
+  struct xbsd_disklabel *d;
+
+  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"));
+#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;
+
+    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;
+}
+
+static int
+xbsd_get_bootstrap (char *path, void *ptr, int size)
+{
+  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;
+}
+
+static void
+sync_disks (void)
+{
+  printf (_("\nSyncing disks.\n"));
+  sync ();
+  sleep (4);
+}
+
+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 */
+  bzero (d, 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;
+
+  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));
+
+#if defined (__powerpc__) || defined (__hppa__)
+  sector = 0;
+#elif defined (__alpha__)
+  sector = 0;
+  alpha_bootblock_checksum (disklabelbuffer);
+#else
+  sector = get_start_sect(xbsd_part);
+#endif
+
+  if (ext2_llseek (fd, (ext2_loff_t) 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);
+#else
+  printf (_("Bootstrap installed on %s.\n"),
+    partname (disk_device, xbsd_part_index+1, 0));
+#endif
+
+  sync_disks ();
+}
+
+static void
+xbsd_change_fstype (void)
+{
+  int i;
+
+  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)
+{
+  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';
+}
+
+static int
+xbsd_check_new_partition (int *i) {
+
+       /* room for more? various BSD flavours have different maxima */
+       if (xbsd_dlabel.d_npartitions == BSD_MAXPARTITIONS) {
+               int t;
+
+               for (t = 0; t < BSD_MAXPARTITIONS; t++)
+                       if (xbsd_dlabel.d_partitions[t].p_size == 0)
+                               break;
+
+               if (t == BSD_MAXPARTITIONS) {
+                       fprintf (stderr, _("The maximum number of partitions "
+                                          "has been created\n"));
+                       return 0;
+               }
+       }
+
+       *i = xbsd_get_part_index (BSD_MAXPARTITIONS);
+
+       if (*i >= xbsd_dlabel.d_npartitions)
+               xbsd_dlabel.d_npartitions = (*i) + 1;
+
+       if (xbsd_dlabel.d_partitions[*i].p_size != 0) {
+               fprintf (stderr, _("This partition already exists.\n"));
+               return 0;
+       }
+
+       return 1;
+}
+
+static void
+xbsd_list_types (void) {
+       list_types (xbsd_fstypes);
+}
+
+static u_short
+xbsd_dkcksum (struct xbsd_disklabel *lp) {
+       u_short *start, *end;
+       u_short sum = 0;
+
+       start = (u_short *) lp;
+       end = (u_short *) &lp->d_partitions[lp->d_npartitions];
+       while (start < end)
+               sum ^= *start++;
+       return sum;
+}
+
+static int
+xbsd_initlabel (struct partition *p, struct xbsd_disklabel *d, int pindex) {
+       struct xbsd_partition *pp;
+       struct geom g;
+
+       get_geometry (&g);
+       bzero (d, sizeof (struct xbsd_disklabel));
+
+       d -> d_magic = BSD_DISKMAGIC;
+
+       if (strncmp (disk_device, "/dev/sd", 7) == 0)
+               d -> d_type = BSD_DTYPE_SCSI;
+       else
+               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;
+#endif
+
+#if !defined (__alpha__)
+       d -> d_flags = BSD_D_DOSPART;
+#else
+       d -> d_flags = 0;
+#endif
+       d -> d_secsize = SECTOR_SIZE;           /* bytes/sector  */
+       d -> d_nsectors = g.sectors;            /* sectors/track */
+       d -> d_ntracks = g.heads;               /* tracks/cylinder (heads) */
+       d -> d_ncylinders = g.cylinders;
+       d -> d_secpercyl  = g.sectors * g.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
+                                                  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
+                                                  the whole disk */
+       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
+                                                  the whole disk */
+       pp -> p_offset = 0;
+       pp -> p_size   = d -> d_secperunit;
+       pp -> p_fstype = BSD_FS_UNUSED;
+#endif
+
+       return 1;
+}
+
+/*
+ * Read a xbsd_disklabel from sector 0 or from the starting sector of p.
+ * If it has the right magic, return 1.
+ */
+static int
+xbsd_readlabel (struct partition *p, struct xbsd_disklabel *d)
+{
+       int t, sector;
+
+       /* p is used only to get the starting sector */
+#if !defined (__alpha__)
+       sector = (p ? get_start_sect(p) : 0);
+#elif defined (__alpha__)
+       sector = 0;
+#endif
+
+       if (ext2_llseek (fd, (ext2_loff_t) 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));
+
+       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;
+       }
+
+       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)
+{
+  int sector;
+
+#if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__)
+  sector = get_start_sect(p) + BSD_LABELSECTOR;
+#else
+  sector = BSD_LABELSECTOR;
+#endif
+
+  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));
+
+#if defined (__alpha__) && BSD_LABELSECTOR == 0
+  alpha_bootblock_checksum (disklabelbuffer);
+  if (ext2_llseek (fd, (ext2_loff_t) 0, SEEK_SET) == -1)
+    fdisk_fatal (unable_to_seek);
+  if (BSD_BBSIZE != write (fd, disklabelbuffer, BSD_BBSIZE))
+    fdisk_fatal (unable_to_write);
+#else
+  if (ext2_llseek (fd, (ext2_loff_t) 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;
+}
+
+
+#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;
+  }
+}
+
+static void
+xbsd_link_part (void)
+{
+  int k, i;
+  struct partition *p;
+
+  k = get_partition (1, partitions);
+
+  if (!xbsd_check_new_partition (&i))
+    return;
+
+  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);
+}
+#endif
+
+#if defined (__alpha__)
+
+#if !defined(__GLIBC__)
+typedef unsigned long long u_int64_t;
+#endif
+
+static void
+alpha_bootblock_checksum (char *boot)
+{
+  u_int64_t *dp, sum;
+  int i;
+
+  dp = (u_int64_t *)boot;
+  sum = 0;
+  for (i = 0; i < 63; i++)
+    sum += dp[i];
+  dp[63] = sum;
+}
+#endif /* __alpha__ */
+
+#endif /* OSF_LABEL */
+
+#if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL)
+static inline unsigned short
+__swap16(unsigned short x) {
+       return (((__u16)(x) & 0xFF) << 8) | (((__u16)(x) & 0xFF00) >> 8);
+}
+
+static inline __u32
+__swap32(__u32 x) {
+       return (((__u32)(x) & 0xFF) << 24) | (((__u32)(x) & 0xFF00) << 8) | (((__u32)(x) & 0xFF0000) >> 8) | (((__u32)(x) & 0xFF000000) >> 24);
+}
+#endif
+
+#ifdef CONFIG_FEATURE_SGI_LABEL
+/*
+ *
+ * fdisksgilabel.c
+ *
+ * Copyright (C) Andreas Neuper, Sep 1998.
+ *      This file may be modified and redistributed under
+ *      the terms of the GNU Public License.
+ *
+ * Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ *      Internationalization
+ */
+
+
+static  int     sgi_other_endian;
+static  int     debug;
+static  short   sgi_volumes=1;
+
+/*
+ * only dealing with free blocks here
+ */
+
+typedef struct { int first; int last; } freeblocks;
+static freeblocks freelist[17]; /* 16 partitions can produce 17 vacant slots */
+
+static void
+setfreelist( int i, int f, int l ) {
+       freelist[i].first = f;
+       freelist[i].last = l;
+}
+
+static void
+add2freelist( int f, int l ) {
+       int i = 0;
+       for( ; i<17 ; i++ ) {
+               if(freelist[i].last==0) break;
+       }
+       setfreelist( i, f, l );
+}
+
+static void
+clearfreelist(void) {
+       int i = 0;
+       for( ; i<17 ; i++ ) {
+               setfreelist( i, 0, 0 );
+       }
+}
+
+static int
+isinfreelist( int b ) {
+       int i = 0;
+       for( ; i<17 ; i++ ) {
+               if (freelist[i].first <= b && freelist[i].last >= b) {
+                       return freelist[i].last;
+               }
+       }
+       return 0;
+}
+       /* return last vacant block of this stride (never 0). */
+       /* the '>=' is not quite correct, but simplifies the code */
+/*
+ * end of free blocks section
+ */
+
+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             }
+};
+
+
+static int
+sgi_get_nsect(void) {
+    return SGI_SSWAP16(sgilabel->devparam.nsect);
+}
+
+static int
+sgi_get_ntrks(void) {
+    return SGI_SSWAP16(sgilabel->devparam.ntrks);
+}
+
+static int
+sgi_get_pcylcount(void) {
+    return SGI_SSWAP16(sgilabel->devparam.pcylcount);
+}
+
+static void
+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;
+
+    size = size / sizeof( unsigned int );
+    for( i=0; i<size; i++ )
+       sum = 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) ) )
+    {
+       fprintf( stderr, _("Detected sgi disklabel with wrong checksum.\n"));
+    } else
+    {
+       heads = sgi_get_ntrks();
+       cylinders = sgi_get_pcylcount();
+       sectors = sgi_get_nsect();
+    }
+    update_units();
+    sgi_label = 1;
+    partitions= 16;
+    sgi_volumes = 15;
+    return 1;
+}
+
+static int
+sgi_get_start_sector( int i ) {
+    return SGI_SSWAP32(sgilabel->partitions[i].start_sector);
+}
+
+static int
+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);
+}
+
+static int
+sgi_get_bootpartition(void)
+{
+    return SGI_SSWAP16(sgilabel->boot_part);
+}
+
+static int
+sgi_get_swappartition(void)
+{
+    return SGI_SSWAP16(sgilabel->swap_part);
+}
+
+static void
+sgi_list_table( int xtra ) {
+    int i, w;
+    int kpi = 0;                /* kernel partition ID */
+    const char *type;
+
+    w = strlen( disk_device );
+
+    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 );
+    }
+    printf(_("----- partitions -----\n"
+          "Pt# %*s  Info     Start       End   Sectors  Id  System\n"),
+          w + 1, _("Device"));
+    for (i = 0 ; i < partitions; i++) {
+           if( sgi_get_num_sectors(i) || debug ) {
+           __u32 start = sgi_get_start_sector(i);
+           __u32 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+2),
+/* 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 */           (type = partition_type(sgi_get_sysid(i)))
+                   ? type : _("Unknown"));
+       }
+    }
+    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)
+       {
+           __u32 start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start);
+           __u32 len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size);
+           char*name = sgilabel->directory[i].vol_file_name;
+           printf(_("%2d: %-10s sector%5u size%8u\n"),
+                   i, name, (unsigned int) start, (unsigned int) len);
+       }
+    }
+}
+
+static void
+sgi_set_bootpartition( int i )
+{
+    sgilabel->boot_part = SGI_SSWAP16(((short)i));
+}
+
+static int
+sgi_get_lastblock(void) {
+    return heads * sectors * cylinders;
+}
+
+static void
+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;
+    } else
+    if( strlen( aFile ) > 16 )
+    {
+       printf( _("\n\tName of Bootfile too long:  16 bytes maximum.\n") );
+       return 0;
+    } else
+    if( aFile[0] != '/' )
+    {
+       printf( _("\n\tBootfile must have a fully qualified pathname.\n") );
+       return 0;
+    }
+    if( strncmp( aFile, 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 */
+}
+
+static const char *
+sgi_get_bootfile(void) {
+       return sgilabel->boot_file;
+}
+
+static void
+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++;
+       }
+       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( 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(
+           (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( sgilabel->directory[0].vol_file_name, "sgilabel",8 ) )
+    {
+       /*
+        * keep this habbit of first writing the "sgilabel".
+        * I never tested whether it works without (AN 981002).
+        */
+       sgiinfo*info = fill_sgiinfo();  /* fills the block appropriately */
+       int infostartblock = SGI_SSWAP32( sgilabel->directory[0].vol_file_start );
+       if( ext2_llseek(fd, (ext2_loff_t)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
+     */
+    int i = *x;
+    int j = *y;
+    int a = sgi_get_start_sector(i);
+    int b = sgi_get_start_sector(j);
+    int c = sgi_get_num_sectors(i);
+    int d = sgi_get_num_sectors(j);
+    if( a == b )
+    {
+       return( d - c );
+    }
+    return( a - b );
+}
+
+
+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;      /* local counters */
+    int start = 0;
+    int gap = 0;        /* count unused blocks */
+    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;
+    }
+    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,\nnot "
+                   "at diskblock %d.\n"), 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 );
+       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] ) )
+       {
+           if( verbose )
+               printf( _("Unused gap of %8d sectors - sectors %8d-%d\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( _("Unused gap of %8d sectors - sectors %8d-%d\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") );
+       }
+       if( sgi_check_bootfile( "/unix" ) )
+       {
+           printf( _("\tYou have chosen an unusual boot file name.\n") );
+       }
+    }
+    return gap;
+}
+
+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);
+}
+
+static void
+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);
+}
+
+/* returns partition index of first entry marked as entire disk */
+static int
+sgi_entire(void) {
+    int i=0;
+    for( i=0; i<16; i++ )
+       if( sgi_get_sysid(i) == SGI_VOLUME )
+           return i;
+    return -1;
+}
+
+static void
+sgi_set_partition( int i, uint start, uint 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;
+    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;
+       }
+    }
+}
+
+static void
+sgi_delete_partition( int i )
+{
+    sgi_set_partition( i, 0, 0, 0 );
+}
+
+static void
+sgi_add_partition( int n, int sys )
+{
+    char mesg[256];
+    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);
+       }
+       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)
+       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 );
+}
+
+static void
+create_sgilabel(void)
+{
+    struct hd_geometry geometry;
+    struct { int start;
+            int nsect;
+            int sysid; } old[4];
+    int i=0;
+    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);
+
+#ifdef HDIO_REQ
+    if (!ioctl(fd, HDIO_REQ, &geometry))
+#else
+    if (!ioctl(fd, HDIO_GETGEO, &geometry))
+#endif
+    {
+       heads = geometry.heads;
+       sectors = geometry.sectors;
+       cylinders = geometry.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(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);
+                                               /* sectors/track */
+    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 );
+       }
+    }
+}
+
+static void
+sgi_set_xcyl(void)
+{
+    /* do nothing in the beginning */
+}
+
+/* _____________________________________________________________
+ */
+
+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( info->scsi_string, "IBM OEM 0662S12         3 30" );
+    strcpy( info->serial, "0000" );
+    info->check1816 = SGI_SSWAP16(18*256 +16 );
+    strcpy( info->installer, "Sfx version 5.3, Oct 18, 1994" );
+    return info;
+}
+#endif /* SGI_LABEL */
+
+
+#ifdef CONFIG_FEATURE_SUN_LABEL
+/*
+ * fdisksunlabel.c
+ *
+ * I think this is mostly, or entirely, due to
+ *      Jakub Jelinek (jj@sunsite.mff.cuni.cz), July 1996
+ *
+ * Merged with fdisk for other architectures, aeb, June 1998.
+ *
+ * Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ *      Internationalization
+ */
+
+
+static int     sun_other_endian;
+static int     scsi_disk;
+static int     floppy;
+
+#ifndef IDE0_MAJOR
+#define IDE0_MAJOR 3
+#endif
+#ifndef IDE1_MAJOR
+#define IDE1_MAJOR 22
+#endif
+static void guess_device_type(void) {
+       struct stat bootstat;
+
+       if (fstat (fd, &bootstat) < 0) {
+               scsi_disk = 0;
+               floppy = 0;
+       } else if (S_ISBLK(bootstat.st_mode)
+                  && ((bootstat.st_rdev >> 8) == IDE0_MAJOR ||
+                      (bootstat.st_rdev >> 8) == IDE1_MAJOR)) {
+               scsi_disk = 0;
+               floppy = 0;
+       } else if (S_ISBLK(bootstat.st_mode)
+                  && (bootstat.st_rdev >> 8) == FLOPPY_MAJOR) {
+               scsi_disk = 0;
+               floppy = 1;
+       } else {
+               scsi_disk = 1;
+               floppy = 0;
+       }
+}
+
+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"    },
+/* New (2.2.x) raid partition with autodetect using persistent superblock */
+/* 0xfd         */  {"\xfd" "Linux raid autodetect" },
+                   { NULL }
+};
+
+
+static void
+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));
+       sunlabel->partitions[i].num_sectors =
+               SUN_SSWAP32(stop - start);
+       set_changed(i);
+}
+
+static void
+sun_nolabel(void) {
+       sun_label = 0;
+       sunlabel->magic = 0;
+       partitions = 4;
+}
+
+static int
+check_sun_label(void) {
+       unsigned short *ush;
+       int csum;
+
+       if (sunlabel->magic != SUN_LABEL_MAGIC &&
+           sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED) {
+               sun_label = 0;
+               sun_other_endian = 0;
+               return 0;
+       }
+       sun_other_endian = (sunlabel->magic == SUN_LABEL_MAGIC_SWAPPED);
+       ush = ((unsigned short *) (sunlabel + 1)) - 1;
+       for (csum = 0; ush >= (unsigned short *)sunlabel;) csum ^= *ush--;
+       if (csum) {
+               fprintf(stderr,_("Detected sun disklabel with wrong checksum.\n"
+                               "Probably you'll have to set all the values,\n"
+                               "e.g. heads, sectors, cylinders and partitions\n"
+                               "or force a fresh label (s command in main menu)\n"));
+       } else {
+               heads = SUN_SSWAP16(sunlabel->ntrks);
+               cylinders = SUN_SSWAP16(sunlabel->ncyl);
+               sectors = SUN_SSWAP16(sunlabel->nsect);
+       }
+       update_units();
+       sun_label = 1;
+       partitions = 8;
+       return 1;
+}
+
+static const struct sun_predefined_drives {
+       const char *vendor;
+       const char *model;
+       unsigned short sparecyl;
+       unsigned short ncyl;
+       unsigned short nacyl;
+       unsigned short pcylcount;
+       unsigned short ntrks;
+       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},
+};
+
+static const struct sun_predefined_drives *
+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",
+#if 0
+           ((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;
+                                       break;
+                                   }
+                               }
+                           }
+                       }
+                   }
+                   break;
+               }
+           }
+           fclose(pfd);
+       }
+    }
+#endif
+    return p;
+}
+
+static void create_sunlabel(void)
+{
+       struct hd_geometry geometry;
+       unsigned int ndiv;
+       int i;
+       unsigned char c;
+       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"));
+#if BYTE_ORDER == LITTLE_ENDIAN
+       sun_other_endian = 1;
+#else
+       sun_other_endian = 0;
+#endif
+       memset(MBRbuffer, 0, sizeof(MBRbuffer));
+       sunlabel->magic = SUN_SSWAP16(SUN_LABEL_MAGIC);
+       if (!floppy) {
+           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;
+               }
+           }
+       }
+       if (!p || floppy) {
+#ifdef HDIO_REQ
+           if (!ioctl(fd, HDIO_REQ, &geometry)) {
+#else
+           if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
+#endif
+               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"));
+               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")));
+           }
+       } 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"));
+       }
+
+       snprintf(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")),
+               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);
+       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 */
+       }
+       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))
+                       csum ^= *ush++;
+               sunlabel->csum = csum;
+       }
+
+       set_all_unchanged();
+       set_changed(0);
+       get_boot(create_empty_sun);
+}
+
+static void
+toggle_sunflags(int i, unsigned char mask) {
+       if (sunlabel->infos[i].flags & mask)
+               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) {
+       int i, continuous = 1;
+       *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) {
+                       starts[i] = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * heads * sectors;
+                       lens[i] = SUN_SSWAP32(sunlabel->partitions[i].num_sectors);
+                       if (continuous) {
+                               if (starts[i] == *start)
+                                       *start += lens[i];
+                               else if (starts[i] + lens[i] >= *stop)
+                                       *stop = starts[i];
+                               else
+                                       continuous = 0;
+                                       /* There will be probably more gaps
+                                         than one, so lets check afterwards */
+                       }
+               } else {
+                       starts[i] = 0;
+                       lens[i] = 0;
+               }
+       }
+}
+
+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;
+}
+
+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);
+                           }
+                       }
+                   }
+           }
+       }
+    }
+    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) {
+       uint start, stop, stop2;
+       uint starts[8], lens[8];
+       int whole_disk = 0;
+
+       char mesg[256];
+       int i, first, last;
+
+       if (sunlabel->partitions[n].num_sectors && sunlabel->infos[n].id) {
+               printf(_("Partition %d is already defined.  Delete "
+                       "it before re-adding it.\n"), n + 1);
+               return;
+       }
+
+       fetch_sun(starts,lens,&start,&stop);
+       if (stop <= start) {
+               if (n == 2)
+                       whole_disk = 1;
+               else {
+                       printf(_("Other partitions already cover the whole disk.\nDelete "
+                              "some/shrink them before retry.\n"));
+                       return;
+               }
+       }
+       snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
+       for (;;) {
+               if (whole_disk)
+                       first = read_int(0, 0, 0, 0, mesg);
+               else
+                       first = read_int(scround(start), scround(stop)+1,
+                                        scround(stop), 0, mesg);
+               if (display_in_cyl_units)
+                       first *= units_per_sector;
+               else
+                       /* Starting sector has to be properly aligned */
+                       first = (first + heads * sectors - 1) / (heads * sectors);
+               if (n == 2 && first != 0)
+                       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"
+                  However, edmundo@rano.demon.co.uk writes:
+                  "In addition to having a Sun partition table, to be able to
+                  boot from the disc, the first partition, /dev/sdX1, must
+                  start at cylinder 0. This means that /dev/sdX1 contains
+                  the partition table and the boot block, as these are the
+                  first two sectors of the disc. Therefore you must be
+                  careful what you use /dev/sdX1 for. In particular, you must
+                  not use a partition starting at cylinder 0 for Linux swap,
+                  as that would overwrite the partition table and the boot
+                  block. You may, however, use such a partition for a UFS
+                  or EXT2 file system, as these file systems leave the first
+                  1024 bytes undisturbed. */
+               /* On the other hand, one should not use partitions
+                  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)
+                               break;
+               if (i < partitions && !whole_disk) {
+                       if (n == 2 && !first) {
+                           whole_disk = 1;
+                           break;
+                       }
+                       printf(_("Sector %d is already allocated\n"), first);
+               } else
+                       break;
+       }
+       stop = cylinders * heads * sectors;
+       stop2 = stop;
+       for (i = 0; i < partitions; i++) {
+               if (starts[i] > first && starts[i] < stop)
+                       stop = starts[i];
+       }
+       snprintf(mesg, sizeof(mesg),
+                _("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);
+       else if (n == 2 && !first)
+               last = read_int(scround(first), scround(stop2), scround(stop2),
+                               scround(first), mesg);
+       else
+               last = read_int(scround(first), scround(stop), scround(stop),
+                               scround(first), mesg);
+       if (display_in_cyl_units)
+               last *= units_per_sector;
+       if (n == 2 && !first) {
+               if (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;
+               }
+       } else if (!whole_disk && last > stop)
+               last = stop;
+
+       if (whole_disk) sys = WHOLE_DISK;
+       set_sun_partition(n, first, last, sys);
+}
+
+static void
+sun_delete_partition(int i) {
+       if (i == 2 && sunlabel->infos[i].id == WHOLE_DISK &&
+           !sunlabel->partitions[i].start_cylinder &&
+           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"),
+                      (uint) SUN_SSWAP32(sunlabel->partitions[i].num_sectors));
+       sunlabel->infos[i].id = 0;
+       sunlabel->partitions[i].num_sectors = 0;
+}
+
+static void
+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;
+       }
+       switch (sys) {
+       case SUNOS_SWAP:
+       case LINUX_SWAP:
+               /* swaps are not mountable by default */
+               sunlabel->infos[i].flags |= 0x01;
+               break;
+       default:
+               /* assume other types are mountable;
+                  user can change it anyway */
+               sunlabel->infos[i].flags &= ~0x01;
+               break;
+       }
+       sunlabel->infos[i].id = sys;
+}
+
+static void
+sun_list_table(int xtra) {
+       int i, w;
+       const char *type;
+
+       w = strlen(disk_device);
+       if (xtra)
+               printf(
+               _("\nDisk %s (Sun disk label): %d heads, %d sectors, %d rpm\n"
+               "%d cylinders, %d alternate 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, 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);
+
+       printf(_("%*s Flag    Start       End    Blocks   Id  System\n"),
+              w + 1, _("Device"));
+       for (i = 0 ; i < partitions; i++) {
+               if (sunlabel->partitions[i].num_sectors) {
+                       __u32 start = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * heads * sectors;
+                       __u32 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 */           (type = partition_type(sunlabel->infos[i].id))
+                               ? type : _("Unknown"));
+               }
+       }
+}
+
+static void
+sun_set_alt_cyl(void) {
+       sunlabel->nacyl =
+               SUN_SSWAP16(read_int(0,SUN_SSWAP16(sunlabel->nacyl), 65535, 0,
+                                _("Number of alternate cylinders")));
+}
+
+static void
+sun_set_ncyl(int cyl) {
+       sunlabel->ncyl = SUN_SSWAP16(cyl);
+}
+
+static void
+sun_set_xcyl(void) {
+       sunlabel->sparecyl =
+               SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->sparecyl), sectors, 0,
+                                _("Extra sectors per cylinder")));
+}
+
+static void
+sun_set_ilfact(void) {
+       sunlabel->ilfact =
+               SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->ilfact), 32, 0,
+                                _("Interleave factor")));
+}
+
+static void
+sun_set_rspeed(void) {
+       sunlabel->rspeed =
+               SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->rspeed), 100000, 0,
+                                _("Rotation speed (rpm)")));
+}
+
+static void
+sun_set_pcylcount(void) {
+       sunlabel->pcylcount =
+               SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->pcylcount), 65535, 0,
+                                _("Number of physical cylinders")));
+}
+
+static void
+sun_write_table(void) {
+       unsigned short *ush = (unsigned short *)sunlabel;
+       unsigned short csum = 0;
+
+       while(ush < (unsigned short *)(&sunlabel->csum))
+               csum ^= *ush++;
+       sunlabel->csum = csum;
+       if (lseek(fd, 0, SEEK_SET) < 0)
+               fdisk_fatal(unable_to_seek);
+       if (write(fd, sunlabel, SECTOR_SIZE) != SECTOR_SIZE)
+               fdisk_fatal(unable_to_write);
+}
+#endif /* SUN_LABEL */
+
+/* DOS partition types */
+
+static const struct systypes i386_sys_types[] = {
+       {"\x00" "Empty"},
+       {"\x01" "FAT12"},
+       {"\x02" "XENIX root"},
+       {"\x03" "XENIX usr"},
+       {"\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 */
+       {"\x08" "AIX"},              /* AIX boot (AIX -- PS/2 port) or SplitDrive */
+       {"\x09" "AIX bootable"},     /* AIX data or Coherent */
+       {"\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)"},
+       {"\x10" "OPUS"},
+       {"\x11" "Hidden FAT12"},
+       {"\x12" "Compaq diagnostics"},
+       {"\x14" "Hidden FAT16 <32M"},
+       {"\x16" "Hidden FAT16"},
+       {"\x17" "Hidden HPFS/NTFS"},
+       {"\x18" "AST SmartSleep"},
+       {"\x1b" "Hidden Win95 FAT32"},
+       {"\x1c" "Hidden Win95 FAT32 (LBA)"},
+       {"\x1e" "Hidden Win95 FAT16 (LBA)"},
+       {"\x24" "NEC DOS"},
+       {"\x39" "Plan 9"},
+       {"\x3c" "PartitionMagic recovery"},
+       {"\x40" "Venix 80286"},
+       {"\x41" "PPC PReP Boot"},
+       {"\x42" "SFS"},
+       {"\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"},
+       {"\x63" "GNU HURD or SysV"}, /* GNU HURD or Mach or Sys V/386 (such as ISC UNIX) */
+       {"\x64" "Novell Netware 286"},
+       {"\x65" "Novell Netware 386"},
+       {"\x70" "DiskSecure Multi-Boot"},
+       {"\x75" "PC/IX"},
+       {"\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"},
+       {"\x93" "Amoeba"},
+       {"\x94" "Amoeba BBT"},       /* (bad block table) */
+       {"\x9f" "BSD/OS"},           /* BSDI */
+       {"\xa0" "IBM Thinkpad hibernation"},
+       {"\xa5" "FreeBSD"},          /* various BSD flavours */
+       {"\xa6" "OpenBSD"},
+       {"\xa7" "NeXTSTEP"},
+       {"\xa8" "Darwin UFS"},
+       {"\xa9" "NetBSD"},
+       {"\xab" "Darwin boot"},
+       {"\xb7" "BSDI fs"},
+       {"\xb8" "BSDI swap"},
+       {"\xbb" "Boot Wizard hidden"},
+       {"\xbe" "Solaris boot"},
+       {"\xc1" "DRDOS/sec (FAT-12)"},
+       {"\xc4" "DRDOS/sec (FAT-16 < 32M)"},
+       {"\xc6" "DRDOS/sec (FAT-16)"},
+       {"\xc7" "Syrinx"},
+       {"\xda" "Non-FS data"},
+       {"\xdb" "CP/M / CTOS / ..."},/* CP/M or Concurrent CP/M or
+                                       Concurrent DOS or CTOS */
+       {"\xde" "Dell Utility"},     /* Dell PowerEdge Server utilities */
+       {"\xdf" "BootIt"},           /* BootIt EMBRM */
+       {"\xe1" "DOS access"},       /* DOS access or SpeedStor 12-bit FAT
+                                       extended partition */
+       {"\xe3" "DOS R/O"},          /* DOS R/O or SpeedStor */
+       {"\xe4" "SpeedStor"},        /* SpeedStor 16-bit FAT extended
+                                       partition < 1024 cyl. */
+       {"\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 */
+       {"\xf1" "SpeedStor"},
+       {"\xf4" "SpeedStor"},        /* SpeedStor large partition */
+       {"\xf2" "DOS secondary"},    /* DOS 3.3+ secondary */
+       {"\xfd" "Linux raid autodetect"},/* New (2.2.x) raid partition with
+                                           autodetect using persistent
+                                           superblock */
+       {"\xfe" "LANstep"},          /* SpeedStor >1024 cyl. or LANstep */
+       {"\xff" "BBT"},              /* Xenix Bad Block Table */
+       { 0 }
+};
+
+
+static void delete_partition(int i);
+
+/* A valid partition table sector ends in 0x55 0xaa */
+static unsigned int
+part_table_flag(const char *b) {
+       return ((uint) b[510]) + (((uint) b[511]) << 8);
+}
+
+static int
+valid_part_table_flag(const unsigned char *b) {
+       return (b[510] == 0x55 && b[511] == 0xaa);
+}
+
+static void
+write_part_table_flag(char *b) {
+       b[510] = 0x55;
+       b[511] = 0xaa;
+}
+
+/* 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) {
+       cp[0] = (val & 0xff);
+       cp[1] = ((val >> 8) & 0xff);
+       cp[2] = ((val >> 16) & 0xff);
+       cp[3] = ((val >> 24) & 0xff);
+}
+
+static unsigned int
+read4_little_endian(const unsigned char *cp) {
+       return (uint)(cp[0]) + ((uint)(cp[1]) << 8)
+               + ((uint)(cp[2]) << 16) + ((uint)(cp[3]) << 24);
+}
+
+static void
+set_start_sect(struct partition *p, unsigned int start_sect) {
+       store4_little_endian(p->start4, start_sect);
+}
+
+static unsigned int
+get_start_sect(const struct partition *p) {
+       return read4_little_endian(p->start4);
+}
+
+static void
+set_nr_sects(struct partition *p, unsigned int nr_sects) {
+       store4_little_endian(p->size4, nr_sects);
+}
+
+static unsigned int
+get_nr_sects(const struct partition *p) {
+       return read4_little_endian(p->size4);
+}
+
+/* normally O_RDWR, -l option gives O_RDONLY */
+static int type_open = O_RDWR;
+
+
+static int ext_index,               /* the prime extended partition */
+       listing,                    /* no aborts for fdisk -l */
+       nowarn,                     /* no warnings for fdisk -l/-s */
+       dos_compatible_flag = ~0,
+       dos_changed;
+
+
+static uint    user_cylinders, user_heads, user_sectors;
+static uint    pt_heads, pt_sectors;
+static uint    kern_heads, kern_sectors;
+
+static uint extended_offset;            /* offset of link pointers */
+static uint    sector_size = DEFAULT_SECTOR_SIZE,
+       user_set_sector_size,
+       sector_offset = 1;
+
+static unsigned long total_number_of_sectors;
+
+
+static jmp_buf listingbuf;
+
+static void fdisk_fatal(enum failure why) {
+       const char *message;
+
+       if (listing) {
+               close(fd);
+               longjmp(listingbuf, 1);
+       }
+
+       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";
+       }
+
+       fputc('\n', stderr);
+       fprintf(stderr, message, disk_device);
+       exit(1);
+}
+
+static void
+seek_sector(uint secno) {
+       ext2_loff_t offset = (ext2_loff_t) secno * sector_size;
+       if (ext2_llseek(fd, offset, SEEK_SET) == (ext2_loff_t) -1)
+               fdisk_fatal(unable_to_seek);
+}
+
+static void
+read_sector(uint secno, char *buf) {
+       seek_sector(secno);
+       if (read(fd, buf, sector_size) != sector_size)
+               fdisk_fatal(unable_to_read);
+}
+
+static void
+write_sector(uint secno, char *buf) {
+       seek_sector(secno);
+       if (write(fd, buf, sector_size) != sector_size)
+               fdisk_fatal(unable_to_write);
+}
+
+/* Allocate a buffer and read a partition table sector */
+static void
+read_pte(int pno, uint offset) {
+       struct pte *pe = &ptes[pno];
+
+       pe->offset = offset;
+       pe->sectorbuffer = (char *) xmalloc(sector_size);
+       read_sector(offset, pe->sectorbuffer);
+       pe->changed = 0;
+       pe->part_table = pe->ext_pointer = NULL;
+}
+
+static unsigned int
+get_partition_start(const struct pte *pe) {
+       return pe->offset + get_start_sect(pe->part_table);
+}
+
+/*
+ * Avoid warning about DOS partitions when no DOS partition was changed.
+ * Here a heuristic "is probably dos partition".
+ * We might also do the opposite and warn in all cases except
+ * for "is probably nondos partition".
+ */
+static int
+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 ||
+               t == 0x1b || t == 0x1c || t == 0x1e || t == 0x24 ||
+               t == 0xc1 || t == 0xc4 || t == 0xc6);
+}
+
+static 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"));
+#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+          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"));
+       } 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 */
+       } 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"));
+#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+          puts(_("\tx\textra functionality (experts only)"));
+#endif
+       }
+}
+
+#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+static 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*/
+       }  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"));
+       } 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"));
+       }  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 */
+#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"));
+       }
+}
+#endif /* ADVANCED mode */
+
+
+static int
+get_sysid(int i) {
+       return (
+#ifdef CONFIG_FEATURE_SUN_LABEL
+               sun_label ? sunlabel->infos[i].id :
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+               sgi_label ? sgi_get_sysid(i) :
+#endif
+               ptes[i].part_table->sys_ind);
+}
+
+static const struct systypes *
+get_sys_types(void) {
+       return (
+#ifdef CONFIG_FEATURE_SUN_LABEL
+               sun_label ? sun_sys_types :
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+               sgi_label ? sgi_sys_types :
+#endif
+               i386_sys_types);
+}
+
+static const char *partition_type(unsigned char type)
+{
+       int i;
+       const struct systypes *types = get_sys_types();
+
+       for (i=0; types[i].name; i++)
+               if (types[i].name[0] == type)
+                       return types[i].name + 1;
+
+       return NULL;
+}
+
+void list_types(const struct systypes *sys)
+{
+       uint last[4], done = 0, next = 0, size;
+       int i;
+
+       for (i = 0; sys[i].name; i++);
+       size = i;
+
+       for (i = 3; i >= 0; i--)
+               last[3 - i] = done += (size + i - done) / (i + 1);
+       i = done = 0;
+
+       do {
+               printf("%c%2x  %-15.15s", i ? ' ' : '\n',
+                       sys[next].name[0], sys[next].name + 1);
+               next = last[i++] + done;
+               if (i > 3 || next >= last[i]) {
+                       i = 0;
+                       next = ++done;
+               }
+       } while (done < last[0]);
+       putchar('\n');
+}
+
+static int
+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) {
+       if (!p)
+               return;
+       p->boot_ind = 0;
+       p->head = 0;
+       p->sector = 0;
+       p->cyl = 0;
+       p->sys_ind = 0;
+       p->end_head = 0;
+       p->end_sector = 0;
+       p->end_cyl = 0;
+       set_start_sect(p,0);
+       set_nr_sects(p,0);
+}
+
+static void
+set_partition(int i, int doext, uint start, uint stop, int sysid) {
+       struct partition *p;
+       uint offset;
+
+       if (doext) {
+               p = ptes[i].ext_pointer;
+               offset = extended_offset;
+       } else {
+               p = ptes[i].part_table;
+               offset = ptes[i].offset;
+       }
+       p->boot_ind = 0;
+       p->sys_ind = sysid;
+       set_start_sect(p, start - offset);
+       set_nr_sects(p, stop - start + 1);
+       if (dos_compatible_flag && (start/(sectors*heads) > 1023))
+               start = heads*sectors*1024 - 1;
+       set_hsc(p->head, p->sector, p->cyl, start);
+       if (dos_compatible_flag && (stop/(sectors*heads) > 1023))
+               stop = heads*sectors*1024 - 1;
+       set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
+       ptes[i].changed = 1;
+}
+
+static int
+test_c(const char **m, const char *mesg) {
+       int val = 0;
+       if (!*m)
+               fprintf(stderr, _("You must set"));
+       else {
+               fprintf(stderr, " %s", *m);
+               val = 1;
+       }
+       *m = mesg;
+       return val;
+}
+
+static int
+warn_geometry(void) {
+       const char *m = NULL;
+       int prev = 0;
+
+       if (!heads)
+               prev = test_c(&m, _("heads"));
+       if (!sectors)
+               prev = test_c(&m, _("sectors"));
+       if (!cylinders)
+               prev = test_c(&m, _("cylinders"));
+       if (!m)
+               return 0;
+       fprintf(stderr,
+               _("%s%s.\nYou can do this from the extra functions menu.\n"),
+               prev ? _(" and ") : " ", m);
+       return 1;
+}
+
+static void update_units(void)
+{
+       int cyl_units = heads * sectors;
+
+       if (display_in_cyl_units && cyl_units)
+               units_per_sector = cyl_units;
+       else
+               units_per_sector = 1;   /* in sectors */
+}
+
+static 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"
+"There is nothing wrong with that, but this is larger than 1024,\n"
+"and could in certain setups cause problems with:\n"
+"1) software that runs at boot time (e.g., old versions of LILO)\n"
+"2) booting and partitioning software from other OSs\n"
+"   (e.g., DOS FDISK, OS/2 FDISK)\n"),
+                       cylinders);
+}
+
+static void
+read_extended(int ext) {
+       int i;
+       struct pte *pex;
+       struct partition *p, *q;
+
+       ext_index = ext;
+       pex = &ptes[ext];
+       pex->ext_pointer = pex->part_table;
+
+       p = pex->part_table;
+       if (!get_start_sect(p)) {
+               fprintf(stderr,
+                       _("Bad offset in primary extended partition\n"));
+               return;
+       }
+
+       while (IS_EXTENDED (p->sys_ind)) {
+               struct pte *pe = &ptes[partitions];
+
+               if (partitions >= MAXIMUM_PARTS) {
+                       /* This is not a Linux restriction, but
+                          this program uses arrays of size MAXIMUM_PARTS.
+                          Do not try to `improve' this test. */
+                       struct pte *pre = &ptes[partitions-1];
+
+                       fprintf(stderr,
+                               _("Warning: deleting partitions after %d\n"),
+                               partitions);
+                       clear_partition(pre->ext_pointer);
+                       pre->changed = 1;
+                       return;
+               }
+
+               read_pte(partitions, extended_offset + get_start_sect(p));
+
+               if (!extended_offset)
+                       extended_offset = get_start_sect(p);
+
+               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 (pe->ext_pointer)
+                                       fprintf(stderr,
+                                               _("Warning: extra link "
+                                                 "pointer in partition table"
+                                                 " %d\n"), partitions + 1);
+                               else
+                                       pe->ext_pointer = p;
+                       } else if (p->sys_ind) {
+                               if (pe->part_table)
+                                       fprintf(stderr,
+                                               _("Warning: ignoring extra "
+                                                 "data in partition table"
+                                                 " %d\n"), partitions + 1);
+                               else
+                                       pe->part_table = p;
+                       }
+               }
+
+               /* very strange code here... */
+               if (!pe->part_table) {
+                       if (q != pe->ext_pointer)
+                               pe->part_table = q;
+                       else
+                               pe->part_table = q + 1;
+               }
+               if (!pe->ext_pointer) {
+                       if (q != pe->part_table)
+                               pe->ext_pointer = q;
+                       else
+                               pe->ext_pointer = q + 1;
+               }
+
+               p = pe->ext_pointer;
+               partitions++;
+       }
+
+       /* remove empty links */
+ remove:
+       for (i = 4; i < partitions; i++) {
+               struct pte *pe = &ptes[i];
+
+               if (!get_nr_sects(pe->part_table) &&
+                   (partitions > 5 || ptes[4].part_table->sys_ind)) {
+                       printf("omitting empty partition (%d)\n", i+1);
+                       delete_partition(i);
+                       goto remove;    /* numbering changed */
+               }
+       }
+}
+
+static void
+create_doslabel(void) {
+       int i;
+
+       fprintf(stderr,
+       _("Building a new DOS disklabel. Changes will remain in memory only,\n"
+         "until you decide to write them. After that, of course, the previous\n"
+         "content won't be recoverable.\n\n"));
+#ifdef CONFIG_FEATURE_SUN_LABEL
+       sun_nolabel();  /* otherwise always recognised as sun */
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+       sgi_nolabel();  /* otherwise always recognised as sgi */
+#endif
+#ifdef CONFIG_FEATURE_AIX_LABEL
+       aix_label = 0;
+#endif
+#ifdef CONFIG_FEATURE_OSF_LABEL
+       osf_label = 0;
+       possibly_osf_label = 0;
+#endif
+       partitions = 4;
+
+       for (i = 510-64; i < 510; i++)
+               MBRbuffer[i] = 0;
+       write_part_table_flag(MBRbuffer);
+       extended_offset = 0;
+       set_all_unchanged();
+       set_changed(0);
+       get_boot(create_empty_dos);
+}
+
+
+static void
+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);
+       }
+}
+
+static void
+get_kernel_geometry(void) {
+       struct hd_geometry geometry;
+
+       if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
+               kern_heads = geometry.heads;
+               kern_sectors = geometry.sectors;
+               /* never use geometry.cylinders - it is truncated */
+       }
+}
+
+static void
+get_partition_table_geometry(void) {
+       unsigned char *bufp = MBRbuffer;
+       struct partition *p;
+       int i, h, s, hh, ss;
+       int first = 1;
+       int bad = 0;
+
+       if (!(valid_part_table_flag(bufp)))
+               return;
+
+       hh = ss = 0;
+       for (i=0; i<4; i++) {
+               p = pt_offset(bufp, i);
+               if (p->sys_ind != 0) {
+                       h = p->end_head + 1;
+                       s = (p->end_sector & 077);
+                       if (first) {
+                               hh = h;
+                               ss = s;
+                               first = 0;
+                       } else if (hh != h || ss != s)
+                               bad = 1;
+               }
+       }
+
+       if (!first && !bad) {
+               pt_heads = hh;
+               pt_sectors = ss;
+       }
+}
+
+void
+get_geometry(struct geom *g) {
+       int sec_fac;
+       unsigned long longsectors;
+
+       get_sectorsize();
+       sec_fac = sector_size / 512;
+#ifdef CONFIG_FEATURE_SUN_LABEL
+       guess_device_type();
+#endif
+       heads = cylinders = sectors = 0;
+       kern_heads = kern_sectors = 0;
+       pt_heads = pt_sectors = 0;
+
+       get_kernel_geometry();
+       get_partition_table_geometry();
+
+       heads = user_heads ? user_heads :
+               pt_heads ? pt_heads :
+               kern_heads ? kern_heads : 255;
+       sectors = user_sectors ? user_sectors :
+               pt_sectors ? pt_sectors :
+               kern_sectors ? kern_sectors : 63;
+
+       if (ioctl(fd, BLKGETSIZE, &longsectors))
+               longsectors = 0;
+
+       sector_offset = 1;
+       if (dos_compatible_flag)
+               sector_offset = sectors;
+
+       cylinders = longsectors / (heads * sectors);
+       cylinders /= sec_fac;
+       if (!cylinders)
+               cylinders = user_cylinders;
+
+       if (g) {
+               g->heads = heads;
+               g->sectors = sectors;
+               g->cylinders = cylinders;
+       }
+
+       total_number_of_sectors = longsectors;
+}
+
+/*
+ * Read MBR.  Returns:
+ *   -1: no 0xaa55 flag present (possibly entire disk BSD)
+ *    0: found or created label
+ *    1: I/O error
+ */
+int
+get_boot(enum action what) {
+       int i;
+
+       partitions = 4;
+
+       for (i = 0; i < 4; i++) {
+               struct pte *pe = &ptes[i];
+
+               pe->part_table = pt_offset(MBRbuffer, i);
+               pe->ext_pointer = NULL;
+               pe->offset = 0;
+               pe->sectorbuffer = MBRbuffer;
+               pe->changed = (what == create_empty_dos);
+       }
+
+       if (what == create_empty_sun && check_sun_label())
+               return 0;
+
+       memset(MBRbuffer, 0, 512);
+
+       if (what == create_empty_dos)
+               goto got_dos_table;             /* skip reading disk */
+
+       if ((fd = open(disk_device, type_open)) < 0) {
+           if ((fd = open(disk_device, O_RDONLY)) < 0) {
+               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)) {
+               if (what == try_only)
+                       return 1;
+               fdisk_fatal(unable_to_read);
+       }
+
+       get_geometry(NULL);
+
+       update_units();
+
+       if (check_sun_label())
+               return 0;
+
+#ifdef CONFIG_FEATURE_SGI_LABEL
+       if (check_sgi_label())
+               return 0;
+#endif
+
+#ifdef CONFIG_FEATURE_AIX_LABEL
+       if (check_aix_label())
+               return 0;
+#endif
+
+#ifdef CONFIG_FEATURE_OSF_LABEL
+       if (check_osf_label()) {
+               possibly_osf_label = 1;
+               if (!valid_part_table_flag(MBRbuffer)) {
+                       osf_label = 1;
+                       return 0;
+               }
+               printf(_("This disk has both DOS and BSD magic.\n"
+                        "Give the 'b' command to go to BSD mode.\n"));
+       }
+#endif
+
+got_dos_table:
+
+       if (!valid_part_table_flag(MBRbuffer)) {
+               switch(what) {
+               case fdisk:
+                       fprintf(stderr,
+                               _("Device contains neither a valid DOS "
+                                 "partition table, nor Sun, SGI or OSF "
+                                 "disklabel\n"));
+#ifdef __sparc__
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       create_sunlabel();
+#endif
+#else
+                       create_doslabel();
+#endif
+                       return 0;
+               case require:
+                       return -1;
+               case try_only:
+                       return -1;
+               case create_empty_dos:
+               case create_empty_sun:
+                       break;
+               default:
+                       fprintf(stderr, _("Internal error\n"));
+                       exit(1);
+               }
+       }
+
+       warn_cylinders();
+       warn_geometry();
+
+       for (i = 0; i < 4; i++) {
+               struct pte *pe = &ptes[i];
+
+               if (IS_EXTENDED (pe->part_table->sys_ind)) {
+                       if (partitions != 4)
+                               fprintf(stderr, _("Ignoring extra extended "
+                                       "partition %d\n"), i + 1);
+                       else
+                               read_extended(i);
+               }
+       }
+
+       for (i = 3; i < partitions; i++) {
+               struct pte *pe = &ptes[i];
+
+               if (!valid_part_table_flag(pe->sectorbuffer)) {
+                       fprintf(stderr,
+                               _("Warning: invalid flag 0x%04x of partition "
+                               "table %d will be corrected by w(rite)\n"),
+                               part_table_flag(pe->sectorbuffer), i + 1);
+                       pe->changed = 1;
+               }
+       }
+
+       return 0;
+}
+
+/*
+ * Print the message MESG, then read an integer between LOW and HIGH (inclusive).
+ * If the user hits Enter, DFLT is returned.
+ * Answers like +10 are interpreted as offsets from BASE.
+ *
+ * There is no default if DFLT is not between LOW and HIGH.
+ */
+static uint
+read_int(uint low, uint dflt, uint high, uint base, char *mesg)
+{
+       uint i;
+       int default_ok = 1;
+       static char *ms = NULL;
+       static int mslen = 0;
+
+       if (!ms || strlen(mesg)+100 > mslen) {
+               mslen = strlen(mesg)+200;
+               ms = xrealloc(ms,mslen);
+       }
+
+       if (dflt < low || dflt > high)
+               default_ok = 0;
+
+       if (default_ok)
+               snprintf(ms, mslen, _("%s (%d-%d, default %d): "),
+                        mesg, low, high, dflt);
+       else
+               snprintf(ms, mslen, "%s (%d-%d): ",
+                        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 != '+')
+                       continue;
+
+               if (*line_ptr == '+' || *line_ptr == '-') {
+                       i = atoi(line_ptr+1);
+                       if (*line_ptr == '-')
+                               i = -i;
+                       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':
+                               case 'K':
+                                       i *= 2;
+                                       i /= (sector_size / 512);
+                                       i /= units_per_sector;
+                                       break;
+                               case 'm':
+                               case 'M':
+                                       i *= 2048;
+                                       i /= (sector_size / 512);
+                                       i /= units_per_sector;
+                                       break;
+                               case 'g':
+                               case 'G':
+                                       i *= 2048000;
+                                       i /= (sector_size / 512);
+                                       i /= units_per_sector;
+                                       break;
+                               default:
+                                       break;
+                       }
+                       i += base;
+               } else {
+                       i = atoi(line_ptr);
+                       while (isdigit(*line_ptr)) {
+                               line_ptr++;
+                               use_default = 0;
+                       }
+               }
+               if (use_default)
+                       printf(_("Using default value %d\n"), i = dflt);
+               if (i >= low && i <= high)
+                       break;
+               else
+                       printf(_("Value out of range.\n"));
+       }
+       return i;
+}
+
+int
+get_partition(int warn, int max) {
+       struct pte *pe;
+       int i;
+
+       i = read_int(1, 0, max, 0, _("Partition number")) - 1;
+       pe = &ptes[i];
+
+       if (warn) {
+               if ((!sun_label && !sgi_label && !pe->part_table->sys_ind)
+#ifdef CONFIG_FEATURE_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)))
+#endif
+                  )
+                       fprintf(stderr,
+                               _("Warning: partition %d has empty type\n"),
+                               i+1);
+       }
+       return i;
+}
+
+static int
+get_existing_partition(int warn, int max) {
+       int pno = -1;
+       int i;
+
+       for (i = 0; i < max; i++) {
+               struct pte *pe = &ptes[i];
+               struct partition *p = pe->part_table;
+
+               if (p && !is_cleared_partition(p)) {
+                       if (pno >= 0)
+                               goto not_unique;
+                       pno = i;
+               }
+       }
+       if (pno >= 0) {
+               printf(_("Selected partition %d\n"), pno+1);
+               return pno;
+       }
+       printf(_("No partition is defined yet!\n"));
+       return -1;
+
+ not_unique:
+       return get_partition(warn, max);
+}
+
+static int
+get_nonexisting_partition(int warn, int max) {
+       int pno = -1;
+       int i;
+
+       for (i = 0; i < max; i++) {
+               struct pte *pe = &ptes[i];
+               struct partition *p = pe->part_table;
+
+               if (p && is_cleared_partition(p)) {
+                       if (pno >= 0)
+                               goto not_unique;
+                       pno = i;
+               }
+       }
+       if (pno >= 0) {
+               printf(_("Selected partition %d\n"), pno+1);
+               return pno;
+       }
+       printf(_("All primary partitions have been defined already!\n"));
+       return -1;
+
+ not_unique:
+       return get_partition(warn, max);
+}
+
+
+void change_units(void)
+{
+       display_in_cyl_units = !display_in_cyl_units;
+       update_units();
+       printf(_("Changing display/entry units to %s\n"),
+               str_units(PLURAL));
+}
+
+static void
+toggle_active(int i) {
+       struct pte *pe = &ptes[i];
+       struct partition *p = pe->part_table;
+
+       if (IS_EXTENDED (p->sys_ind) && !p->boot_ind)
+               fprintf(stderr,
+                       _("WARNING: Partition %d is an extended partition\n"),
+                       i + 1);
+       p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
+       pe->changed = 1;
+}
+
+static void
+toggle_dos_compatibility_flag(void) {
+       dos_compatible_flag = ~dos_compatible_flag;
+       if (dos_compatible_flag) {
+               sector_offset = sectors;
+               printf(_("DOS Compatibility flag is set\n"));
+       }
+       else {
+               sector_offset = 1;
+               printf(_("DOS Compatibility flag is not set\n"));
+       }
+}
+
+static void
+delete_partition(int i) {
+       struct pte *pe = &ptes[i];
+       struct partition *p = pe->part_table;
+       struct partition *q = pe->ext_pointer;
+
+/* Note that for the fifth partition (i == 4) we don't actually
+ * decrement partitions.
+ */
+
+       if (warn_geometry())
+               return;         /* C/H/S not set */
+       pe->changed = 1;
+
+#ifdef CONFIG_FEATURE_SUN_LABEL
+       if (sun_label) {
+               sun_delete_partition(i);
+               return;
+       }
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+       if (sgi_label) {
+               sgi_delete_partition(i);
+               return;
+       }
+#endif
+
+       if (i < 4) {
+               if (IS_EXTENDED (p->sys_ind) && i == ext_index) {
+                       partitions = 4;
+                       ptes[ext_index].ext_pointer = NULL;
+                       extended_offset = 0;
+               }
+               clear_partition(p);
+               return;
+       }
+
+       if (!q->sys_ind && i > 4) {
+               /* the last one in the chain - just delete */
+               --partitions;
+               --i;
+               clear_partition(ptes[i].ext_pointer);
+               ptes[i].changed = 1;
+       } else {
+               /* not the last one - further ones will be moved down */
+               if (i > 4) {
+                       /* delete this link in the chain */
+                       p = ptes[i-1].ext_pointer;
+                       *p = *q;
+                       set_start_sect(p, get_start_sect(q));
+                       set_nr_sects(p, get_nr_sects(q));
+                       ptes[i-1].changed = 1;
+               } else if (partitions > 5) {    /* 5 will be moved to 4 */
+                       /* the first logical in a longer chain */
+                       pe = &ptes[5];
+
+                       if (pe->part_table) /* prevent SEGFAULT */
+                               set_start_sect(pe->part_table,
+                                              get_partition_start(pe) -
+                                              extended_offset);
+                       pe->offset = extended_offset;
+                       pe->changed = 1;
+               }
+
+               if (partitions > 5) {
+                       partitions--;
+                       while (i < partitions) {
+                               ptes[i] = ptes[i+1];
+                               i++;
+                       }
+               } else
+                       /* the only logical: clear only */
+                       clear_partition(ptes[i].part_table);
+       }
+}
+
+static void
+change_sysid(void) {
+       const char *temp;
+       int i, sys, origsys;
+       struct partition *p;
+
+       i = get_existing_partition(0, partitions);
+       if (i == -1)
+               return;
+       p = ptes[i].part_table;
+       origsys = sys = get_sysid(i);
+
+       /* if changing types T to 0 is allowed, then
+          the reverse change must be allowed, too */
+       if (!sys && !sgi_label && !sun_label && !get_nr_sects(p))
+               printf(_("Partition %d does not exist yet!\n"), i + 1);
+       else while (1) {
+               sys = read_hex (get_sys_types());
+
+               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"));
+                       /* break; */
+               }
+
+               if (!sun_label && !sgi_label) {
+                       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"));
+                               break;
+                       }
+               }
+
+               if (sys < 256) {
+#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"));
+#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"));
+#endif
+                       if (sys == origsys)
+                               break;
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       if (sun_label) {
+                               sun_change_sysid(i, sys);
+                       } else
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+                       if (sgi_label) {
+                               sgi_change_sysid(i, sys);
+                       } else
+#endif
+                               p->sys_ind = sys;
+                       printf (_("Changed system type of partition %d "
+                               "to %x (%s)\n"), i + 1, sys,
+                               (temp = partition_type(sys)) ? temp :
+                               _("Unknown"));
+                       ptes[i].changed = 1;
+                       if (is_dos_partition(origsys) ||
+                           is_dos_partition(sys))
+                               dos_changed = 1;
+                       break;
+               }
+       }
+}
+
+/* check_consistency() and long2chs() added Sat Mar 6 12:28:16 1993,
+ * faith@cs.unc.edu, based on code fragments from pfdisk by Gordon W. Ross,
+ * Jan.  1990 (version 1.2.1 by Gordon W. Ross Aug. 1990; Modified by S.
+ * Lubkin Oct.  1991). */
+
+static void long2chs(ulong ls, uint *c, uint *h, uint *s) {
+       int     spc = heads * sectors;
+
+       *c = ls / spc;
+       ls = ls % spc;
+       *h = ls / sectors;
+       *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 */
+
+       if (!heads || !sectors || (partition >= 4))
+               return;         /* do not check extended partitions */
+
+/* physical beginning c, h, s */
+       pbc = (p->cyl & 0xff) | ((p->sector << 2) & 0x300);
+       pbh = p->head;
+       pbs = p->sector & 0x3f;
+
+/* physical ending c, h, s */
+       pec = (p->end_cyl & 0xff) | ((p->end_sector << 2) & 0x300);
+       peh = p->end_head;
+       pes = p->end_sector & 0x3f;
+
+/* compute logical beginning (c, h, s) */
+       long2chs(get_start_sect(p), &lbc, &lbh, &lbs);
+
+/* compute logical ending (c, h, s) */
+       long2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
+
+/* Same physical / logical beginning? */
+       if (cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
+               printf(_("Partition %d has different physical/logical "
+                       "beginnings (non-Linux?):\n"), partition + 1);
+               printf(_("     phys=(%d, %d, %d) "), pbc, pbh, pbs);
+               printf(_("logical=(%d, %d, %d)\n"),lbc, lbh, lbs);
+       }
+
+/* Same physical / logical ending? */
+       if (cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
+               printf(_("Partition %d has different physical/logical "
+                       "endings:\n"), partition + 1);
+               printf(_("     phys=(%d, %d, %d) "), pec, peh, pes);
+               printf(_("logical=(%d, %d, %d)\n"),lec, leh, les);
+       }
+
+#if 0
+/* Beginning on cylinder boundary? */
+       if (pbh != !pbc || pbs != 1) {
+               printf(_("Partition %i does not start on cylinder "
+                       "boundary:\n"), partition + 1);
+               printf(_("     phys=(%d, %d, %d) "), pbc, pbh, pbs);
+               printf(_("should be (%d, %d, 1)\n"), pbc, !pbc);
+       }
+#endif
+
+/* Ending on cylinder boundary? */
+       if (peh != (heads - 1) || pes != sectors) {
+               printf(_("Partition %i does not end on cylinder boundary:\n"),
+                       partition + 1);
+#if 0
+               printf(_("     phys=(%d, %d, %d) "), pec, peh, pes);
+               printf(_("should be (%d, %d, %d)\n"),
+               pec, heads - 1, sectors);
+#endif
+       }
+}
+
+static void
+list_disk_geometry(void) {
+       long long bytes = (long long) total_number_of_sectors * 512;
+       long megabytes = bytes/1000000;
+
+       if (megabytes < 10000)
+               printf(_("\nDisk %s: %ld MB, %lld bytes\n"),
+                      disk_device, megabytes, bytes);
+       else
+               printf(_("\nDisk %s: %ld.%ld GB, %lld bytes\n"),
+                      disk_device, megabytes/1000, (megabytes/100)%10, bytes);
+       printf(_("%d heads, %d sectors/track, %d cylinders"),
+              heads, sectors, cylinders);
+       if (units_per_sector == 1)
+               printf(_(", total %lu sectors"),
+                      total_number_of_sectors / (sector_size/512));
+       printf("\n");
+       printf(_("Units = %s of %d * %d = %d bytes\n\n"),
+              str_units(PLURAL),
+              units_per_sector, sector_size, units_per_sector * sector_size);
+}
+
+/*
+ * Check whether partition entries are ordered by their starting positions.
+ * Return 0 if OK. Return i if partition i should have been earlier.
+ * Two separate checks: primary and logical partitions.
+ */
+static int
+wrong_p_order(int *prev) {
+       const struct pte *pe;
+       const struct partition *p;
+       uint last_p_start_pos = 0, p_start_pos;
+       int i, last_i = 0;
+
+       for (i = 0 ; i < partitions; i++) {
+               if (i == 4) {
+                       last_i = 4;
+                       last_p_start_pos = 0;
+               }
+               pe = &ptes[i];
+               if ((p = pe->part_table)->sys_ind) {
+                       p_start_pos = get_partition_start(pe);
+
+                       if (last_p_start_pos > p_start_pos) {
+                               if (prev)
+                                       *prev = last_i;
+                               return i;
+                       }
+
+                       last_p_start_pos = p_start_pos;
+                       last_i = i;
+               }
+       }
+       return 0;
+}
+
+#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+/*
+ * Fix the chain of logicals.
+ * extended_offset is unchanged, the set of sectors used is unchanged
+ * The chain is sorted so that sectors increase, and so that
+ * starting sectors increase.
+ *
+ * After this it may still be that cfdisk doesnt like the table.
+ * (This is because cfdisk considers expanded parts, from link to
+ * end of partition, and these may still overlap.)
+ * Now
+ *   sfdisk /dev/hda > ohda; sfdisk /dev/hda < ohda
+ * may help.
+ */
+static void
+fix_chain_of_logicals(void) {
+       int j, oj, ojj, sj, sjj;
+       struct partition *pj,*pjj,tmp;
+
+       /* Stage 1: sort sectors but leave sector of part 4 */
+       /* (Its sector is the global extended_offset.) */
+ stage1:
+       for (j = 5; j < partitions-1; j++) {
+               oj = ptes[j].offset;
+               ojj = ptes[j+1].offset;
+               if (oj > ojj) {
+                       ptes[j].offset = ojj;
+                       ptes[j+1].offset = oj;
+                       pj = ptes[j].part_table;
+                       set_start_sect(pj, get_start_sect(pj)+oj-ojj);
+                       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);
+                       set_start_sect(ptes[j].ext_pointer,
+                                      oj-extended_offset);
+                       goto stage1;
+               }
+       }
+
+       /* Stage 2: sort starting sectors */
+ stage2:
+       for (j = 4; j < partitions-1; j++) {
+               pj = ptes[j].part_table;
+               pjj = ptes[j+1].part_table;
+               sj = get_start_sect(pj);
+               sjj = get_start_sect(pjj);
+               oj = ptes[j].offset;
+               ojj = ptes[j+1].offset;
+               if (oj+sj > ojj+sjj) {
+                       tmp = *pj;
+                       *pj = *pjj;
+                       *pjj = tmp;
+                       set_start_sect(pj, ojj+sjj-oj);
+                       set_start_sect(pjj, oj+sj-ojj);
+                       goto stage2;
+               }
+       }
+
+       /* Probably something was changed */
+       for (j = 4; j < partitions; j++)
+               ptes[j].changed = 1;
+}
+
+
+
+static void
+fix_partition_table_order(void) {
+       struct pte *pei, *pek;
+       int i,k;
+
+       if (!wrong_p_order(NULL)) {
+               printf(_("Nothing to do. Ordering is correct already.\n\n"));
+               return;
+       }
+
+       while ((i = wrong_p_order(&k)) != 0 && i < 4) {
+               /* partition i should have come earlier, move it */
+               /* We have to move data in the MBR */
+               struct partition *pi, *pk, *pe, pbuf;
+               pei = &ptes[i];
+               pek = &ptes[k];
+
+               pe = pei->ext_pointer;
+               pei->ext_pointer = pek->ext_pointer;
+               pek->ext_pointer = pe;
+
+               pi = pei->part_table;
+               pk = pek->part_table;
+
+               memmove(&pbuf, pi, sizeof(struct partition));
+               memmove(pi, pk, sizeof(struct partition));
+               memmove(pk, &pbuf, sizeof(struct partition));
+
+               pei->changed = pek->changed = 1;
+       }
+
+       if (i)
+               fix_chain_of_logicals();
+
+       printf("Done.\n");
+
+}
+#endif
+
+static void
+list_table(int xtra) {
+       const struct partition *p;
+       const char *type;
+       int i, w;
+
+#ifdef CONFIG_FEATURE_SUN_LABEL
+       if (sun_label) {
+               sun_list_table(xtra);
+               return;
+       }
+#endif
+
+#ifdef CONFIG_FEATURE_SGI_LABEL
+       if (sgi_label) {
+               sgi_list_table(xtra);
+               return;
+       }
+#endif
+
+       list_disk_geometry();
+
+#ifdef CONFIG_FEATURE_OSF_LABEL
+       if (osf_label) {
+               xbsd_print_disklabel(xtra);
+               return;
+       }
+#endif
+
+       /* Heuristic: we list partition 3 of /dev/foo as /dev/foo3,
+          but if the device name ends in a digit, say /dev/foo1,
+          then the partition is called /dev/foo1p3. */
+       w = strlen(disk_device);
+       if (w && isdigit(disk_device[w-1]))
+               w++;
+       if (w < 5)
+               w = 5;
+
+       printf(_("%*s Boot    Start       End    Blocks   Id  System\n"),
+              w+1, _("Device"));
+
+       for (i = 0; i < partitions; i++) {
+               const struct pte *pe = &ptes[i];
+
+               p = pe->part_table;
+               if (p && !is_cleared_partition(p)) {
+                       unsigned int psects = get_nr_sects(p);
+                       unsigned int pblocks = psects;
+                       unsigned int podd = 0;
+
+                       if (sector_size < 1024) {
+                               pblocks /= (1024 / sector_size);
+                               podd = psects % (1024 / sector_size);
+                       }
+                       if (sector_size > 1024)
+                               pblocks *= (sector_size / 1024);
+                       printf(
+                           "%s  %c %9ld %9ld %9ld%c  %2x  %s\n",
+                       partname(disk_device, i+1, w+2),
+/* boot flag */         !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG
+                       ? '*' : '?',
+/* start */             (long) cround(get_partition_start(pe)),
+/* end */               (long) cround(get_partition_start(pe) + psects
+                               - (psects ? 1 : 0)),
+/* odd flag on end */   (long) pblocks, podd ? '+' : ' ',
+/* type id */           p->sys_ind,
+/* type name */         (type = partition_type(p->sys_ind)) ?
+                       type : _("Unknown"));
+                       check_consistency(p, i);
+               }
+       }
+
+       /* Is partition table in disk order? It need not be, but... */
+       /* partition table entries are not checked for correct order if this
+          is a sgi, sun or aix labeled disk... */
+       if (dos_label && wrong_p_order(NULL)) {
+               printf(_("\nPartition table entries are not in disk order\n"));
+       }
+}
+
+#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+static void
+x_list_table(int extend) {
+       const struct pte *pe;
+       const struct partition *p;
+       int i;
+
+       printf(_("\nDisk %s: %d heads, %d sectors, %d cylinders\n\n"),
+               disk_device, heads, sectors, cylinders);
+       printf(_("Nr AF  Hd Sec  Cyl  Hd Sec  Cyl    Start     Size ID\n"));
+       for (i = 0 ; i < partitions; i++) {
+               pe = &ptes[i];
+               p = (extend ? pe->ext_pointer : pe->part_table);
+               if (p != NULL) {
+                       printf("%2d %02x%4d%4d%5d%4d%4d%5d%9d%9d %02x\n",
+                               i + 1, p->boot_ind, p->head,
+                               sector(p->sector),
+                               cylinder(p->sector, p->cyl), p->end_head,
+                               sector(p->end_sector),
+                               cylinder(p->end_sector, p->end_cyl),
+                               get_start_sect(p), get_nr_sects(p), p->sys_ind);
+                       if (p->sys_ind)
+                               check_consistency(p, i);
+               }
+       }
+}
+#endif
+
+static void
+fill_bounds(uint *first, uint *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)) {
+                       first[i] = 0xffffffff;
+                       last[i] = 0;
+               } else {
+                       first[i] = get_partition_start(pe);
+                       last[i] = first[i] + get_nr_sects(p) - 1;
+               }
+       }
+}
+
+static void
+check(int n, uint h, uint s, uint c, uint start) {
+       uint total, real_s, real_c;
+
+       real_s = sector(s) - 1;
+       real_c = cylinder(s, c);
+       total = (real_c * sectors + real_s) * heads + h;
+       if (!total)
+               fprintf(stderr, _("Warning: partition %d contains sector 0\n"), n);
+       if (h >= heads)
+               fprintf(stderr,
+                       _("Partition %d: head %d greater than maximum %d\n"),
+                       n, h + 1, heads);
+       if (real_s >= sectors)
+               fprintf(stderr, _("Partition %d: sector %d greater than "
+                       "maximum %d\n"), n, s, sectors);
+       if (real_c >= cylinders)
+               fprintf(stderr, _("Partitions %d: cylinder %d greater than "
+                       "maximum %d\n"), n, real_c + 1, cylinders);
+       if (cylinders <= 1024 && start != total)
+               fprintf(stderr,
+                       _("Partition %d: previous sectors %d disagrees with "
+                       "total %d\n"), n, start, total);
+}
+
+static void
+verify(void) {
+       int i, j;
+       uint total = 1;
+       uint first[partitions], last[partitions];
+       struct partition *p;
+
+       if (warn_geometry())
+               return;
+
+#ifdef CONFIG_FEATURE_SUN_LABEL
+       if (sun_label) {
+               verify_sun();
+               return;
+       }
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+       if (sgi_label) {
+               verify_sgi(1);
+               return;
+       }
+#endif
+
+       fill_bounds(first, last);
+       for (i = 0; i < partitions; i++) {
+               struct pte *pe = &ptes[i];
+
+               p = pe->part_table;
+               if (p->sys_ind && !IS_EXTENDED (p->sys_ind)) {
+                       check_consistency(p, i);
+                       if (get_partition_start(pe) < first[i])
+                               printf(_("Warning: bad start-of-data in "
+                                       "partition %d\n"), i + 1);
+                       check(i + 1, p->end_head, p->end_sector, p->end_cyl,
+                               last[i]);
+                       total += last[i] + 1 - first[i];
+                       for (j = 0; j < i; j++)
+                       if ((first[i] >= first[j] && first[i] <= last[j])
+                        || ((last[i] <= last[j] && last[i] >= first[j]))) {
+                               printf(_("Warning: partition %d overlaps "
+                                       "partition %d.\n"), j + 1, i + 1);
+                               total += first[i] >= first[j] ?
+                                       first[i] : first[j];
+                               total -= last[i] <= last[j] ?
+                                       last[i] : last[j];
+                       }
+               }
+       }
+
+       if (extended_offset) {
+               struct pte *pex = &ptes[ext_index];
+               uint e_last = get_start_sect(pex->part_table) +
+                       get_nr_sects(pex->part_table) - 1;
+
+               for (i = 4; i < partitions; i++) {
+                       total++;
+                       p = ptes[i].part_table;
+                       if (!p->sys_ind) {
+                               if (i != 4 || i + 1 < partitions)
+                                       printf(_("Warning: partition %d "
+                                               "is empty\n"), i + 1);
+                       }
+                       else if (first[i] < extended_offset ||
+                                       last[i] > e_last)
+                               printf(_("Logical partition %d not entirely in "
+                                       "partition %d\n"), i + 1, ext_index + 1);
+               }
+       }
+
+       if (total > heads * sectors * cylinders)
+               printf(_("Total allocated sectors %d greater than the maximum "
+                       "%d\n"), total, heads * sectors * cylinders);
+       else if ((total = heads * sectors * cylinders - total) != 0)
+               printf(_("%d unallocated sectors\n"), total);
+}
+
+static void
+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;
+       struct partition *q = ptes[ext_index].part_table;
+       uint start, stop = 0, limit, temp,
+               first[partitions], last[partitions];
+
+       if (p && p->sys_ind) {
+               printf(_("Partition %d is already defined.  Delete "
+                        "it before re-adding it.\n"), n + 1);
+               return;
+       }
+       fill_bounds(first, last);
+       if (n < 4) {
+               start = sector_offset;
+               if (display_in_cyl_units)
+                       limit = heads * sectors * cylinders - 1;
+               else
+                       limit = total_number_of_sectors - 1;
+               if (extended_offset) {
+                       first[ext_index] = extended_offset;
+                       last[ext_index] = get_start_sect(q) +
+                               get_nr_sects(q) - 1;
+               }
+       } else {
+               start = extended_offset + sector_offset;
+               limit = get_start_sect(q) + get_nr_sects(q) - 1;
+       }
+       if (display_in_cyl_units)
+               for (i = 0; i < partitions; i++)
+                       first[i] = (cround(first[i]) - 1) * units_per_sector;
+
+       snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
+       do {
+               temp = start;
+               for (i = 0; i < partitions; i++) {
+                       int lastplusoff;
+
+                       if (start == ptes[i].offset)
+                               start += sector_offset;
+                       lastplusoff = last[i] + ((n<4) ? 0 : sector_offset);
+                       if (start >= first[i] && start <= lastplusoff)
+                               start = lastplusoff + 1;
+               }
+               if (start > limit)
+                       break;
+               if (start >= temp+units_per_sector && readed) {
+                       printf(_("Sector %d is already allocated\n"), temp);
+                       temp = start;
+                       readed = 0;
+               }
+               if (!readed && start == temp) {
+                       uint saved_start;
+
+                       saved_start = start;
+                       start = read_int(cround(saved_start), cround(saved_start), cround(limit),
+                                        0, mesg);
+                       if (display_in_cyl_units) {
+                               start = (start - 1) * units_per_sector;
+                               if (start < saved_start) start = saved_start;
+                       }
+                       readed = 1;
+               }
+       } while (start != temp || !readed);
+       if (n > 4) {                    /* NOT for fifth partition */
+               struct pte *pe = &ptes[n];
+
+               pe->offset = start - sector_offset;
+               if (pe->offset == extended_offset) { /* must be corrected */
+                       pe->offset++;
+                       if (sector_offset == 1)
+                               start++;
+               }
+       }
+
+       for (i = 0; i < partitions; i++) {
+               struct pte *pe = &ptes[i];
+
+               if (start < pe->offset && limit >= pe->offset)
+                       limit = pe->offset - 1;
+               if (start < first[i] && limit >= first[i])
+                       limit = first[i] - 1;
+       }
+       if (start > limit) {
+               printf(_("No free sectors available\n"));
+               if (n > 4)
+                       partitions--;
+               return;
+       }
+       if (cround(start) == cround(limit)) {
+               stop = limit;
+       } else {
+               snprintf(mesg, sizeof(mesg),
+                        _("Last %s or +size or +sizeM or +sizeK"),
+                        str_units(SINGULAR));
+               stop = read_int(cround(start), cround(limit), cround(limit),
+                               cround(start), mesg);
+               if (display_in_cyl_units) {
+                       stop = stop * units_per_sector - 1;
+                       if (stop >limit)
+                               stop = limit;
+               }
+       }
+
+       set_partition(n, 0, start, stop, sys);
+       if (n > 4)
+               set_partition(n - 1, 1, ptes[n].offset, stop, EXTENDED);
+
+       if (IS_EXTENDED (sys)) {
+               struct pte *pe4 = &ptes[4];
+               struct pte *pen = &ptes[n];
+
+               ext_index = n;
+               pen->ext_pointer = p;
+               pe4->offset = extended_offset = start;
+               pe4->sectorbuffer = xcalloc(1, sector_size);
+               pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
+               pe4->ext_pointer = pe4->part_table + 1;
+               pe4->changed = 1;
+               partitions = 5;
+       }
+}
+
+static void
+add_logical(void) {
+       if (partitions > 5 || ptes[4].part_table->sys_ind) {
+               struct pte *pe = &ptes[partitions];
+
+               pe->sectorbuffer = xcalloc(1, sector_size);
+               pe->part_table = pt_offset(pe->sectorbuffer, 0);
+               pe->ext_pointer = pe->part_table + 1;
+               pe->offset = 0;
+               pe->changed = 1;
+               partitions++;
+       }
+       add_partition(partitions - 1, LINUX_NATIVE);
+}
+
+static void
+new_partition(void) {
+       int i, free_primary = 0;
+
+       if (warn_geometry())
+               return;
+
+#ifdef CONFIG_FEATURE_SUN_LABEL
+       if (sun_label) {
+               add_sun_partition(get_partition(0, partitions), LINUX_NATIVE);
+               return;
+       }
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+       if (sgi_label) {
+               sgi_add_partition(get_partition(0, partitions), LINUX_NATIVE);
+               return;
+       }
+#endif
+#ifdef CONFIG_FEATURE_AIX_LABEL
+       if (aix_label) {
+               printf(_("\tSorry - this fdisk cannot handle AIX disk labels."
+                        "\n\tIf you want to add DOS-type partitions, create"
+                        "\n\ta new empty DOS partition table first. (Use o.)"
+                        "\n\tWARNING: "
+                        "This will destroy the present disk contents.\n"));
+               return;
+       }
+#endif
+
+       if (partitions >= MAXIMUM_PARTS) {
+               printf(_("The maximum number of partitions has been created\n"));
+               return;
+       }
+
+       for (i = 0; i < 4; i++)
+               free_primary += !ptes[i].part_table->sys_ind;
+       if (!free_primary) {
+               if (extended_offset)
+                       add_logical();
+               else
+                       printf(_("You must delete some partition and add "
+                                "an extended partition first\n"));
+       } else {
+               char c, line[LINE_LENGTH];
+               snprintf(line, sizeof(line), "%s\n   %s\n   p   primary "
+                                               "partition (1-4)\n",
+                        "Command action", (extended_offset ?
+                        "l   logical (5 or over)" : "e   extended"));
+               while (1) {
+                       if ((c = read_char(line)) == 'p' || c == 'P') {
+                               i = get_nonexisting_partition(0, 4);
+                               if (i >= 0)
+                                       add_partition(i, LINUX_NATIVE);
+                               return;
+                       }
+                       else if (c == 'l' && extended_offset) {
+                               add_logical();
+                               return;
+                       }
+                       else if (c == 'e' && !extended_offset) {
+                               i = get_nonexisting_partition(0, 4);
+                               if (i >= 0)
+                                       add_partition(i, EXTENDED);
+                               return;
+                       }
+                       else
+                               printf(_("Invalid partition number "
+                                        "for type `%c'\n"), c);
+               }
+       }
+}
+
+static void
+write_table(void) {
+       int i;
+
+       if (dos_label) {
+               for (i=0; i<3; i++)
+                       if (ptes[i].changed)
+                               ptes[3].changed = 1;
+               for (i = 3; i < partitions; i++) {
+                       struct pte *pe = &ptes[i];
+
+                       if (pe->changed) {
+                               write_part_table_flag(pe->sectorbuffer);
+                               write_sector(pe->offset, pe->sectorbuffer);
+                       }
+               }
+       }
+#ifdef CONFIG_FEATURE_SGI_LABEL
+       else if (sgi_label) {
+               /* no test on change? the printf below might be mistaken */
+               sgi_write_table();
+       }
+#endif
+#ifdef CONFIG_FEATURE_SUN_LABEL
+         else if (sun_label) {
+               int needw = 0;
+
+               for (i=0; i<8; i++)
+                       if (ptes[i].changed)
+                               needw = 1;
+               if (needw)
+                       sun_write_table();
+       }
+#endif
+
+       printf(_("The partition table has been altered!\n\n"));
+       reread_partition_table(1);
+}
+
+void
+reread_partition_table(int leave) {
+       int error = 0;
+       int i;
+
+       printf(_("Calling ioctl() to re-read partition table.\n"));
+       sync();
+       sleep(2);
+       if ((i = ioctl(fd, BLKRRPART)) != 0) {
+               error = errno;
+       } else {
+               /* some kernel versions (1.2.x) seem to have trouble
+                  rereading the partition table, but if asked to do it
+                  twice, the second time works. - biro@yggdrasil.com */
+               sync();
+               sleep(2);
+               if ((i = ioctl(fd, BLKRRPART)) != 0)
+                       error = errno;
+       }
+
+       if (i) {
+               printf(_("\nWARNING: Re-reading the partition table "
+                        "failed with error %d: %s.\n"
+                        "The kernel still uses the old table.\n"
+                        "The new table will be used "
+                        "at the next reboot.\n"),
+                       error, strerror(error));
+       }
+
+       if (dos_changed)
+           printf(
+               _("\nWARNING: If you have created or modified any DOS 6.x\n"
+               "partitions, please see the fdisk manual page for additional\n"
+               "information.\n"));
+
+       if (leave) {
+               close(fd);
+
+               printf(_("Syncing disks.\n"));
+               sync();
+               sleep(4);               /* for sync() */
+               exit(!!i);
+       }
+}
+
+#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#define MAX_PER_LINE    16
+static void
+print_buffer(char pbuffer[]) {
+       int     i,
+               l;
+
+       for (i = 0, l = 0; i < sector_size; i++, l++) {
+               if (l == 0)
+                       printf("0x%03X:", i);
+               printf(" %02X", (unsigned char) pbuffer[i]);
+               if (l == MAX_PER_LINE - 1) {
+                       printf("\n");
+                       l = -1;
+               }
+       }
+       if (l > 0)
+               printf("\n");
+       printf("\n");
+}
+
+
+static void
+print_raw(void) {
+       int i;
+
+       printf(_("Device: %s\n"), disk_device);
+#if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL)
+       if (sun_label || sgi_label)
+               print_buffer(MBRbuffer);
+       else
+#endif
+               for (i = 3; i < partitions; i++)
+                       print_buffer(ptes[i].sectorbuffer);
+}
+
+static void
+move_begin(int i) {
+       struct pte *pe = &ptes[i];
+       struct partition *p = pe->part_table;
+       uint new, first;
+
+       if (warn_geometry())
+               return;
+       if (!p->sys_ind || !get_nr_sects(p) || IS_EXTENDED (p->sys_ind)) {
+               printf(_("Partition %d has no data area\n"), i + 1);
+               return;
+       }
+       first = get_partition_start(pe);
+       new = read_int(first, first, first + get_nr_sects(p) - 1, first,
+                      _("New beginning of data")) - pe->offset;
+
+       if (new != get_nr_sects(p)) {
+               first = get_nr_sects(p) + get_start_sect(p) - new;
+               set_nr_sects(p, first);
+               set_start_sect(p, new);
+               pe->changed = 1;
+       }
+}
+
+static void
+xselect(void) {
+       char c;
+
+       while(1) {
+               putchar('\n');
+               c = tolower(read_char(_("Expert command (m for help): ")));
+               switch (c) {
+               case 'a':
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       if (sun_label)
+                               sun_set_alt_cyl();
+#endif
+                       break;
+               case 'b':
+                       if (dos_label)
+                               move_begin(get_partition(0, partitions));
+                       break;
+               case 'c':
+                       user_cylinders = cylinders =
+                               read_int(1, cylinders, 1048576, 0,
+                                        _("Number of cylinders"));
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       if (sun_label)
+                               sun_set_ncyl(cylinders);
+#endif
+                       if (dos_label)
+                               warn_cylinders();
+                       break;
+               case 'd':
+                       print_raw();
+                       break;
+               case 'e':
+#ifdef CONFIG_FEATURE_SGI_LABEL
+                       if (sgi_label)
+                               sgi_set_xcyl();
+                        else
+#endif
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                        if (sun_label)
+                               sun_set_xcyl();
+                        else
+#endif
+                       if (dos_label)
+                               x_list_table(1);
+                       break;
+               case 'f':
+                       if (dos_label)
+                               fix_partition_table_order();
+                       break;
+               case 'g':
+#ifdef CONFIG_FEATURE_SGI_LABEL
+                       create_sgilabel();
+#endif
+                       break;
+               case 'h':
+                       user_heads = heads = read_int(1, heads, 256, 0,
+                                        _("Number of heads"));
+                       update_units();
+                       break;
+               case 'i':
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       if (sun_label)
+                               sun_set_ilfact();
+#endif
+                       break;
+               case 'o':
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       if (sun_label)
+                               sun_set_rspeed();
+#endif
+                       break;
+               case 'p':
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       if (sun_label)
+                               list_table(1);
+                       else
+#endif
+                               x_list_table(0);
+                       break;
+               case 'q':
+                       close(fd);
+                       printf("\n");
+                       exit(0);
+               case 'r':
+                       return;
+               case 's':
+                       user_sectors = sectors = read_int(1, sectors, 63, 0,
+                                          _("Number of sectors"));
+                       if (dos_compatible_flag) {
+                               sector_offset = sectors;
+                               fprintf(stderr, _("Warning: setting "
+                                       "sector offset for DOS "
+                                       "compatiblity\n"));
+                       }
+                       update_units();
+                       break;
+               case 'v':
+                       verify();
+                       break;
+               case 'w':
+                       write_table();  /* does not return */
+                       break;
+               case 'y':
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       if (sun_label)
+                               sun_set_pcylcount();
+#endif
+                       break;
+               default:
+                       xmenu();
+               }
+       }
+}
+#endif /* ADVANCED mode */
+
+static int
+is_ide_cdrom_or_tape(const char *device) {
+       FILE *procf;
+       char buf[100];
+       struct stat statbuf;
+       int is_ide = 0;
+
+       /* No device was given explicitly, and we are trying some
+          likely things.  But opening /dev/hdc may produce errors like
+          "hdc: tray open or drive not ready"
+          if it happens to be a CD-ROM drive. It even happens that
+          the process hangs on the attempt to read a music CD.
+          So try to be careful. This only works since 2.1.73. */
+
+       if (strncmp("/dev/hd", device, 7))
+               return 0;
+
+       snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
+       procf = fopen(buf, "r");
+       if (procf != NULL && fgets(buf, sizeof(buf), procf))
+               is_ide = (!strncmp(buf, "cdrom", 5) ||
+                         !strncmp(buf, "tape", 4));
+       else
+               /* Now when this proc file does not exist, skip the
+                  device when it is read-only. */
+               if (stat(device, &statbuf) == 0)
+                       is_ide = ((statbuf.st_mode & 0222) == 0);
+
+       if (procf)
+               fclose(procf);
+       return is_ide;
+}
+
+static void
+try(const char *device, int user_specified) {
+       int gb;
+
+       disk_device = device;
+       if (setjmp(listingbuf))
+               return;
+       if (!user_specified)
+               if (is_ide_cdrom_or_tape(device))
+                       return;
+       if ((fd = open(disk_device, type_open)) >= 0) {
+               gb = get_boot(try_only);
+               if (gb > 0) {   /* I/O error */
+                       close(fd);
+               } else if (gb < 0) { /* no DOS signature */
+                       list_disk_geometry();
+                       if (aix_label)
+                               return;
+#ifdef CONFIG_FEATURE_OSF_LABEL
+                       if (btrydev(device) < 0)
+#endif
+                               fprintf(stderr,
+                                       _("Disk %s doesn't contain a valid "
+                                         "partition table\n"), device);
+                       close(fd);
+               } else {
+                       close(fd);
+                       list_table(0);
+                       if (!sun_label && partitions > 4)
+                               delete_partition(ext_index);
+               }
+       } else {
+               /* Ignore other errors, since we try IDE
+                  and SCSI hard disks which may not be
+                  installed on the system. */
+               if (errno == EACCES) {
+                       fprintf(stderr, _("Cannot open %s\n"), device);
+                       return;
+               }
+       }
+}
+
+/* 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) {
+       FILE *procpt;
+       char line[100], ptname[100], devname[120], *s;
+       int ma, mi, sz;
+
+       procpt = wfopen(PROC_PARTITIONS, "r");
+
+       while (fgets(line, sizeof(line), procpt)) {
+               if (sscanf (line, " %d %d %d %[^\n ]",
+                           &ma, &mi, &sz, ptname) != 4)
+                       continue;
+               for (s = ptname; *s; s++);
+               if (isdigit(s[-1]))
+                       continue;
+               snprintf(devname, sizeof(devname), "/dev/%s", ptname);
+               try(devname, 0);
+       }
+       fclose(procpt);
+}
+
+static void
+unknown_command(int c) {
+       printf(_("%c: unknown command\n"), c);
+}
+
+int fdisk_main(int argc, char **argv) {
+       int j, c;
+       int optl = 0, opts = 0;
+
+       /*
+        * Calls:
+        *  fdisk -v
+        *  fdisk -l [-b sectorsize] [-u] device ...
+        *  fdisk -s [partition] ...
+        *  fdisk [-b sectorsize] [-u] device
+        *
+        * Options -C, -H, -S set the geometry.
+        *
+        */
+       while ((c = getopt(argc, argv, "b:C:H:lsS:uvV")) != -1) {
+               switch (c) {
+               case 'b':
+                       /* Ugly: this sector size is really per device,
+                          so cannot be combined with multiple disks,
+                          and te same goes for the C/H/S options.
+                       */
+                       sector_size = atoi(optarg);
+                       if (sector_size != 512 && sector_size != 1024 &&
+                           sector_size != 2048)
+                               show_usage();
+                       sector_offset = 2;
+                       user_set_sector_size = 1;
+                       break;
+               case 'C':
+                       user_cylinders = atoi(optarg);
+                       break;
+               case 'H':
+                       user_heads = atoi(optarg);
+                       if (user_heads <= 0 || user_heads >= 256)
+                               user_heads = 0;
+                       break;
+               case 'S':
+                       user_sectors = atoi(optarg);
+                       if (user_sectors <= 0 || user_sectors >= 64)
+                               user_sectors = 0;
+                       break;
+               case 'l':
+                       optl = 1;
+                       break;
+               case 's':
+                       opts = 1;
+                       break;
+               case 'u':
+                       display_in_cyl_units = 0;
+                       break;
+               case 'V':
+               case 'v':
+                       printf("fdisk v" UTIL_LINUX_VERSION "\n");
+                       return 0;
+               default:
+                       show_usage();
+               }
+       }
+
+#if 0
+       printf(_("This kernel finds the sector size itself - "
+                "-b option ignored\n"));
+#else
+       if (user_set_sector_size && argc-optind != 1)
+               printf(_("Warning: the -b (set sector size) option should"
+                        " be used with one specified device\n"));
+#endif
+
+       if (optl) {
+               nowarn = 1;
+               type_open = O_RDONLY;
+               if (argc > optind) {
+                       int k;
+#if __GNUC__
+                       /* avoid gcc warning:
+                          variable `k' might be clobbered by `longjmp' */
+                       (void)&k;
+#endif
+                       listing = 1;
+                       for (k=optind; k<argc; k++)
+                               try(argv[k], 1);
+               } else {
+                       /* we no longer have default device names */
+                       /* but, we can use /proc/partitions instead */
+                       tryprocpt();
+               }
+               return 0;
+       }
+
+       if (opts) {
+               long size;
+
+               nowarn = 1;
+               type_open = O_RDONLY;
+
+               opts = argc - optind;
+               if (opts <= 0)
+                       show_usage();
+
+               for (j = optind; j < argc; j++) {
+                       disk_device = argv[j];
+                       if ((fd = open(disk_device, type_open)) < 0)
+                               fdisk_fatal(unable_to_open);
+                       if (ioctl(fd, BLKGETSIZE, &size))
+                               fdisk_fatal(ioctl_error);
+                       close(fd);
+                       if (opts == 1)
+                               printf("%ld\n", size/2);
+                       else
+                               printf("%s: %ld\n", argv[j], size/2);
+               }
+               return 0;
+       }
+
+       if (argc-optind == 1)
+               disk_device = argv[optind];
+       else
+               show_usage();
+
+       get_boot(fdisk);
+
+#ifdef CONFIG_FEATURE_OSF_LABEL
+       if (osf_label) {
+               /* OSF label, and no DOS label */
+               printf(_("Detected an OSF/1 disklabel on %s, entering "
+                        "disklabel mode.\n"),
+                      disk_device);
+               bselect();
+               osf_label = 0;
+               /* If we return we may want to make an empty DOS label? */
+       }
+#endif
+
+       while (1) {
+               putchar('\n');
+               c = tolower(read_char(_("Command (m for help): ")));
+               switch (c) {
+               case 'a':
+                       if (dos_label)
+                               toggle_active(get_partition(1, partitions));
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       else if (sun_label)
+                               toggle_sunflags(get_partition(1, partitions),
+                                               0x01);
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+                       else if (sgi_label)
+                               sgi_set_bootpartition(
+                                       get_partition(1, partitions));
+#endif
+                       else
+                               unknown_command(c);
+                       break;
+               case 'b':
+#ifdef CONFIG_FEATURE_SGI_LABEL
+                       if (sgi_label) {
+                               printf(_("\nThe current boot file is: %s\n"),
+                                      sgi_get_bootfile());
+                               if (read_chars(_("Please enter the name of the "
+                                              "new boot file: ")) == '\n')
+                                       printf(_("Boot file unchanged\n"));
+                               else
+                                       sgi_set_bootfile(line_ptr);
+                       } else
+#endif
+#ifdef CONFIG_FEATURE_OSF_LABEL
+                               bselect();
+#endif
+                       break;
+               case 'c':
+                       if (dos_label)
+                               toggle_dos_compatibility_flag();
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       else if (sun_label)
+                               toggle_sunflags(get_partition(1, partitions),
+                                               0x10);
+#endif
+#ifdef CONFIG_FEATURE_SGI_LABEL
+                       else if (sgi_label)
+                               sgi_set_swappartition(
+                                               get_partition(1, partitions));
+#endif
+                       else
+                               unknown_command(c);
+                       break;
+               case 'd':
+                       j = get_existing_partition(1, partitions);
+                       if (j >= 0)
+                               delete_partition(j);
+                       break;
+               case 'i':
+#ifdef CONFIG_FEATURE_SGI_LABEL
+                       if (sgi_label)
+                               create_sgiinfo();
+                       else
+#endif
+                               unknown_command(c);
+               case 'l':
+                       list_types(get_sys_types());
+                       break;
+               case 'm':
+                       menu();
+                       break;
+               case 'n':
+                       new_partition();
+                       break;
+               case 'o':
+                       create_doslabel();
+                       break;
+               case 'p':
+                       list_table(0);
+                       break;
+               case 'q':
+                       close(fd);
+                       printf("\n");
+                       return 0;
+               case 's':
+#ifdef CONFIG_FEATURE_SUN_LABEL
+                       create_sunlabel();
+#endif
+                       break;
+               case 't':
+                       change_sysid();
+                       break;
+               case 'u':
+                       change_units();
+                       break;
+               case 'v':
+                       verify();
+                       break;
+               case 'w':
+                       write_table();          /* does not return */
+                       break;
+#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+               case 'x':
+#ifdef CONFIG_FEATURE_SGI_LABEL
+                       if (sgi_label) {
+                               fprintf(stderr,
+                                       _("\n\tSorry, no experts menu for SGI "
+                                       "partition tables available.\n\n"));
+                       } else
+#endif
+
+                               xselect();
+                       break;
+#endif
+               default:
+                       unknown_command(c);
+                       menu();
+               }
+       }
+       return 0;
+}