--- /dev/null
+/* 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;
+}
projects / platform / upstream / busybox.git / commitdiff