Imported from util-linux-2.2 tarball.

1 files changed, 1339 insertions, 0 deletions

diff --git a/disk-utils/fdisk.c b/disk-utils/fdisk.c
new file mode 100644
index 000000000..3c0a328d5
--- /dev/null
+++ b/disk-utils/fdisk.c
@@ -0,0 +1,1339 @@
+/* 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.
+ *
+ * Before Linux version 0.95c, this program requires a kernel patch.
+ *
+ * Modified, Tue Feb  2 18:46:49 1993, faith@cs.unc.edu to better support SCSI.
+ * Modified, Sat Feb 27 18:11:27 1993, faith@cs.unc.edu: added extfs support.
+ * Modified, Sat Mar  6 10:14:12 1993, faith@cs.unc.edu: added more comments.
+ * Modified, Sat Mar  6 12:25:45 1993, faith@cs.unc.edu:
+ *	Added patches from Michael Bischoff (i1041905@ws.rz.tu-bs.de
+ *	or mbi@mo.math.nat.tu-bs.de) to fix the following problems:
+ *	1) Incorrect mapping of head/sector/cylinder to absolute sector
+ *	2) Odd sector count causes one sector to be lost
+ * Modified, Sat Mar  6 12:25:52 1993, faith@cs.unc.edu: improved verification.
+ * Modified, Sat Apr 17 15:00:00 1993, LeBlanc@mcc.ac.uk: add -s, fix -l.
+ * Modified, Sat Apr 24 10:00:00 1993, LeBlanc@mcc.ac.uk: fix overlap bug.
+ * Modified, Wed May  5 21:30:00 1993, LeBlanc@mcc.ac.uk: errors to stderr.
+ * Modified, Mon Mar 21 20:00:00 1994, LeBlanc@mcc.ac.uk:
+ *	more stderr for messages, avoid division by 0, and
+ *	give reboot message only if ioctl(fd, BLKRRPART) fails.
+ * Modified, Mon Apr 25 01:01:05 1994, martin@cs.unc.edu:
+ *    1) Added support for DOS, OS/2, ... compatibility.  We should be able
+ *       use this fdisk to partition our drives for other operating systems.
+ *    2) Added a print the raw data in the partition table command.
+ * Modified, Wed Jun 22 21:05:30 1994, faith@cs.unc.edu:
+ *    Added/changed a few partition type names to conform to cfdisk.
+ *    (suggested by Sujal, smpatel@wam.umd.edu)
+ */
+
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <setjmp.h>
+#include <errno.h>
+
+#include <sys/ioctl.h>
+
+#include <linux/genhd.h>
+#include <linux/hdreg.h>
+#include <linux/fs.h>
+
+#if defined(__GNUC__) || defined(HAS_LONG_LONG)
+typedef long long ext2_loff_t;
+#else
+typedef long      ext2_loff_t;
+#endif
+
+extern ext2_loff_t ext2_llseek(unsigned int fd,
+			       ext2_loff_t offset,
+			       unsigned int origin);
+
+#define hex_val(c)	({ \
+				char _c = (c); \
+				isdigit(_c) ? _c - '0' : \
+				tolower(_c) + 10 - 'a'; \
+			})
+
+
+#define VERSION	"2.0a (>2GB)"
+
+#define DEFAULT_DEVICE	"/dev/hda"
+#define ALTERNATE_DEVICE "/dev/sda"
+#define LINE_LENGTH	80
+#define MAXIMUM_PARTS	60
+#define SECTOR_SIZE	512
+#define PART_TABLE_FLAG	0xaa55
+#define table_check(b)	((unsigned short *)((b) + 0x1fe))
+#define 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 calculate(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;	\
+			}
+
+#define cround(n)	(((n) + display_factor * unit_flag) / display_factor)
+#define ACTIVE_FLAG	0x80
+#define EXTENDED	5
+
+#define LINUX_PARTITION	0x81
+#define LINUX_SWAP	0x82
+#define LINUX_NATIVE	0x83
+
+enum failure {usage, unable_to_open, unable_to_read, unable_to_seek,
+	unable_to_write, out_of_memory};
+
+char	*disk_device = DEFAULT_DEVICE,	/* hda, unless specified */
+	*line_ptr,			/* interactive input */
+	line_buffer[LINE_LENGTH],
+	changed[MAXIMUM_PARTS],		/* marks changed buffers */
+	buffer[SECTOR_SIZE],		/* first four partitions */
+	*buffers[MAXIMUM_PARTS]		/* pointers to buffers */
+		= {buffer, buffer, buffer, buffer};
+
+int	fd,				/* the disk */
+	ext_index,			/* the prime extended partition */
+	listing = 0,			/* no aborts for fdisk -l */
+	size_flag = 0,
+	dos_compatible_flag = ~0,
+	partitions = 4;			/* maximum partition + 1 */
+
+uint	heads,
+	sectors,
+	cylinders,
+	sector_offset = 1,
+	display_factor = 1,		/* in units/sector */
+	unit_flag = 1,
+	full_bits = 0,			/* 1024 cylinders in sectors */
+	extended_offset = 0,		/* offset of link pointers */
+	offsets[MAXIMUM_PARTS] = {0, 0, 0, 0};
+
+struct	partition *part_table[MAXIMUM_PARTS]	/* partitions */
+		= {offset(buffer, 0), offset(buffer, 1),
+		offset(buffer, 2), offset(buffer, 3)},
+	*ext_pointers[MAXIMUM_PARTS]		/* link pointers */
+		= {NULL, NULL, NULL, NULL};
+
+struct systypes {
+	unsigned char index;
+	char *name;
+	} sys_types[] = {
+		{0, "Empty"},
+		{1, "DOS 12-bit FAT"},
+		{2, "XENIX root"},
+		{3, "XENIX usr"},
+		{4, "DOS 16-bit <32M"},
+		{EXTENDED, "Extended"},
+		{6, "DOS 16-bit >=32M"},
+		{7, "OS/2 HPFS"},		/* or QNX? */
+		{8, "AIX"},
+		{9, "AIX bootable"},
+		{10, "OS/2 Boot Manager"},
+		{0x40, "Venix 80286"},
+		{0x51, "Novell?"},
+		{0x52, "Microport"},		/* or CPM? */
+		{0x63, "GNU HURD"},		/* or System V/386? */
+		{0x64, "Novell"},
+		{0x75, "PC/IX"},
+		{0x80, "Old MINIX"},		/* Minix 1.4a and earlier */
+
+		{LINUX_PARTITION, "Linux/MINIX"}, /* Minix 1.4b and later */
+		{LINUX_SWAP, "Linux swap"},
+		{LINUX_NATIVE, "Linux native"},
+
+		{0x93, "Amoeba"},
+		{0x94, "Amoeba BBT"},		/* (bad block table) */
+		{0xa5, "BSD/386"},
+		{0xb7, "BSDI fs"},
+		{0xb8, "BSDI swap"},
+		{0xc7, "Syrinx"},
+		{0xdb, "CP/M"},			/* or Concurrent DOS? */
+		{0xe1, "DOS access"},
+		{0xe3, "DOS R/O"},
+		{0xf2, "DOS secondary"},
+		{0xff, "BBT"}			/* (bad track table) */
+	};
+
+jmp_buf listingbuf;
+
+void fatal(enum failure why)
+{
+	char	error[LINE_LENGTH],
+		*message = error;
+
+	if (listing) {
+		close(fd);
+		longjmp(listingbuf, 1);
+	}
+
+	switch (why) {
+		case usage: message =
+			"Usage: fdisk [-l] [-v] [-s /dev/hdxn] [/dev/hdx]\n";
+			break;
+		case unable_to_open:
+			sprintf(error, "Unable to open %s\n", disk_device);
+			break;
+		case unable_to_read:
+			sprintf(error, "Unable to read %s\n", disk_device);
+			break;
+		case unable_to_seek:
+			sprintf(error, "Unable to seek on %s\n", disk_device);
+			break;
+		case unable_to_write:
+			sprintf(error, "Unable to write %s\n", disk_device);
+			break;
+		case out_of_memory:
+			message = "Unable to allocate any more memory\n";
+			break;
+		default: message = "Fatal error\n";
+	}
+
+	fputc('\n', stderr);
+	fputs(message, stderr);
+	exit(1);
+}
+
+void menu(void)
+{
+	puts("Command action\n"
+		"   a   toggle a bootable flag\n"
+		"   c   toggle the dos compatiblity flag\n"
+		"   d   delete a partition\n"
+		"   l   list known partition types\n"
+		"   m   print this menu\n"
+		"   n   add a new partition\n"
+		"   p   print the partition table\n"
+		"   q   quit without saving changes\n"
+		"   t   change a partition's system id\n"
+		"   u   change display/entry units\n"
+		"   v   verify the partition table\n"
+		"   w   write table to disk and exit\n"
+		"   x   extra functionality (experts only)"
+	);
+}
+
+void xmenu(void)
+{
+	puts("Command action\n"
+		"   b   move beginning of data in a partition\n"
+		"   c   change number of cylinders\n"
+		"   d   print the raw data in the partition table\n"
+		"   e   list extended partitions\n"
+		"   h   change number of heads\n"
+		"   m   print this menu\n"
+		"   p   print the partition table\n"
+		"   q   quit without saving changes\n"
+		"   r   return to main menu\n"
+		"   s   change number of sectors\n"
+		"   w   write table to disk and exit"
+	);
+}
+
+char *partition_type(unsigned char type)
+{
+	int high = sizeof(sys_types) / sizeof(struct systypes),
+		low = 0, mid;
+	uint tmp;
+
+	while (high >= low) {
+		mid = (high + low) >> 1;
+		if ((tmp = sys_types[mid].index) == type)
+			return sys_types[mid].name;
+		else if (tmp < type)
+			low = mid + 1;
+		else high = mid - 1;
+	}
+	return NULL;
+}
+
+void list_types(void)
+{
+	uint last[4], done = 0, next = 0,
+		size = sizeof(sys_types) / sizeof(struct systypes);
+	int 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_types[next].index, sys_types[next].name);
+		next = last[i++] + done;
+		if (i > 3 || next >= last[i]) {
+			i = 0;
+			next = ++done;
+		}
+	} while (done < last[0]);
+	putchar('\n');
+}
+
+void clear_partition(struct partition *p)
+{
+	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;
+	p->start_sect = 0;
+	p->nr_sects = 0;
+}
+
+void set_partition(int i, struct partition *p, uint start, uint stop,
+	int sys, uint offset)
+{
+	p->boot_ind = 0;
+	p->sys_ind = sys;
+	p->start_sect = start - offset;
+	p->nr_sects = 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);
+	changed[i] = 1;
+}
+
+int test_c(char **m, char *mesg)
+{
+	int val = 0;
+	if (!*m)
+		fprintf(stderr, "You must set");
+	else {
+		fprintf(stderr, " %s", *m);
+		val = 1;
+	}
+	*m = mesg;
+	return val;
+}
+
+int warn_geometry(void)
+{
+	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;
+}
+
+uint rounded(uint calcul, uint start)
+{
+	uint i;
+	if (!full_bits)
+		return calcul;
+	while ((i = calcul + full_bits) <= start)
+		calcul = i;
+	return calcul;
+}
+
+void update_units(void)
+{
+	full_bits = 1024 * heads * sectors;
+	if (unit_flag && full_bits)
+		display_factor = full_bits >> 10;
+	else display_factor = 1;
+}
+
+void warn_cylinders(void)
+{
+	update_units();
+	if (cylinders > 1024)
+		fprintf(stderr, "The number of cylinders for this disk is "
+			"set to %d.\nThis is larger than 1024, and may cause "
+			"problems with:\n"
+			"1) software that runs at boot time (e.g., LILO)\n"
+			"2) booting and partitioning software form other OSs\n"
+			"   (e.g., DOS FDISK, OS/2 FDISK)\n",
+			cylinders);
+}
+
+void read_extended(struct partition *p)
+{
+	int i;
+	struct partition *q;
+
+	ext_pointers[ext_index] = part_table[ext_index];
+	if (!p->start_sect)
+		fprintf(stderr, "Bad offset in primary extended partition\n");
+	else while (p->sys_ind == EXTENDED) {
+		if (partitions >= MAXIMUM_PARTS) {
+			fprintf(stderr,
+				"Warning: deleting partitions after %d\n",
+				partitions);
+			clear_partition(ext_pointers[partitions - 1]);
+			changed[partitions - 1] = 1;
+			return;
+		}
+		offsets[partitions] = extended_offset + p->start_sect;
+		if (!extended_offset)
+			extended_offset = p->start_sect;
+		if (ext2_llseek(fd, offsets[partitions]
+			       * SECTOR_SIZE, SEEK_SET) < 0)
+			fatal(unable_to_seek);
+		if (!(buffers[partitions] = (char *) malloc(SECTOR_SIZE)))
+			fatal(out_of_memory);
+		if (SECTOR_SIZE != read(fd, buffers[partitions], SECTOR_SIZE))
+			fatal(unable_to_read);
+		part_table[partitions] = ext_pointers[partitions] = NULL;
+		q = p = offset(buffers[partitions], 0);
+		for (i = 0; i < 4; i++, p++) {
+			if (p->sys_ind == EXTENDED)
+				if (ext_pointers[partitions])
+					fprintf(stderr, "Warning: extra link "
+						"pointer in partition table "
+						"%d\n", partitions + 1);
+				else
+					ext_pointers[partitions] = p;
+			else if (p->sys_ind)
+				if (part_table[partitions])
+					fprintf(stderr,
+						"Warning: ignoring extra data "
+						"in partition table %d\n",
+						partitions + 1);
+				else
+					part_table[partitions] = p;
+		}
+		if (!part_table[partitions])
+			if (q != ext_pointers[partitions])
+				part_table[partitions] = q;
+			else part_table[partitions] = q + 1;
+		if (!ext_pointers[partitions])
+			if (q != part_table[partitions])
+				ext_pointers[partitions] = q;
+			else ext_pointers[partitions] = q + 1;
+		p = ext_pointers[partitions++];
+	}
+}
+
+void get_boot(void)
+{
+	int i;
+	struct hd_geometry geometry;
+
+	partitions = 4;
+	if ((fd = open(disk_device, O_RDWR)) < 0)
+		fatal(unable_to_open);
+	if (SECTOR_SIZE != read(fd, buffer, SECTOR_SIZE))
+		fatal(unable_to_read);
+	if (!ioctl(fd, HDIO_REQ, &geometry)) {
+		heads = geometry.heads;
+		sectors = geometry.sectors;
+		cylinders = geometry.cylinders;
+		if (dos_compatible_flag)
+			sector_offset = sectors;
+		warn_cylinders();
+	}
+	else update_units();
+	warn_geometry();
+
+	for (i = 0; i < 4; i++)
+		if(part_table[i]->sys_ind == EXTENDED)
+			if (partitions != 4)
+				fprintf(stderr, "Ignoring extra extended "
+					"partition %d\n", i + 1);
+			else read_extended(part_table[ext_index = i]);
+
+	for (i = 3; i < partitions; i++)
+		if (*table_check(buffers[i]) != PART_TABLE_FLAG) {
+			fprintf(stderr, "Warning: invalid flag %04x of parti"
+				"tion table %d will be corrected by w(rite)\n",
+				*table_check(buffers[i]), i + 1);
+			changed[i] = 1;
+		}
+}
+
+int read_line(void)
+{
+	if (!fgets(line_buffer, LINE_LENGTH, stdin))
+		return 0;
+	line_ptr = line_buffer;
+	while (*line_ptr && !isgraph(*line_ptr))
+		line_ptr++;
+	return *line_ptr;
+}
+
+char read_char(char *mesg)
+{
+	do
+		fputs(mesg, stdout);
+	while (!read_line());
+	return *line_ptr;
+}
+
+uint read_int(uint low, uint high, char *mesg)
+{
+	uint i;
+	char ms[70];
+	sprintf(ms, "%s (%d-%d): ", mesg, low, high);
+
+	while (1) {
+		while (!isdigit(read_char(ms)) &&
+			(!size_flag || *line_ptr != '+'));
+		if (*line_ptr == '+') {
+			i = atoi(++line_ptr);
+			while (isdigit(*line_ptr))
+				line_ptr++;
+			switch (*line_ptr) {
+				case 'c':
+				case 'C': if (!unit_flag)
+						i *= heads * sectors;
+					break;
+				case 'k':
+				case 'K': i *= 2;
+					i /= display_factor;
+					break;
+				case 'm':
+				case 'M': i *= 2048;
+					i /= display_factor;
+					break;
+				default: break;
+			}
+			i += low;
+		}
+		else i = atoi(line_ptr);
+		if (i >= low && i <= high)
+			break;
+	}
+	size_flag = 0;
+	return i;
+}
+
+int get_partition(int warn, int max)
+{
+	int i = read_int(1, max, "Partition number") - 1;
+
+	if (warn && !part_table[i]->sys_ind)
+		fprintf(stderr, "Warning: partition %d has empty type\n",
+			i + 1);
+	return i;
+}
+
+char *const str_units(void)
+{
+	return unit_flag ? "cylinder" : "sector";
+}
+
+void change_units(void)
+{
+	if (unit_flag = !unit_flag)
+		display_factor = 1;
+	else display_factor = heads * sectors;
+	update_units();
+	printf("Changing display/entry units to %ss\n",
+		str_units());
+}
+
+void toggle_active(int i)
+{
+	struct partition *p = part_table[i];
+
+	if (p->sys_ind == EXTENDED && !p->boot_ind)
+		fprintf(stderr,
+			"WARNING: Partition %d is an extended partition\n",
+			i + 1);
+	if (p->boot_ind)
+		p->boot_ind = 0;
+	else p->boot_ind = ACTIVE_FLAG;
+	changed[i] = 1;
+}
+
+void toggle_dos(void)
+{
+	dos_compatible_flag = ~dos_compatible_flag;
+	printf("DOS Compatibility flag is ");
+	if (dos_compatible_flag)
+		sector_offset = sectors;
+	else {
+		sector_offset = 1;
+		printf("not ");
+	}
+	printf("set\n");
+}
+
+void delete_partition(int i)
+{
+	struct partition *p = part_table[i], *q = ext_pointers[i];
+
+/* Note that for the fifth partition (i == 4) we don't actually
+ * decrement partitions.
+ */
+
+	if (warn_geometry())
+		return;
+	changed[i] = 1;
+	if (i < 4) {
+		if (p->sys_ind == EXTENDED && i == ext_index) {
+			while (partitions > 4)
+				free(buffers[--partitions]);
+			ext_pointers[ext_index] = NULL;
+			extended_offset = 0;
+		}
+		clear_partition(p);
+	}
+	else if (!q->sys_ind && i > 4) {
+		free(buffers[--partitions]);
+		clear_partition(ext_pointers[--i]);
+	}
+	else if (i > 3) {
+		if (i > 4) {
+			p = ext_pointers[i - 1];
+			p->boot_ind = 0;
+			p->head = q->head;
+			p->sector = q->sector;
+			p->cyl = q->cyl;
+			p->sys_ind = EXTENDED;
+			p->end_head = q->end_head;
+			p->end_sector = q->end_sector;
+			p->end_cyl = q->end_cyl;
+			p->start_sect = q->start_sect;
+			p->nr_sects = q->nr_sects;
+			changed[i - 1] = 1;
+		}
+		else {
+			part_table[5]->start_sect +=
+				offsets[5] - extended_offset;
+			offsets[5] = extended_offset;
+			changed[5] = 1;
+		}
+		if (partitions > 5) {
+			partitions--;
+			free(buffers[i]);
+			while (i < partitions) {
+				changed[i] = changed[i + 1];
+				buffers[i] = buffers[i + 1];
+				offsets[i] = offsets[i + 1];
+				part_table[i] = part_table[i + 1];
+				ext_pointers[i] = ext_pointers[i + 1];
+				i++;
+			}
+		}
+		else
+			clear_partition(part_table[i]);
+	}
+}
+
+void change_sysid(void)
+{
+	char *temp;
+	int i = get_partition(0, partitions), sys;
+	struct partition *p = part_table[i];
+
+	if ((sys = p->sys_ind) == EXTENDED)
+		printf("Partition %d is extended.  Delete it\n", i + 1);
+	else if (!sys)
+		printf("Partition %d does not exist yet!\n", i + 1);
+	else while (1) {
+		read_char("Hex code (type L to list codes): ");
+		if (tolower(*line_ptr) == 'l')
+			list_types();
+		else if (isxdigit(*line_ptr)) {
+			sys = 0;
+			do
+				sys = sys << 4 | hex_val(*line_ptr++);
+			while (isxdigit(*line_ptr));
+			if (!sys) {
+				delete_partition(i);
+				break;
+			}
+			else if (sys == EXTENDED) {
+				printf("You may not change a partition "
+					"to be an extended partition\n");
+				break;
+			}
+			else if (sys < 256) {
+				if (sys == p->sys_ind)
+					break;
+				part_table[i]->sys_ind = sys;
+				printf ("Changed system type of partition %d "
+					"to %x (%s)\n", i + 1, sys,
+					(temp = partition_type(sys)) ? temp :
+					"Unknown");
+				changed[i] = 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(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(p->start_sect, &lbc, &lbh, &lbs);
+
+/* compute logical ending (c, h, s) */
+	long2chs(p->start_sect + p->nr_sects - 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);
+	}
+
+/* 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);
+	}
+
+/* Ending on cylinder boundary? */
+	if (peh != (heads - 1) || pes != sectors) {
+		printf("Partition %i does not end on cylinder boundary:\n",
+			partition + 1);
+		printf("     phys=(%d, %d, %d) ", pec, peh, pes);
+		printf("should be (%d, %d, %d)\n",
+		pec, heads - 1, sectors);
+	}
+}
+
+void list_table(void)
+{
+	struct partition *p;
+	char *type;
+	int i, w = strlen(disk_device);
+
+	printf("\nDisk %s: %d heads, %d sectors, %d cylinders\nUnits = "
+		"%ss of %d * 512 bytes\n\n", disk_device, heads, sectors,
+		cylinders, str_units(), display_factor);
+	if (w < 5)
+		w = 5;
+	printf("%*s Boot  Begin   Start     End  Blocks   Id  System\n",
+		w + 1, "Device");
+	for (i = 0 ; i < partitions; i++)
+		if ((p = part_table[i])->sys_ind) {
+			printf("%*s%-2d  %c%8d%8d%8d%8d%c  %2x  %s\n", w,
+			disk_device, i + 1,
+			!p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG
+			? '*' : '?',
+			cround(rounded( calculate(p->head, p->sector, p->cyl),
+				p->start_sect + offsets[i])),
+			cround(p->start_sect + offsets[i]),
+			cround(p->start_sect + offsets[i] + p->nr_sects
+				- (p->nr_sects ? 1: 0)),
+			p->nr_sects / 2, p->nr_sects & 1 ? '+' : ' ',
+			p->sys_ind,
+			(type = partition_type(p->sys_ind)) ?
+			type : "Unknown");
+			check_consistency(p, i);
+		}
+
+}
+
+void x_list_table(int extend)
+{
+	struct partition *p, **q;
+	int i;
+
+	if (extend)
+		q = ext_pointers;
+	else
+		q = part_table;
+	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++)
+		if (p = q[i]) {
+                        printf("%2d %02x%4d%4d%5d%4d%4d%5d%8d%8d %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),
+				p->start_sect, p->nr_sects, p->sys_ind);
+			if (p->sys_ind)
+				check_consistency(p, i);
+		}
+}
+
+void check_bounds(uint *first, uint *last)
+{
+	int i;
+	uint max = 256 * 63 * 1024;
+	struct partition *p = part_table[0];
+
+	for (i = 0; i < partitions; p = part_table[++i])
+		if (!p->sys_ind || p->sys_ind == EXTENDED) {
+			first[i] = max;
+			last[i] = 0;
+		}
+		else {
+			first[i] = rounded(calculate(p->head, p->sector,
+				p->cyl), p->start_sect + offsets[i]);
+			last[i] = p->start_sect + offsets[i] + p->nr_sects - 1;
+		}
+}
+
+void check(int n, uint h, uint s, uint c, uint start)
+{
+	uint total, real_s, real_c, i;
+
+	real_s = sector(s) - 1;
+	real_c = cylinder(s, c);
+	total = (real_c * sectors + real_s) * heads + h;
+	if (full_bits)
+		while ((i = total + full_bits) <= start) {
+			real_c += 1024;
+			total = i;
+		}
+	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 (start != total)
+		fprintf(stderr,
+			"Partition %d: previous sectors %d disagrees with "
+			"total %d\n", n, start, total);
+}
+
+
+void verify(void)
+{
+	int i, j;
+	uint total = 1,
+		first[partitions], last[partitions];
+	struct partition *p = part_table[0];
+
+	if (warn_geometry())
+		return;
+
+	check_bounds(first, last);
+	for (i = 0; i < partitions; p = part_table[++i])
+		if (p->sys_ind && (p->sys_ind != EXTENDED)) {
+			check_consistency(p, i);
+			if (p->start_sect + offsets[i] < 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) {
+		uint e_last = part_table[ext_index]->start_sect +
+			part_table[ext_index]->nr_sects - 1;
+
+		for (p = part_table[i = 4]; i < partitions;
+				p = part_table[++i]) {
+			total++;
+			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)
+		printf("%d unallocated sectors\n", total);
+}
+
+void add_partition(int n, int sys)
+{
+	char mesg[48];
+	int i, read = 0;
+	struct partition *p = part_table[n], *q = part_table[ext_index];
+	uint start, stop = 0, limit, temp,
+		first[partitions], last[partitions];
+
+	if (p->sys_ind) {
+		printf("Partition %d is already defined.  Delete "
+			"it before re-adding it.\n", n + 1);
+		return;
+	}
+	check_bounds(first, last);
+	if (n < 4) {
+		start = sector_offset;
+		limit = heads * sectors * cylinders - 1;
+		if (extended_offset) {
+			first[ext_index] = extended_offset;
+			last[ext_index] = q->start_sect + q->nr_sects - 1;
+		}
+	}
+	else {
+		start = extended_offset + sector_offset;
+		limit = q->start_sect + q->nr_sects - 1;
+	}
+	if (unit_flag)
+		for (i = 0; i < partitions; i++)
+			first[i] = (cround(first[i]) - 1) * display_factor;
+
+	sprintf(mesg, "First %s", str_units());
+	do {
+		temp = start;
+		for (i = 0; i < partitions; i++) {
+			if (start == offsets[i])
+				start += sector_offset;
+			if (start >= first[i] && start <= last[i])
+				if (n < 4)
+					start = last[i] + 1;
+				else
+					start = last[i] + sector_offset;
+		}
+		if (start > limit)
+			break;
+		if (start != temp && read) {
+			printf("Sector %d is already allocated\n", temp);
+			temp = start = stop;
+			read = 0;
+		}
+		if (!read && start == temp) {
+			uint i;
+			temp = 0;
+			start = read_int(cround(i = (stop = start) + (n > 4)),
+				cround(limit), mesg);
+			if (unit_flag) {
+				start = (start - 1) * display_factor;
+				if (start < i) start = i;
+				}
+			read = 1;
+		}
+	} while (start != temp || !read);
+	if (n > 4)			/* NOT for fifth partition */
+		offsets[n] = start - sector_offset;
+
+	for (i = 0; i < partitions; i++) {
+		if (start < offsets[i] && limit >= offsets[i])
+			limit = offsets[i] - 1;
+		if (start < first[i] && limit >= first[i])
+			limit = first[i] - 1;
+	}
+	if (start > limit) {
+		printf("No free sectors available\n");
+		if (n > 4) {
+			free(buffers[n]);
+			partitions--;
+		}
+		return;
+	}
+	if (cround(start) == cround(limit))
+		stop = start;
+	else {
+		sprintf(mesg, "Last %s or +size or +sizeM or +sizeK",
+			str_units());
+		size_flag = 1;
+		stop = read_int(cround(start), cround(limit), mesg);
+		if (unit_flag) {
+			stop = stop * display_factor - 1;
+			if (stop >limit)
+				stop = limit;
+		}
+	}
+
+	set_partition(n, p, start, stop, sys, offsets[n]);
+
+	if (sys == EXTENDED) {
+		ext_index = n;
+		offsets[4] = extended_offset = start;
+		ext_pointers[n] = p;
+		if (!(buffers[4] = calloc(1, SECTOR_SIZE)))
+			fatal(out_of_memory);
+		part_table[4] = offset(buffers[4], 0);
+		ext_pointers[4] = part_table[4] + 1;
+		changed[4] = 1;
+		partitions = 5;
+	}
+	else {
+		if (n > 4)
+			set_partition(n - 1, ext_pointers[n - 1],
+				start - sector_offset, stop, EXTENDED,
+				extended_offset);
+#if 0
+		if ((limit = p->nr_sects) & 1)
+			printf("Warning: partition %d has an odd "
+				"number of sectors.\n", n + 1);
+#endif
+	}
+}
+
+void add_logical(void)
+{
+	if (partitions > 5 || part_table[4]->sys_ind) {
+		if (!(buffers[partitions] = calloc(1, SECTOR_SIZE)))
+			fatal(out_of_memory);
+		part_table[partitions] = offset(buffers[partitions], 0);
+		ext_pointers[partitions] = part_table[partitions] + 1;
+		offsets[partitions] = 0;
+		partitions++;
+	}
+	add_partition(partitions - 1, LINUX_NATIVE);
+}
+
+void new_partition(void)
+{
+	int i, free_primary = 0;
+
+	if (warn_geometry())
+		return;
+	if (partitions >= MAXIMUM_PARTS) {
+		printf("The maximum number of partitions has been created\n");
+		return;
+	}
+
+	for (i = 0; i < 4; i++)
+		free_primary += !part_table[i]->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];
+		sprintf(line, "Command action\n   %s\n   p   primary "
+			"partition (1-4)\n", extended_offset ?
+			"l   logical (5 or over)" : "e   extended");
+		while (1)
+			if ((c = tolower(read_char(line))) == 'p') {
+				add_partition(get_partition(0, 4),
+					LINUX_NATIVE);
+				return;
+			}
+			else if (c == 'l' && extended_offset) {
+				add_logical();
+				return;
+			}
+			else if (c == 'e' && !extended_offset) {
+				add_partition(get_partition(0, 4),
+					EXTENDED);
+				return;
+			}
+	}
+}
+
+void write_table(void)
+{
+	int i, error = 0;
+
+	changed[3] = changed[0] || changed[1] || changed[2] || changed[3];
+	for (i = 3; i < partitions; i++)
+		if (changed[i]) {
+			*table_check(buffers[i]) = PART_TABLE_FLAG;
+			if (ext2_llseek(fd, offsets[i]
+				       * SECTOR_SIZE, SEEK_SET) < 0)
+				fatal(unable_to_seek);
+			if (write(fd, buffers[i], SECTOR_SIZE) != SECTOR_SIZE)
+				fatal(unable_to_write);
+	}
+
+	printf("The partition table has been altered!\n\n");
+
+	printf("Calling ioctl() to re-read partition table.\n"
+	       "(Reboot to ensure the partition table has been updated.)\n");
+	sync();
+	sleep(2);
+	if (i = ioctl(fd, BLKRRPART))
+		error = errno;
+	close(fd);
+
+	printf("Syncing disks.\n");
+	sync();
+	sleep(4);		/* for sync() */
+
+	if (i)
+		printf("Re-read table failed with error %d: %s.\nReboot your "
+			"system to ensure the partition table is updated.\n",
+			error, strerror(error));
+
+	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" );
+
+	exit(0);
+}
+
+#define MAX_PER_LINE	16
+void print_buffer(char buffer[])
+{
+	int	i,
+		l;
+
+	for (i = 0, l = 0; i < SECTOR_SIZE; i++, l++) {
+		if (l == 0)
+			printf("0x%03X:", i);
+		printf(" %02X", (unsigned char) buffer[i]);
+		if (l == MAX_PER_LINE - 1) {
+			printf("\n");
+			l = -1;
+		}
+	}
+	if (l > 0)
+		printf("\n");
+	printf("\n");
+}
+
+void print_raw(void)
+{
+	int i;
+
+	printf("Device: %s\n", disk_device);
+	for (i = 3; i < partitions; i++)
+		print_buffer(buffers[i]);
+}
+
+void move_begin(int i)
+{
+	struct partition *p = part_table[i];
+	uint new, first;
+
+	if (warn_geometry())
+		return;
+	if (!p->sys_ind || !p->nr_sects || p->sys_ind == EXTENDED) {
+		printf("Partition %d has no data area\n", i + 1);
+		return;
+	}
+	first = rounded(calculate(p->head, p->sector, p->cyl), p->start_sect +
+		offsets[i]);
+	new = read_int(first, p->start_sect + p->nr_sects + offsets[i] - 1,
+		"New beginning of data") - offsets[i];
+
+	if (new != p->nr_sects) {
+		first = p->nr_sects + p->start_sect - new;
+		p->nr_sects = first;
+		p->start_sect = new;
+		changed[i] = 1;
+	}
+}
+
+void xselect(void)
+{
+	while(1) {
+		putchar('\n');
+		switch (tolower(read_char("Expert command (m for help): "))) {
+			case 'b': move_begin(get_partition(0, partitions));
+				break;
+			case 'c': cylinders = read_int(1, 65535,
+					"Number of cylinders");
+				warn_cylinders();
+				break;
+			case 'd': print_raw();
+				break;
+			case 'e': x_list_table(1);
+				break;
+			case 'h': heads = read_int(1, 256, "Number of heads");
+				update_units();
+				break;
+			case 'p': x_list_table(0);
+				break;
+			case 'q': close(fd);
+				exit(0);
+			case 'r': return;
+			case 's': sectors = read_int(1, 63,
+					"Number of sectors");
+				if (dos_compatible_flag) {
+					sector_offset = sectors;
+					fprintf(stderr, "Warning: setting "
+						"sector offset for DOS "
+						"compatiblity\n");
+				}
+				update_units();
+				break;
+			case 'w': write_table();
+			default: xmenu();
+		}
+	}
+}
+
+void try(char *device)
+{
+	disk_device = device;
+	if (!setjmp(listingbuf))
+		if ((fd = open(disk_device, O_RDWR)) >= 0) {
+			close(fd);
+			get_boot();
+			list_table();
+			if (partitions > 4)
+				delete_partition(ext_index);
+		}
+}
+
+void main(int argc, char **argv)
+{
+	if (argc > 3)
+		fatal(usage);
+	if (argc > 1 && *argv[1] == '-') {
+		switch (*(argv[1] + 1)) {
+			case 'v':
+				printf("fdisk v" VERSION "\n");
+				exit(0);
+			case 'l':
+				listing = 1;
+				try("/dev/hda");
+				try("/dev/hdb");
+				try("/dev/hdc");
+				try("/dev/hdd");
+				try("/dev/sda");
+				try("/dev/sdb");
+				try("/dev/sdc");
+				try("/dev/sdd");
+				try("/dev/sde");
+				try("/dev/sdf");
+				try("/dev/sdg");
+				try("/dev/sdh");
+				exit(0);
+			case 's': {
+				int i;
+				if (argc < 3)
+					fatal(usage);
+				if (!(i = atoi(argv[2] + 8)))
+					fatal(usage);
+				disk_device = (char *) malloc(9);
+				strncpy(disk_device, argv[2], 8);
+				if ((fd = open(disk_device, O_RDWR)) >= 0) {
+					close(fd);
+					get_boot();
+				if (i > partitions) exit(1);
+				if (part_table[--i]->sys_ind > 10)
+					printf("%d\n",
+						part_table[i]->nr_sects / 2);
+				else exit(1);
+				exit(0);
+			}
+	}
+			default:
+				fatal(usage);
+		}
+	}
+	if (argc > 1)
+		disk_device = argv[argc - 1];
+	else if ((fd = open(DEFAULT_DEVICE, O_RDWR)) < 0)
+		disk_device = ALTERNATE_DEVICE;
+	else close(fd);
+
+	get_boot();
+	if (argc == 1)
+		printf("Using %s as default device!\n", disk_device);
+
+	while (1) {
+		putchar('\n');
+		switch (tolower(read_char("Command (m for help): "))) {
+			case 'a': toggle_active(get_partition(1, partitions));
+				break;
+			case 'c':
+				toggle_dos();
+				break;
+			case 'd': delete_partition(
+					get_partition(1, partitions));
+				break;
+			case 'l': list_types();
+				break;
+			case 'n': new_partition();
+				break;
+			case 'p': list_table();
+				break;
+			case 'q': close(fd);
+				exit(0);
+			case 't': change_sysid();
+				break;
+			case 'u': change_units();
+				break;
+			case 'v': verify();
+				break;
+			case 'w': write_table();
+			case 'x': xselect();
+				break;
+			default: menu();
+		}
+	}
+}