From 61b3a9733c0e0a79ccc43096642d378c8706add6 Mon Sep 17 00:00:00 2001

From: Arvin Schnell <aschnell@suse.com>

Date: Wed, 11 May 2022 14:02:21 +0000

Subject: [PATCH 2/5] parted: add type command

Include the partition type-id and type-uuid in the JSON

output. Also add the the command 'type' to set them. Remove

redundant flags from DosPartitionData and use only the system

variable.

Signed-off-by: Brian C. Lane <bcl@redhat.com>

---

 NEWS                                  |   3 +

 doc/C/parted.8                        |   5 +

 doc/parted.texi                       |  20 +

 include/parted/disk.in.h              |  23 +-

 libparted/disk.c                      | 102 +++++

 libparted/labels/dasd.c               |   4 +

 libparted/labels/dos.c                | 621 ++++++++++++--------------

 libparted/labels/gpt.c                |  44 +-

 parted/parted.c                       | 113 ++++-

 tests/Makefile.am                     |   4 +

 tests/t0800-json-gpt.sh               |   2 +

 tests/t0801-json-msdos.sh             |   5 +-

 tests/t0900-type-gpt.sh               |  69 +++

 tests/t0901-type-gpt-invalid.sh       |  35 ++

 tests/t0910-type-dos.sh               |  69 +++

 tests/t0911-type-dos-invalid.sh       |  35 ++

 tests/t2400-dos-hfs-partition-type.sh |   2 +-

 tests/t3300-palo-prep.sh              |   8 +-

 tests/t3310-flags.sh                  |   4 +

 19 files changed, 825 insertions(+), 343 deletions(-)

 create mode 100755 tests/t0900-type-gpt.sh

 create mode 100755 tests/t0901-type-gpt-invalid.sh

 create mode 100755 tests/t0910-type-dos.sh

 create mode 100755 tests/t0911-type-dos-invalid.sh

diff --git a/NEWS b/NEWS

index 2bd161f..099f8bd 100644

--- a/NEWS

+++ b/NEWS

@@ -2,6 +2,9 @@ GNU parted NEWS                                    -*- outline -*-

 * Noteworthy changes in release ?.? (????-??-??) [?]

+** New Features

+

+  Add type commands to set type-id on MS-DOS and type-uuid on GPT.

 * Noteworthy changes in release 3.5 (2022-04-18) [stable]

diff --git a/doc/C/parted.8 b/doc/C/parted.8

index 7895440..ab34be7 100644

--- a/doc/C/parted.8

+++ b/doc/C/parted.8

@@ -134,6 +134,11 @@ human-friendly form for output).

 .B toggle \fIpartition\fP \fIflag\fP

 Toggle the state of \fIflag\fP on \fIpartition\fP.

 .TP

+.B type \fIpartition\fP \fIid\fP or \fIuuid\fP

+On MS-DOS set the type aka. partition id of \fIpartition\fP to

+\fIid\fP. The \fIid\fP is a value between "0x01" and "0xff". On GPT

+the type-uuid of \fIpartition\fP to \fIuuid\fP.

+.TP

 .B disk_set \fIflag\fP \fIstate\fP

 Change a \fIflag\fP on the disk to \fIstate\fP. A flag can be either "on" or "off".

 Some or all of these flags will be available, depending on what disk label you

diff --git a/doc/parted.texi b/doc/parted.texi

index 8a3978a..9c9d282 100644

--- a/doc/parted.texi

+++ b/doc/parted.texi

@@ -466,6 +466,7 @@ GNU Parted provides the following commands:

 * select::

 * set::

 * toggle::

+* type::

 * unit::

 @end menu

@@ -1034,6 +1035,25 @@ Toggle the state of @var{flag} on partition @var{number}.

 @end deffn

+@node type

+@subsection type

+@cindex type, command description

+@cindex command description, type

+

+@deffn Command type @var{number} @var{id} or @var{uuid}

+

+On MS-DOS set the type-id aka partition id to @var{id} on partition

+@var{number}. The id is a value between 0x01 and 0xff, e.g. the ID for

+Linux is 0x83. A list with some IDs is available at

+@uref{https://en.wikipedia.org/wiki/Partition_type}.

+

+On GPT set the type-uuid to @var{uuid} on partition

+@var{number}. E.g. the UUID for Linux is

+0fc63daf-8483-4772-8e79-3d69d8477de4. A list with some UUIDs is availabe

+at @uref{https://en.wikipedia.org/wiki/GUID_Partition_Table}.

+

+@end deffn

+

 @node unit

 @subsection unit

 @cindex unit, command description

diff --git a/include/parted/disk.in.h b/include/parted/disk.in.h

index 38e869d..672c4ee 100644

--- a/include/parted/disk.in.h

+++ b/include/parted/disk.in.h

@@ -32,6 +32,7 @@

  */

 #include <stdlib.h>

 #include <unistd.h>

+#include <stdint.h>

 /**

  * Disk flags

@@ -91,11 +92,13 @@ enum _PedPartitionFlag {

 #define PED_PARTITION_LAST_FLAG         PED_PARTITION_LINUX_HOME

 enum _PedDiskTypeFeature {

-        PED_DISK_TYPE_EXTENDED=1,       /**< supports extended partitions */

-        PED_DISK_TYPE_PARTITION_NAME=2  /**< supports partition names */

+        PED_DISK_TYPE_EXTENDED=1,             /**< supports extended partitions */

+        PED_DISK_TYPE_PARTITION_NAME=2,       /**< supports partition names */

+        PED_DISK_TYPE_PARTITION_TYPE_ID=4,    /**< supports partition type-ids */

+        PED_DISK_TYPE_PARTITION_TYPE_UUID=8,  /**< supports partition type-uuids */

 };

 #define PED_DISK_TYPE_FIRST_FEATURE    PED_DISK_TYPE_EXTENDED

-#define PED_DISK_TYPE_LAST_FEATURE     PED_DISK_TYPE_PARTITION_NAME

+#define PED_DISK_TYPE_LAST_FEATURE     PED_DISK_TYPE_PARTITION_TYPE_UUID

 struct _PedDisk;

 struct _PedPartition;

@@ -247,6 +250,13 @@ struct _PedDiskOps {

                 PedPartitionFlag flag);

         void (*partition_set_name) (PedPartition* part, const char* name);

         const char* (*partition_get_name) (const PedPartition* part);

+

+        int (*partition_set_type_id) (PedPartition* part, uint8_t id);

+        uint8_t (*partition_get_type_id) (const PedPartition* part);

+

+        int (*partition_set_type_uuid) (PedPartition* part, const uint8_t* uuid);

+        uint8_t* (*partition_get_type_uuid) (const PedPartition* part);

+

         int (*partition_align) (PedPartition* part,

                                 const PedConstraint* constraint);

         int (*partition_enumerate) (PedPartition* part);

@@ -347,6 +357,13 @@ extern int ped_partition_set_system (PedPartition* part,

                                      const PedFileSystemType* fs_type);

 extern int ped_partition_set_name (PedPartition* part, const char* name);

 extern const char* ped_partition_get_name (const PedPartition* part);

+

+extern int ped_partition_set_type_id (PedPartition* part, uint8_t id);

+extern uint8_t ped_partition_get_type_id (const PedPartition* part);

+

+extern int ped_partition_set_type_uuid (PedPartition* part, const uint8_t* uuid);

+extern uint8_t* ped_partition_get_type_uuid (const PedPartition* part);

+

 extern int ped_partition_is_busy (const PedPartition* part);

 extern char* ped_partition_get_path (const PedPartition* part);

diff --git a/libparted/disk.c b/libparted/disk.c

index 3bf7634..22dff36 100644

--- a/libparted/disk.c

+++ b/libparted/disk.c

@@ -1458,6 +1458,36 @@ _assert_partition_name_feature (const PedDiskType* disk_type)

 	return 1;

 }

+static int

+_assert_partition_type_id_feature (const PedDiskType* disk_type)

+{

+        if (!ped_disk_type_check_feature (

+                        disk_type, PED_DISK_TYPE_PARTITION_TYPE_ID)) {

+                ped_exception_throw (

+                        PED_EXCEPTION_ERROR,

+                        PED_EXCEPTION_CANCEL,

+                        "%s disk labels do not support partition type-ids.",

+                        disk_type->name);

+                return 0;

+        }

+        return 1;

+}

+

+static int

+_assert_partition_type_uuid_feature (const PedDiskType* disk_type)

+{

+        if (!ped_disk_type_check_feature (

+                        disk_type, PED_DISK_TYPE_PARTITION_TYPE_UUID)) {

+                ped_exception_throw (

+                        PED_EXCEPTION_ERROR,

+                        PED_EXCEPTION_CANCEL,

+                        "%s disk labels do not support partition type-uuids.",

+                        disk_type->name);

+                return 0;

+        }

+        return 1;

+}

+

 /**

  * Sets the name of a partition.

  *

@@ -1510,6 +1540,78 @@ ped_partition_get_name (const PedPartition* part)

 	return part->disk->type->ops->partition_get_name (part);

 }

+/**

+ * Set the type-id of the partition \p part. This will only work if the disk label

+ * supports it.

+ */

+int

+ped_partition_set_type_id (PedPartition *part, uint8_t id)

+{

+        PED_ASSERT (part != NULL);

+        PED_ASSERT (part->disk != NULL);

+        PED_ASSERT (ped_partition_is_active (part));

+

+        if (!_assert_partition_type_id_feature (part->disk->type))

+                return 0;

+

+        PED_ASSERT (part->disk->type->ops->partition_set_type_id != NULL);

+        return part->disk->type->ops->partition_set_type_id (part, id);

+}

+

+/**

+ * Get the type-id of the partition \p part. This will only work if the disk label

+ * supports it.

+ */

+uint8_t

+ped_partition_get_type_id (const PedPartition *part)

+{

+        PED_ASSERT (part != NULL);

+        PED_ASSERT (part->disk != NULL);

+        PED_ASSERT (ped_partition_is_active (part));

+

+        if (!_assert_partition_type_id_feature (part->disk->type))

+                return 0;

+

+        PED_ASSERT (part->disk->type->ops->partition_set_type_id != NULL);

+        return part->disk->type->ops->partition_get_type_id (part);

+}

+

+/**

+ * Set the type-uuid of the partition \p part. This will only work if the disk label

+ * supports it.

+ */

+int

+ped_partition_set_type_uuid (PedPartition *part, const uint8_t* uuid)

+{

+        PED_ASSERT (part != NULL);

+        PED_ASSERT (part->disk != NULL);

+        PED_ASSERT (ped_partition_is_active (part));

+

+        if (!_assert_partition_type_uuid_feature (part->disk->type))

+                return 0;

+

+        PED_ASSERT (part->disk->type->ops->partition_set_type_uuid != NULL);

+        return part->disk->type->ops->partition_set_type_uuid (part, uuid);

+}

+

+/**

+ * Get the type-uuid of the partition \p part. This will only work if the disk label

+ * supports it.

+ */

+uint8_t*

+ped_partition_get_type_uuid (const PedPartition *part)

+{

+        PED_ASSERT (part != NULL);

+        PED_ASSERT (part->disk != NULL);

+        PED_ASSERT (ped_partition_is_active (part));

+

+        if (!_assert_partition_type_uuid_feature (part->disk->type))

+                return NULL;

+

+        PED_ASSERT (part->disk->type->ops->partition_set_type_uuid != NULL);

+        return part->disk->type->ops->partition_get_type_uuid (part);

+}

+

 /** @} */

 /**

diff --git a/libparted/labels/dasd.c b/libparted/labels/dasd.c

index 38f2b00..0c00c4f 100644

--- a/libparted/labels/dasd.c

+++ b/libparted/labels/dasd.c

@@ -117,6 +117,10 @@ static PedDiskOps dasd_disk_ops = {

 	partition_set_name:	NULL,

 	partition_get_name:	NULL,

+	partition_set_type_id:          NULL,

+	partition_get_type_id:          NULL,

+	partition_set_type_uuid:	NULL,

+	partition_get_type_uuid:	NULL,

 	get_partition_alignment: dasd_get_partition_alignment,

diff --git a/libparted/labels/dos.c b/libparted/labels/dos.c

index 26d8804..bd7465d 100644

--- a/libparted/labels/dos.c

+++ b/libparted/labels/dos.c

@@ -100,6 +100,209 @@ static const char MBR_BOOT_CODE[] = {

 #define PARTITION_LINUX_RAID	0xfd

 #define PARTITION_LINUX_LVM_OLD 0xfe

+struct flag_id_mapping_t

+{

+    enum _PedPartitionFlag flag;

+    unsigned char type_id;

+    unsigned char alt_type_id;

+};

+

+static const struct flag_id_mapping_t flag_id_mapping[] =

+{

+    { PED_PARTITION_BLS_BOOT,           PARTITION_BLS_BOOT },

+    { PED_PARTITION_DIAG,               PARTITION_COMPAQ_DIAG, PARTITION_DELL_DIAG },

+    { PED_PARTITION_ESP,                PARTITION_ESP },

+    { PED_PARTITION_IRST,               PARTITION_IRST },

+    { PED_PARTITION_LVM,                PARTITION_LINUX_LVM, PARTITION_LINUX_LVM_OLD },

+    { PED_PARTITION_MSFT_RESERVED,      PARTITION_MSFT_RECOVERY },

+    { PED_PARTITION_PALO,               PARTITION_PALO },

+    { PED_PARTITION_PREP,               PARTITION_PREP },

+    { PED_PARTITION_RAID,               PARTITION_LINUX_RAID },

+    { PED_PARTITION_SWAP,               PARTITION_LINUX_SWAP },

+};

+

+static const struct flag_id_mapping_t* _GL_ATTRIBUTE_CONST

+dos_find_flag_id_mapping (PedPartitionFlag flag)

+{

+    int n = sizeof(flag_id_mapping) / sizeof(flag_id_mapping[0]);

+

+    for (int i = 0; i < n; ++i)

+	if (flag_id_mapping[i].flag == flag)

+	    return &flag_id_mapping[i];

+

+    return NULL;

+}

+

+/**

+ * Check whether the type_id supports the hidden flag. Returns true for both hidden and

+ * non-hidden id.

+ */

+static bool

+dos_type_id_supports_hidden(unsigned char type_id)

+{

+    switch (type_id)

+    {

+	case PARTITION_DOS_EXT:

+	case PARTITION_DOS_EXT_H:

+	case PARTITION_FAT12:

+	case PARTITION_FAT12_H:

+	case PARTITION_FAT16:

+	case PARTITION_FAT16_H:

+	case PARTITION_FAT16_LBA:

+	case PARTITION_FAT16_LBA_H:

+	case PARTITION_FAT16_SM:

+	case PARTITION_FAT16_SM_H:

+	case PARTITION_FAT32:

+	case PARTITION_FAT32_H:

+	case PARTITION_FAT32_LBA:

+	case PARTITION_FAT32_LBA_H:

+	case PARTITION_NTFS:

+	case PARTITION_NTFS_H:

+	    return true;

+

+	default:

+	    return false;

+    }

+}

+

+/**

+ * Check whether the type_id has the hidden flag set.

+ */

+static bool

+dos_type_id_is_hidden(unsigned char type_id)

+{

+    switch (type_id)

+    {

+	case PARTITION_DOS_EXT_H:

+	case PARTITION_FAT12_H:

+	case PARTITION_FAT16_H:

+	case PARTITION_FAT16_LBA_H:

+	case PARTITION_FAT16_SM_H:

+	case PARTITION_FAT32_H:

+	case PARTITION_FAT32_LBA_H:

+	case PARTITION_NTFS_H:

+	    return true;

+

+	default:

+	    return false;

+    }

+}

+

+/**

+ * Sets the hidden flag on type_id.

+ */

+static bool

+dos_type_id_set_hidden(unsigned char* type_id, bool state)

+{

+    PED_ASSERT (type_id);

+

+    if (!dos_type_id_supports_hidden(*type_id))

+	return false;

+

+    if (state)

+	*type_id |= PART_FLAG_HIDDEN;

+    else

+	*type_id &= ~PART_FLAG_HIDDEN;

+

+    return 1;

+}

+

+/**

+ * Check whether the type_id supports the lba flag. Returns true for both lba and non-lba

+ * id.

+ */

+static bool

+dos_type_id_supports_lba(unsigned char type_id)

+{

+    switch (type_id)

+    {

+	case PARTITION_FAT16:

+	case PARTITION_FAT16_H:

+	case PARTITION_FAT16_LBA:

+	case PARTITION_FAT16_LBA_H:

+	case PARTITION_FAT32:

+	case PARTITION_FAT32_H:

+	case PARTITION_FAT32_LBA:

+	case PARTITION_FAT32_LBA_H:

+	case PARTITION_DOS_EXT:

+	case PARTITION_EXT_LBA:

+	    return true;

+

+	default:

+	    return false;

+    }

+}

+

+/**

+ * Check whether the type_id has the lba flag set.

+ */

+static bool

+dos_type_id_is_lba(unsigned char type_id)

+{

+    switch (type_id)

+    {

+	case PARTITION_FAT16_LBA:

+	case PARTITION_FAT16_LBA_H:

+	case PARTITION_FAT32_LBA:

+	case PARTITION_FAT32_LBA_H:

+	case PARTITION_EXT_LBA:

+	    return true;

+

+	default:

+	    return false;

+    }

+}

+

+/**

+ * Sets the lba flag on type_id.

+ */

+static bool

+dos_type_id_set_lba(unsigned char* type_id, bool state)

+{

+    PED_ASSERT (type_id);

+

+    if (!dos_type_id_supports_lba(*type_id))

+	return false;

+

+    if (state)

+    {

+	switch (*type_id)

+	{

+	    case PARTITION_FAT16:

+		*type_id = PARTITION_FAT16_LBA;

+		break;

+

+	    case PARTITION_FAT32:

+		*type_id = PARTITION_FAT32_LBA;

+		break;

+

+	    case PARTITION_DOS_EXT:

+		*type_id = PARTITION_EXT_LBA;

+		break;

+	}

+    }

+    else

+    {

+	switch (*type_id)

+	{

+	    case PARTITION_FAT16_LBA:

+		*type_id = PARTITION_FAT16;

+		break;

+

+	    case PARTITION_FAT32_LBA:

+		*type_id = PARTITION_FAT32;

+		break;

+

+	    case PARTITION_EXT_LBA:

+		*type_id = PARTITION_DOS_EXT;

+		break;

+	}

+    }

+

+    return true;

+}

+

+

 /* This constant contains the maximum cylinder number that can be represented

  * in (C,H,S) notation.  Higher cylinder numbers are reserved for

  * "too big" indicators (in which case only LBA addressing can be used).

@@ -156,18 +359,6 @@ typedef struct {

 typedef struct {

 	unsigned char	system;

 	int		boot;

-	int		hidden;

-	int		msftres;

-	int		raid;

-	int		lvm;

-	int		swap;

-	int		lba;

-	int		palo;

-	int		prep;

-	int		diag;

-	int		irst;

-	int		esp;

-	int		bls_boot;

 	OrigState*	orig;			/* used for CHS stuff */

 } DosPartitionData;

@@ -891,48 +1082,6 @@ raw_part_is_extended (const DosRawPartition* raw_part)

 	return 0;

 }

-static int _GL_ATTRIBUTE_PURE

-raw_part_is_hidden (const DosRawPartition* raw_part)

-{

-	PED_ASSERT (raw_part != NULL);

-

-	switch (raw_part->type) {

-	case PARTITION_FAT12_H:

-	case PARTITION_FAT16_SM_H:

-	case PARTITION_FAT16_H:

-	case PARTITION_FAT32_H:

-	case PARTITION_NTFS_H:

-	case PARTITION_FAT32_LBA_H:

-	case PARTITION_FAT16_LBA_H:

-		return 1;

-

-	default:

-		return 0;

-	}

-

-	return 0;

-}

-

-static int _GL_ATTRIBUTE_PURE

-raw_part_is_lba (const DosRawPartition* raw_part)

-{

-	PED_ASSERT (raw_part != NULL);

-

-	switch (raw_part->type) {

-	case PARTITION_FAT32_LBA:

-	case PARTITION_FAT16_LBA:

-	case PARTITION_EXT_LBA:

-	case PARTITION_FAT32_LBA_H:

-	case PARTITION_FAT16_LBA_H:

-		return 1;

-

-	default:

-		return 0;

-	}

-

-	return 0;

-}

-

 static PedPartition*

 raw_part_parse (const PedDisk* disk, const DosRawPartition* raw_part,

 	        PedSector lba_offset, PedPartitionType type)

@@ -952,20 +1101,6 @@ raw_part_parse (const PedDisk* disk, const DosRawPartition* raw_part,

 	dos_data = part->disk_specific;

 	dos_data->system = raw_part->type;

 	dos_data->boot = raw_part->boot_ind != 0;

-	dos_data->diag = raw_part->type == PARTITION_COMPAQ_DIAG ||

-			 raw_part->type == PARTITION_DELL_DIAG;

-	dos_data->msftres = raw_part->type == PARTITION_MSFT_RECOVERY;

-	dos_data->hidden = raw_part_is_hidden (raw_part);

-	dos_data->raid = raw_part->type == PARTITION_LINUX_RAID;

-	dos_data->lvm = raw_part->type == PARTITION_LINUX_LVM_OLD

-			|| raw_part->type == PARTITION_LINUX_LVM;

-	dos_data->swap = raw_part->type == PARTITION_LINUX_SWAP;

-	dos_data->lba = raw_part_is_lba (raw_part);

-	dos_data->palo = raw_part->type == PARTITION_PALO;

-	dos_data->prep = raw_part->type == PARTITION_PREP;

-	dos_data->irst = raw_part->type == PARTITION_IRST;

-	dos_data->esp = raw_part->type == PARTITION_ESP;

-	dos_data->bls_boot = raw_part->type == PARTITION_BLS_BOOT;

 	dos_data->orig = ped_malloc (sizeof (OrigState));

 	if (!dos_data->orig) {

 		ped_partition_destroy (part);

@@ -1377,18 +1512,6 @@ msdos_partition_duplicate (const PedPartition* part)

 	new_dos_data = (DosPartitionData*) new_part->disk_specific;

 	new_dos_data->system = old_dos_data->system;

 	new_dos_data->boot = old_dos_data->boot;

-	new_dos_data->diag = old_dos_data->diag;

-	new_dos_data->hidden = old_dos_data->hidden;

-	new_dos_data->msftres = old_dos_data->msftres;

-	new_dos_data->raid = old_dos_data->raid;

-	new_dos_data->lvm = old_dos_data->lvm;

-	new_dos_data->swap = old_dos_data->swap;

-	new_dos_data->lba = old_dos_data->lba;

-	new_dos_data->palo = old_dos_data->palo;

-	new_dos_data->prep = old_dos_data->prep;

-	new_dos_data->irst = old_dos_data->irst;

-	new_dos_data->esp = old_dos_data->esp;

-	new_dos_data->bls_boot = old_dos_data->bls_boot;

 	if (old_dos_data->orig) {

 		new_dos_data->orig = ped_malloc (sizeof (OrigState));

@@ -1425,234 +1548,87 @@ msdos_partition_set_system (PedPartition* part,

 	part->fs_type = fs_type;

-	if (dos_data->hidden

-		    && fs_type

-		    && strncmp (fs_type->name, "fat", 3) != 0

-		    && strcmp (fs_type->name, "ntfs") != 0)

-		dos_data->hidden = 0;

-

-	if (dos_data->msftres

-		    && fs_type

-		    && strcmp (fs_type->name, "ntfs") != 0)

-		dos_data->msftres = 0;

-

 	if (part->type & PED_PARTITION_EXTENDED) {

-		dos_data->diag = 0;

-		dos_data->raid = 0;

-		dos_data->lvm = 0;

-		dos_data->swap = 0;

-		dos_data->palo = 0;

-		dos_data->prep = 0;

-		dos_data->irst = 0;

-		dos_data->esp = 0;

-		if (dos_data->lba)

-			dos_data->system = PARTITION_EXT_LBA;

-		else

-			dos_data->system = PARTITION_DOS_EXT;

-		return 1;

-	}

-

-	if (dos_data->diag) {

-		/* Don't change the system if it already is a diag type,

-		   otherwise use Compaq as almost all vendors use that. */

-		if (dos_data->system != PARTITION_COMPAQ_DIAG &&

-		    dos_data->system != PARTITION_DELL_DIAG)

-			dos_data->system = PARTITION_COMPAQ_DIAG;

-		return 1;

-	}

-	if (dos_data->msftres) {

-		dos_data->system = PARTITION_MSFT_RECOVERY;

-		return 1;

-	}

-	if (dos_data->lvm) {

-		dos_data->system = PARTITION_LINUX_LVM;

-		return 1;

-	}

-	if (dos_data->swap) {

-		dos_data->system = PARTITION_LINUX_SWAP;

-		return 1;

-	}

-	if (dos_data->raid) {

-		dos_data->system = PARTITION_LINUX_RAID;

-		return 1;

-	}

-	if (dos_data->palo) {

-		dos_data->system = PARTITION_PALO;

-		return 1;

-	}

-	if (dos_data->prep) {

-		dos_data->system = PARTITION_PREP;

-		return 1;

-	}

-	if (dos_data->irst) {

-		dos_data->system = PARTITION_IRST;

-		return 1;

-	}

-	if (dos_data->esp) {

-		dos_data->system = PARTITION_ESP;

-		return 1;

-	}

-	if (dos_data->bls_boot) {

-		dos_data->system = PARTITION_BLS_BOOT;

+		dos_data->system = PARTITION_EXT_LBA;

 		return 1;

 	}

 	if (!fs_type)

 		dos_data->system = PARTITION_LINUX;

-	else if (!strcmp (fs_type->name, "fat16")) {

-		dos_data->system = dos_data->lba

-				   ? PARTITION_FAT16_LBA : PARTITION_FAT16;

-		dos_data->system |= dos_data->hidden ? PART_FLAG_HIDDEN : 0;

-	} else if (!strcmp (fs_type->name, "fat32")) {

-		dos_data->system = dos_data->lba

-				   ? PARTITION_FAT32_LBA : PARTITION_FAT32;

-		dos_data->system |= dos_data->hidden ? PART_FLAG_HIDDEN : 0;

-	} else if (!strcmp (fs_type->name, "ntfs")

-		   || !strcmp (fs_type->name, "hpfs")) {

+	else if (!strcmp (fs_type->name, "fat16"))

+		dos_data->system = PARTITION_FAT16;

+	else if (!strcmp (fs_type->name, "fat32"))

+		dos_data->system = PARTITION_FAT32;

+	else if (!strcmp (fs_type->name, "ntfs")

+		   || !strcmp (fs_type->name, "hpfs"))

 		dos_data->system = PARTITION_NTFS;

-		dos_data->system |= dos_data->hidden ? PART_FLAG_HIDDEN : 0;

-	} else if (!strcmp (fs_type->name, "hfs")

+	else if (!strcmp (fs_type->name, "hfs")

 		   || !strcmp (fs_type->name, "hfs+"))