--- util-linux-2.13-pre6/fdisk/fdisk.c.gpt	2005-11-24 15:30:36.000000000 +0100

+++ util-linux-2.13-pre6/fdisk/fdisk.c	2005-11-24 15:30:36.000000000 +0100

@@ -34,6 +34,8 @@

 #include <linux/blkpg.h>

 #endif

+#include "gpt.h"

+

 static void delete_partition(int i);

 #define hex_val(c)	({ \

@@ -2400,6 +2402,14 @@

 }

 static void

+gpt_warning(char *dev)

+{

+	if (gpt_probe_signature_devname(dev))

+		fprintf(stderr, _("\nWARNING: GPT (GUID Partition Table) detected on '%s'! "

+			"The util fdisk doesn't support GPT. Use GNU Parted.\n\n"), dev);

+}

+

+static void

 try(char *device, int user_specified) {

 	int gb;

@@ -2409,6 +2419,7 @@

 	if (!user_specified)

 		if (is_ide_cdrom_or_tape(device))

 			return;

+	gpt_warning(device);

 	if ((fd = open(disk_device, type_open)) >= 0) {

 		gb = get_boot(try_only);

 		if (gb > 0) { /* I/O error */

@@ -2470,6 +2481,8 @@

 	printf(_("%c: unknown command\n"), c);

 }

+

+

 int

 main(int argc, char **argv) {

 	int j, c;

@@ -2574,6 +2587,7 @@

 		for (j = optind; j < argc; j++) {

 			disk_device = argv[j];

+			gpt_warning(disk_device);

 			if ((fd = open(disk_device, type_open)) < 0)

 				fatal(unable_to_open);

 			if (disksize(fd, &size))

@@ -2594,6 +2608,7 @@

 	else

 		fatal(usage2);

+	gpt_warning(disk_device);

 	get_boot(fdisk);

 	if (osf_label) {

--- /dev/null	2005-11-14 15:52:26.044616250 +0100

+++ util-linux-2.13-pre6/fdisk/gpt.h	2005-11-24 15:30:36.000000000 +0100

@@ -0,0 +1,9 @@

+

+#ifndef __GPT_H__

+#define __GPT_H__

+

+extern int gpt_probe_signature_fd(int fd);

+extern int gpt_probe_signature_devname(char *devname);

+

+#endif /* __GPT_H__ */

+

--- util-linux-2.13-pre6/fdisk/Makefile.am.gpt	2005-10-16 14:12:52.000000000 +0200

+++ util-linux-2.13-pre6/fdisk/Makefile.am	2005-11-24 15:31:42.000000000 +0100

@@ -5,13 +5,13 @@

 sbin_PROGRAMS = fdisk

 man_MANS = fdisk.8

 fdisk_SOURCES = fdisk.c disksize.c fdiskbsdlabel.c fdisksgilabel.c \

-	fdisksunlabel.c fdiskaixlabel.c i386_sys_types.c partname.c

+	fdisksunlabel.c fdiskaixlabel.c i386_sys_types.c partname.c gpt.c

 if !SPARC

 sbin_PROGRAMS += sfdisk

 man_MANS += sfdisk.8

-sfdisk_SOURCES = sfdisk.c disksize.c i386_sys_types.c partname.c

+sfdisk_SOURCES = sfdisk.c disksize.c i386_sys_types.c partname.c gpt.c

 if USE_SLANG

 sbin_PROGRAMS += cfdisk

--- util-linux-2.13-pre6/fdisk/fdisk.8.gpt	2005-11-24 15:30:36.000000000 +0100

+++ util-linux-2.13-pre6/fdisk/fdisk.8	2005-11-24 15:30:36.000000000 +0100

@@ -42,6 +42,11 @@

 partition tables.

 It understands DOS type partition tables and BSD or SUN type disklabels.

+.B fdisk 

+doesn't understand GUID Partition Table (GPT) and 

+it is not designed for large partitions. In particular case use more advanced GNU 

+.B parted(8).

+

 The

 .I device

 is usually one of the following:

--- util-linux-2.13-pre6/fdisk/sfdisk.8.gpt	2004-12-31 17:28:30.000000000 +0100

+++ util-linux-2.13-pre6/fdisk/sfdisk.8	2005-11-24 15:30:36.000000000 +0100

@@ -18,6 +18,11 @@

 on a device, check the partitions on a device, and - very dangerous -

 repartition a device.

+.B sfdisk 

+doesn't understand GUID Partition Table (GPT) and 

+it is not designed for large partitions. In particular case use more advanced GNU 

+.B parted(8).

+

 .SS "List Sizes"

 .BI "sfdisk \-s " partition

 gives the size of

--- /dev/null	2005-11-14 15:52:26.044616250 +0100

+++ util-linux-2.13-pre6/fdisk/gpt.c	2005-11-24 15:30:36.000000000 +0100

@@ -0,0 +1,287 @@

+/*

+    GPT (GUID Partition Table) signature detection. Based on libparted and 

+    util-linux/partx.

+  

+    Warning: this code doesn't do all GPT checks (CRC32, Protective MBR, ..). It's

+             really GPT signature detection only.

+    

+    -- Karel Zak <kzak@redhat.com> (Jun-2-2005)

+

+*/

+

+#include <stdio.h>

+#include <string.h>

+#include <stdlib.h>

+#include <inttypes.h>

+#include <sys/stat.h>

+#include <sys/ioctl.h>

+#include <sys/utsname.h>

+#include <sys/types.h>

+#include <fcntl.h>

+#include <unistd.h>

+#include <errno.h>

+#include <linux/fs.h>

+

+#include "gpt.h"

+

+#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

+#define SECTOR_SIZE	512	/* default */

+

+#define _GET_BYTE(x, n)		( ((x) >> (8 * (n))) & 0xff )

+

+#define _PED_SWAP64(x)		( (_GET_BYTE(x, 0) << 56)	\

+				+ (_GET_BYTE(x, 1) << 48)	\

+				+ (_GET_BYTE(x, 2) << 40)	\

+				+ (_GET_BYTE(x, 3) << 32)	\

+				+ (_GET_BYTE(x, 4) << 24)	\

+				+ (_GET_BYTE(x, 5) << 16)	\

+				+ (_GET_BYTE(x, 6) << 8)	\

+				+ (_GET_BYTE(x, 7) << 0) )

+

+#define PED_SWAP64(x)           ((uint64_t) _PED_SWAP64( (uint64_t) (x) ))

+

+#if __BYTE_ORDER == __LITTLE_ENDIAN

+# define CPU_TO_LE64(x)	(x)

+#else

+# define CPU_TO_LE64(x)	PED_SWAP64(x)

+#endif

+

+#define BLKSSZGET  _IO(0x12,104) /* get block device sector size */

+#define BLKGETLASTSECT  _IO(0x12,108)   /* get last sector of block device */

+#define BLKGETSIZE _IO(0x12,96)	/* return device size */

+#define BLKGETSIZE64 _IOR(0x12,114,size_t)	/* return device size in bytes (u64 *arg) */

+

+#define GPT_HEADER_SIGNATURE 0x5452415020494645LL

+#define GPT_PRIMARY_PARTITION_TABLE_LBA 1

+

+typedef struct {

+        uint32_t time_low;

+        uint16_t time_mid;

+        uint16_t time_hi_and_version;

+        uint8_t  clock_seq_hi_and_reserved;

+        uint8_t  clock_seq_low;

+        uint8_t  node[6];

+} /* __attribute__ ((packed)) */ efi_guid_t;

+/* commented out "__attribute__ ((packed))" to work around gcc bug (fixed

+ * in gcc3.1): __attribute__ ((packed)) breaks addressing on initialized

+ * data.  It turns out we don't need it in this case, so it doesn't break

+ * anything :)

+ */

+

+typedef struct _GuidPartitionTableHeader_t {

+	uint64_t Signature;

+	uint32_t Revision;

+	uint32_t HeaderSize;

+	uint32_t HeaderCRC32;

+	uint32_t Reserved1;

+	uint64_t MyLBA;

+	uint64_t AlternateLBA;

+	uint64_t FirstUsableLBA;

+	uint64_t LastUsableLBA;

+	efi_guid_t DiskGUID;

+	uint64_t PartitionEntryLBA;

+	uint32_t NumberOfPartitionEntries;

+	uint32_t SizeOfPartitionEntry;

+	uint32_t PartitionEntryArrayCRC32;

+	uint8_t Reserved2[512 - 92];

+} __attribute__ ((packed)) GuidPartitionTableHeader_t;

+

+struct blkdev_ioctl_param {

+        unsigned int block;

+        size_t content_length;

+        char * block_contents;

+};

+

+static int

+_get_linux_version (void)

+{

+	static int kver = -1;

+	struct utsname uts;

+	int major;

+	int minor;

+	int teeny;

+

+	if (kver != -1)

+		return kver;

+	if (uname (&uts))

+		return kver = 0;

+	if (sscanf (uts.release, "%u.%u.%u", &major, &minor, &teeny) != 3)

+		return kver = 0;

+	return kver = KERNEL_VERSION (major, minor, teeny);

+}

+

+static unsigned int

+_get_sector_size (int fd)

+{

+	unsigned int sector_size;

+

+	if (_get_linux_version() < KERNEL_VERSION (2,3,0))

+		return SECTOR_SIZE;

+	if (ioctl (fd, BLKSSZGET, &sector_size))

+		return SECTOR_SIZE;

+	return sector_size;

+}

+

+static uint64_t

+_get_num_sectors(int fd)

+{

+	int version = _get_linux_version();

+	unsigned long	size;

+	uint64_t bytes=0;

+

+	if (version >= KERNEL_VERSION(2,5,4) || 

+		(version <  KERNEL_VERSION(2,5,0) && 

+		 version >= KERNEL_VERSION (2,4,18)))

+	{

+                if (ioctl(fd, BLKGETSIZE64, &bytes) == 0) 

+                        return bytes / _get_sector_size(fd);

+	}

+	if (ioctl (fd, BLKGETSIZE, &size))

+		return 0;

+	return size;

+}

+

+static uint64_t

+last_lba(int fd)

+{

+	int rc;

+	uint64_t sectors = 0;

+	struct stat s;

+

+	memset(&s, 0, sizeof (s));

+	rc = fstat(fd, &s);

+	if (rc == -1) 

+	{

+		fprintf(stderr, "last_lba() could not stat: %s\n",

+			strerror(errno));

+		return 0;

+	}

+	if (S_ISBLK(s.st_mode))

+		sectors = _get_num_sectors(fd);

+	else 

+	{

+		fprintf(stderr,

+			"last_lba(): I don't know how to handle files with mode %x\n",

+			s.st_mode);

+		sectors = 1;

+	}

+	return sectors - 1;

+}

+

+static ssize_t

+read_lastoddsector(int fd, uint64_t lba, void *buffer, size_t count)

+{

+        int rc;

+        struct blkdev_ioctl_param ioctl_param;

+

+        if (!buffer) return 0; 

+

+        ioctl_param.block = 0; /* read the last sector */

+        ioctl_param.content_length = count;

+        ioctl_param.block_contents = buffer;

+

+        rc = ioctl(fd, BLKGETLASTSECT, &ioctl_param);

+        if (rc == -1) perror("read failed");

+

+        return !rc;

+}

+

+static ssize_t

+read_lba(int fd, uint64_t lba, void *buffer, size_t bytes)

+{

+	int sector_size = _get_sector_size(fd);

+	off_t offset = lba * sector_size;

+        ssize_t bytesread;

+

+	lseek(fd, offset, SEEK_SET);

+	bytesread = read(fd, buffer, bytes);

+

+        /* Kludge.  This is necessary to read/write the last

+           block of an odd-sized disk, until Linux 2.5.x kernel fixes.

+           This is only used by gpt.c, and only to read

+           one sector, so we don't have to be fancy.

+        */

+        if (!bytesread && !(last_lba(fd) & 1) && lba == last_lba(fd))

+                bytesread = read_lastoddsector(fd, lba, buffer, bytes);

+        return bytesread;

+}

+

+static GuidPartitionTableHeader_t *

+alloc_read_gpt_header(int fd, uint64_t lba)

+{

+	GuidPartitionTableHeader_t *gpt = 

+		(GuidPartitionTableHeader_t *) malloc(sizeof (GuidPartitionTableHeader_t));

+	if (!gpt)

+		return NULL;

+	memset(gpt, 0, sizeof (*gpt));

+	if (!read_lba(fd, lba, gpt, sizeof (GuidPartitionTableHeader_t))) 

+	{

+		free(gpt);

+		return NULL;

+	}

+	return gpt;

+}

+

+static int

+gpt_check_signature(int fd, uint64_t lba)

+{

+	GuidPartitionTableHeader_t *gpt;

+	int res=0;

+

+	if ((gpt = alloc_read_gpt_header(fd, lba)))

+	{

+		if (gpt->Signature == CPU_TO_LE64(GPT_HEADER_SIGNATURE))

+			res = 1;

+		free(gpt);

+	}

+	return res;

+}

+

+/* returns:

+ *	0 not found GPT

+ * 	1 for valid primary GPT header

+ *	2 for valid alternative GPT header

+ */

+int

+gpt_probe_signature_fd(int fd)

+{

+	int res = 0;

+

+	/* check primary GPT header */	

+	if (gpt_check_signature(fd, GPT_PRIMARY_PARTITION_TABLE_LBA))

+		res = 1;

+	else

+	{

+		/* check alternative GPT header */

+		uint64_t lastlba = last_lba(fd);

+        	if (gpt_check_signature(fd, lastlba))

+			res = 2;

+	}

+	return res;

+}

+

+int

+gpt_probe_signature_devname(char *devname)

+{

+	int res, fd;

+	if ((fd = open(devname, O_RDONLY)) < 0)

+		return 0;

+	res = gpt_probe_signature_fd(fd);

+	close(fd);

+	return res;

+}

+

+#ifdef GPT_TEST_MAIN

+int

+main(int argc, char **argv)

+{

+	if (argc!=2)

+	{

+		fprintf(stderr, "usage: %s <dev>\n", argv[0]);

+		exit(EXIT_FAILURE);

+	}

+	if (gpt_probe_signature_devname(argv[1]))

+		printf("GPT (GUID Partition Table) detected on %s\n", argv[1]);

+	exit(EXIT_SUCCESS);

+}

+#endif

--- util-linux-2.13-pre6/fdisk/sfdisk.c.gpt	2005-10-16 14:18:32.000000000 +0200

+++ util-linux-2.13-pre6/fdisk/sfdisk.c	2005-11-24 15:30:36.000000000 +0100

@@ -50,6 +50,8 @@

 #include "nls.h"

 #include "common.h"

+#include "gpt.h"

+

 #define SIZE(a)	(sizeof(a)/sizeof(a[0]))

 /*

@@ -2457,6 +2459,23 @@

 	return NULL;

 }	

+static void

+gpt_warning(char *dev, int warn_only)

+{

+	if (force)

+		warn_only = 1;

+	

+	if (gpt_probe_signature_devname(dev)) {

+		fflush(stdout);

+		fprintf(stderr, _("\nWARNING: GPT (GUID Partition Table) detected on '%s'! "

+			"The util sfdisk doesn't support GPT. Use GNU Parted.\n\n"), dev);

+		if (!warn_only) {

+			fprintf(stderr, _("Use the --force flag to overrule this check.\n"));

+			exit(1);

+		}

+	}

+}

+

 static void do_list(char *dev, int silent);

 static void do_size(char *dev, int silent);

 static void do_geom(char *dev, int silent);

@@ -2602,6 +2621,7 @@

 	while ((dev = nextproc()) != NULL) {

 	    if (is_ide_cdrom_or_tape(dev))

 		continue;

+	    gpt_warning(dev, 1);

 	    if (opt_out_geom)

 		do_geom(dev, 1);

 	    if (opt_out_pt_geom)

@@ -2629,6 +2649,7 @@

     if (opt_list || opt_out_geom || opt_out_pt_geom || opt_size || verify) {

 	while (optind < argc) {

+	    gpt_warning(argv[optind], 1);

 	    if (opt_out_geom)

 	      do_geom(argv[optind], 0);

 	    if (opt_out_pt_geom)

@@ -2657,6 +2678,7 @@

 	  fatal(_("usage: sfdisk --change-id device partition-number Id\n"));

 	else if (optind != argc-3 && optind != argc-2)

 	  fatal(_("usage: sfdisk --id device partition-number [Id]\n"));

+	gpt_warning(argv[optind], 0);

 	do_change_id(argv[optind], argv[optind+1],

 		     (optind == argc-2) ? 0 : argv[optind+2]);

 	exit(exit_status);

@@ -2666,6 +2688,8 @@

       fatal(_("can specify only one device (except with -l or -s)\n"));

     dev = argv[optind];

+    gpt_warning(dev, 0);

+    

     if (opt_reread)

       do_reread(dev);

     else if (restore_sector_file)

@@ -2842,6 +2866,8 @@

     z = &old;;

+    gpt_warning(dev, 0);

+    

     rw = (!no_write && (arg || ac > 1));

     fd = my_open(dev, rw, 0);

@@ -2943,6 +2969,8 @@

     z = &old;;

+    gpt_warning(dev, 0);

+    

     rw = !no_write;

     fd = my_open(dev, rw, 0);