Index: uspace/lib/c/generic/uuid.c
===================================================================
--- uspace/lib/c/generic/uuid.c	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/c/generic/uuid.c	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -36,4 +36,5 @@
 #include <uuid.h>
 #include <stdlib.h>
+#include <str.h>
 
 /** Generate UUID.
@@ -87,4 +88,87 @@
 }
 
+/** Parse string UUID.
+ *
+ * If @a endptr is not NULL, it is set to point to the first character
+ * following the UUID. If @a endptr is NULL, the string must not contain
+ * any characters following the UUID, otherwise an error is returned.
+ *
+ * @param str    String beginning with UUID string representation
+ * @param uuid   Place to store UUID
+ * @param endptr Place to store pointer to end of UUID or @c NULL
+ *
+ * @return EOK on success or negative error code
+ */
+int uuid_parse(const char *str, uuid_t *uuid, const char **endptr)
+{
+	int rc;
+	const char *eptr;
+	uint32_t time_low;
+	uint16_t time_mid;
+	uint16_t time_ver;
+	uint16_t clock;
+	uint64_t node;
+	int i;
+
+	rc = str_uint32_t(str, &eptr, 16, false, &time_low);
+	if (rc != EOK || eptr != str + 8 || *eptr != '-')
+		return EINVAL;
+
+	rc = str_uint16_t(str + 9, &eptr, 16, false, &time_mid);
+	if (rc != EOK || eptr != str + 13 || *eptr != '-')
+		return EINVAL;
+
+	rc = str_uint16_t(str + 14, &eptr, 16, false, &time_ver);
+	if (rc != EOK || eptr != str + 18 || *eptr != '-')
+		return EINVAL;
+
+	rc = str_uint16_t(str + 19, &eptr, 16, false, &clock);
+	if (rc != EOK || eptr != str + 23 || *eptr != '-')
+		return EINVAL;
+
+	rc = str_uint64_t(str + 24, &eptr, 16, false, &node);
+	if (rc != EOK || eptr != str + 36 || *eptr != '\0')
+		return EINVAL;
+
+	uuid->b[0] = time_low >> 24;
+	uuid->b[1] = (time_low >> 16) & 0xff;
+	uuid->b[2] = (time_low >> 8) & 0xff;
+	uuid->b[3] = time_low & 0xff;
+
+	uuid->b[4] = time_mid >> 8;
+	uuid->b[5] = time_mid & 0xff;
+
+	uuid->b[6] = time_ver >> 8;
+	uuid->b[7] = time_ver & 0xff;
+
+	uuid->b[8] = clock >> 8;
+	uuid->b[9] = clock & 0xff;
+
+	for (i = 0; i < 6; i++)
+		uuid->b[10 + i] = (node >> 8 * (5 - i)) & 0xff;
+
+	if (endptr != NULL) {
+		*endptr = str + 36;
+	} else {
+		if (*(str + 36) != '\0')
+			return EINVAL;
+	}
+
+	return EOK;
+}
+
+/** Format UUID into string representation.
+ *
+ * @param uuid UUID
+ * @param rstr Place to store pointer to newly allocated string
+ *
+ * @return EOK on success, ENOMEM if out of memory
+ */
+int uuid_format(uuid_t *uuid, char **rstr)
+{
+	return ENOTSUP;
+}
+
+
 /** @}
  */
Index: uspace/lib/c/generic/vbd.c
===================================================================
--- uspace/lib/c/generic/vbd.c	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/c/generic/vbd.c	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -330,4 +330,38 @@
 }
 
+/** Suggest partition type based on partition content.
+ *
+ * @param vbd   Virtual Block Device
+ * @param disk  Disk on which the partition will be created
+ * @param pcnt  Partition content
+ * @param ptype Place to store suggested partition type
+ *
+ * @return EOK on success or negative error code
+ */
+int vbd_suggest_ptype(vbd_t *vbd, service_id_t disk, label_pcnt_t pcnt,
+    label_ptype_t *ptype)
+{
+	async_exch_t *exch;
+	sysarg_t retval;
+	ipc_call_t answer;
+
+	exch = async_exchange_begin(vbd->sess);
+	aid_t req = async_send_2(exch, VBD_SUGGEST_PTYPE, disk, pcnt, &answer);
+	int rc = async_data_read_start(exch, ptype, sizeof(label_ptype_t));
+	async_exchange_end(exch);
+
+	if (rc != EOK) {
+		async_forget(req);
+		return EIO;
+	}
+
+	async_wait_for(req, &retval);
+	if (retval != EOK)
+		return EIO;
+
+	return EOK;
+}
+
+
 /** @}
  */
Index: uspace/lib/c/include/ipc/vbd.h
===================================================================
--- uspace/lib/c/include/ipc/vbd.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/c/include/ipc/vbd.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -46,4 +46,5 @@
 	VBD_PART_CREATE,
 	VBD_PART_DELETE,
+	VBD_SUGGEST_PTYPE
 } vbd_request_t;
 
Index: uspace/lib/c/include/types/label.h
===================================================================
--- uspace/lib/c/include/types/label.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/c/include/types/label.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -36,4 +36,6 @@
 #define LIBC_TYPES_LABEL_H_
 
+#include <types/uuid.h>
+
 /** Disk contents */
 typedef enum {
@@ -72,11 +74,48 @@
 	/** Label supports extended (and logical) partitions */
 	lf_ext_supp = 0x1,
+	/** Partition type is in UUID format (otherwise in small number format) */
+	lf_ptype_uuid = 0x2,
 	/** Currently it is possible to create a primary partition */
-	lf_can_create_pri = 0x2,
+	lf_can_create_pri = 0x4,
 	/** Currently it is possible to create an extended partition */
-	lf_can_create_ext = 0x4,
+	lf_can_create_ext = 0x8,
 	/** Currrently it is possible to create a logical partition */
-	lf_can_create_log = 0x8
+	lf_can_create_log = 0x10
 } label_flags_t;
+
+/** Partition type format */
+typedef enum {
+	/** Small number */
+	lptf_num,
+	/** UUID */
+	lptf_uuid
+} label_pt_fmt;
+
+/** Partition type */
+typedef struct {
+	/** Type format */
+	label_pt_fmt fmt;
+	/** Depending on @c fmt */
+	union {
+		/* Small number */
+		uint8_t num;
+		/** UUID */
+		uuid_t uuid;
+	} t;
+} label_ptype_t;
+
+/** Partition content (used to get partition type suggestion) */
+typedef enum {
+	/** ExFAT */
+	lpc_exfat,
+	/** Ext4 */
+	lpc_ext4,
+	/** FAT12 or FAT16 */
+	lpc_fat12_16,
+	/** FAT32 */
+	lpc_fat32,
+	/** Minix file system */
+	lpc_minix
+} label_pcnt_t;
 
 #endif
Index: uspace/lib/c/include/types/uuid.h
===================================================================
--- uspace/lib/c/include/types/uuid.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
+++ uspace/lib/c/include/types/uuid.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2015 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - 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.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ */
+
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBC_TYPES_UUID_H_
+#define LIBC_TYPES_UUID_H_
+
+#include <stdint.h>
+
+enum {
+	uuid_bytes = 16
+};
+
+/** Universally Unique Identifier */
+typedef struct {
+	uint8_t b[uuid_bytes];
+} uuid_t;
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/include/uuid.h
===================================================================
--- uspace/lib/c/include/uuid.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/c/include/uuid.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -37,17 +37,11 @@
 
 #include <stdint.h>
-
-enum {
-	uuid_bytes = 16
-};
-
-/** Universally Unique Identifier */
-typedef struct {
-	uint8_t b[uuid_bytes];
-} uuid_t;
+#include <types/uuid.h>
 
 extern int uuid_generate(uuid_t *);
 extern void uuid_encode(uuid_t *, uint8_t *);
 extern void uuid_decode(uint8_t *, uuid_t *);
+extern int uuid_parse(const char *, uuid_t *, const char **);
+extern int uuid_format(uuid_t *, char **);
 
 #endif
Index: uspace/lib/c/include/vbd.h
===================================================================
--- uspace/lib/c/include/vbd.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/c/include/vbd.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -74,5 +74,5 @@
 	label_pkind_t pkind;
 	/** Partition type */
-	uint64_t ptype;
+	label_ptype_t ptype;
 } vbd_part_spec_t;
 
@@ -105,4 +105,6 @@
 extern int vbd_part_delete(vbd_t *, vbd_part_id_t);
 extern void vbd_pspec_init(vbd_part_spec_t *);
+extern int vbd_suggest_ptype(vbd_t *, service_id_t, label_pcnt_t,
+    label_ptype_t *);
 
 #endif
Index: uspace/lib/fdisk/src/fdisk.c
===================================================================
--- uspace/lib/fdisk/src/fdisk.c	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/fdisk/src/fdisk.c	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -912,4 +912,5 @@
 	aoff64_t fnblocks;
 	uint64_t block_size;
+	label_pcnt_t pcnt;
 	unsigned i;
 	int index;
@@ -932,4 +933,27 @@
 	req_blocks = fdisk_ba_align_up(dev, req_blocks);
 
+	pcnt = -1;
+
+	switch (pspec->fstype) {
+	case fdfs_none:
+	case fdfs_unknown:
+		break;
+	case fdfs_exfat:
+		pcnt = lpc_exfat;
+		break;
+	case fdfs_fat:
+		pcnt = lpc_fat32; /* XXX Detect FAT12/16 vs FAT32 */
+		break;
+	case fdfs_minix:
+		pcnt = lpc_minix;
+		break;
+	case fdfs_ext4:
+		pcnt = lpc_ext4;
+		break;
+	}
+
+	if (pcnt < 0)
+		return EINVAL;
+
 	printf("fdisk_part_spec_prepare() - switch\n");
 	switch (pspec->pkind) {
@@ -952,6 +976,4 @@
 		vpspec->nblocks = req_blocks;
 		vpspec->pkind = pspec->pkind;
-		if (pspec->pkind != lpk_extended)
-			vpspec->ptype = 42;
 		break;
 	case lpk_logical:
@@ -967,6 +989,14 @@
 		vpspec->nblocks = req_blocks;
 		vpspec->pkind = lpk_logical;
-		vpspec->ptype = 42;
-		break;
+		vpspec->ptype.fmt = lptf_num;
+		vpspec->ptype.t.num = 42;
+		break;
+	}
+
+	if (pspec->pkind != lpk_extended) {
+		rc = vbd_suggest_ptype(dev->fdisk->vbd, dev->sid, pcnt,
+		    &vpspec->ptype);
+		if (rc != EOK)
+			return EIO;
 	}
 
Index: uspace/lib/label/include/label.h
===================================================================
--- uspace/lib/label/include/label.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/label/include/label.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -55,4 +55,5 @@
 extern int label_part_destroy(label_part_t *);
 extern void label_pspec_init(label_part_spec_t *);
+extern int label_suggest_ptype(label_t *, label_pcnt_t, label_ptype_t *);
 
 #endif
Index: uspace/lib/label/include/std/gpt.h
===================================================================
--- uspace/lib/label/include/std/gpt.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/label/include/std/gpt.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -77,4 +77,12 @@
 } __attribute__((packed)) gpt_entry_t;
 
+/** Microsoft Basic Data Partition */
+#define GPT_MS_BASIC_DATA "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7"
+/** Linux Filesystem Data */
+#define GPT_LINUX_FS_DATA "0FC63DAF-8483-4772-8E79-3D69D8477DE4"
+/** I could not find any definition of Minix GUID partition type.
+ * This is a randomly generated UUID */
+#define GPT_MINIX_FAKE "8308e350-4e2d-46c7-8e3b-24b07e8ac674"
+
 #endif
 
Index: uspace/lib/label/include/std/mbr.h
===================================================================
--- uspace/lib/label/include/std/mbr.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/label/include/std/mbr.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -57,9 +57,21 @@
 };
 
-enum ptype {
+enum mbr_ptype {
 	/** Unused partition entry */
-	mbr_pt_unused	= 0x00,
+	mbr_pt_unused	    = 0x00,
 	/** Extended partition */
-	mbr_pt_extended	= 0x05
+	mbr_pt_extended	    = 0x05,
+	/** Extended partition with LBA */
+	mbr_pt_extended_lba = 0x0f,
+	/** FAT16 with LBA */
+	mbr_pt_fat16_lba    = 0x0e,
+	/** FAT32 with LBA */
+	mbr_pt_fat32_lba    = 0x0c,
+	/** IFS, HPFS, NTFS, exFAT */
+	mbr_pt_ms_advanced  = 0x07,
+	/** Minix */
+	mbr_pt_minix        = 0x81,
+	/** Linux */
+	mbr_pt_linux        = 0x83
 };
 
Index: uspace/lib/label/include/types/liblabel.h
===================================================================
--- uspace/lib/label/include/types/liblabel.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/label/include/types/liblabel.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -61,4 +61,5 @@
 	int (*part_create)(label_t *, label_part_spec_t *, label_part_t **);
 	int (*part_destroy)(label_part_t *);
+	int (*suggest_ptype)(label_t *, label_pcnt_t, label_ptype_t *);
 } label_ops_t;
 
@@ -106,5 +107,5 @@
 	aoff64_t nblocks;
 	/** Partition type */
-	uint64_t ptype;
+	label_ptype_t ptype;
 	/** Partition UUID */
 	uuid_t part_uuid;
@@ -124,5 +125,5 @@
 	label_pkind_t pkind;
 	/** Partition type */
-	uint64_t ptype;
+	label_ptype_t ptype;
 };
 
Index: uspace/lib/label/src/gpt.c
===================================================================
--- uspace/lib/label/src/gpt.c	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/label/src/gpt.c	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -55,4 +55,5 @@
 static int gpt_part_create(label_t *, label_part_spec_t *, label_part_t **);
 static int gpt_part_destroy(label_part_t *);
+static int gpt_suggest_ptype(label_t *, label_pcnt_t, label_ptype_t *);
 
 static void gpt_unused_pte(gpt_entry_t *);
@@ -80,5 +81,6 @@
 	.part_get_info = gpt_part_get_info,
 	.part_create = gpt_part_create,
-	.part_destroy = gpt_part_destroy
+	.part_destroy = gpt_part_destroy,
+	.suggest_ptype = gpt_suggest_ptype
 };
 
@@ -547,5 +549,5 @@
 	linfo->dcnt = dc_label;
 	linfo->ltype = lt_gpt;
-	linfo->flags = 0;
+	linfo->flags = lf_ptype_uuid; /* Partition type is in UUID format */
 	if (gpt_can_create_pri(label))
 		linfo->flags = linfo->flags | lf_can_create_pri;
@@ -607,4 +609,10 @@
 	/* GPT only has primary partitions */
 	if (pspec->pkind != lpk_primary) {
+		rc = EINVAL;
+		goto error;
+	}
+
+	/* Partition type must be in UUID format */
+	if (pspec->ptype.fmt != lptf_uuid) {
 		rc = EINVAL;
 		goto error;
@@ -663,4 +671,36 @@
 }
 
+static int gpt_suggest_ptype(label_t *label, label_pcnt_t pcnt,
+    label_ptype_t *ptype)
+{
+	const char *ptid;
+	int rc;
+
+	ptid = NULL;
+
+	switch (pcnt) {
+	case lpc_fat12_16:
+	case lpc_exfat:
+	case lpc_fat32:
+		ptid = GPT_MS_BASIC_DATA;
+		break;
+	case lpc_ext4:
+		ptid = GPT_LINUX_FS_DATA;
+		break;
+	case lpc_minix:
+		ptid = GPT_MINIX_FAKE;
+		break;
+	}
+
+	if (ptid == NULL)
+		return EINVAL;
+
+	ptype->fmt = lptf_uuid;
+	rc = uuid_parse(ptid, &ptype->t.uuid, NULL);
+	assert(rc == EOK);
+
+	return EOK;
+}
+
 static void gpt_unused_pte(gpt_entry_t *pte)
 {
@@ -677,5 +717,5 @@
 
 	memset(pte, 0, sizeof(gpt_entry_t));
-	pte->part_type[0] = 0x12;
+	uuid_encode(&part->ptype.t.uuid, pte->part_type);
 	uuid_encode(&part->part_uuid, pte->part_id);
 	pte->start_lba = host2uint64_t_le(part->block0);
@@ -713,4 +753,6 @@
 	part->block0 = b0;
 	part->nblocks = b1 - b0 + 1;
+	part->ptype.fmt = lptf_uuid;
+	uuid_decode(pte->part_type, &part->ptype.t.uuid);
 	uuid_decode(pte->part_id, &part->part_uuid);
 
Index: uspace/lib/label/src/label.c
===================================================================
--- uspace/lib/label/src/label.c	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/label/src/label.c	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -133,4 +133,10 @@
 }
 
+int label_suggest_ptype(label_t *label, label_pcnt_t pcnt,
+    label_ptype_t *ptype)
+{
+	return label->ops->suggest_ptype(label, pcnt, ptype);
+}
+
 /** @}
  */
Index: uspace/lib/label/src/mbr.c
===================================================================
--- uspace/lib/label/src/mbr.c	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/lib/label/src/mbr.c	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -54,4 +54,5 @@
 static int mbr_part_create(label_t *, label_part_spec_t *, label_part_t **);
 static int mbr_part_destroy(label_part_t *);
+static int mbr_suggest_ptype(label_t *, label_pcnt_t, label_ptype_t *);
 
 static void mbr_unused_pte(mbr_pte_t *);
@@ -77,5 +78,6 @@
 	.part_get_info = mbr_part_get_info,
 	.part_create = mbr_part_create,
-	.part_destroy = mbr_part_destroy
+	.part_destroy = mbr_part_destroy,
+	.suggest_ptype = mbr_suggest_ptype
 };
 
@@ -485,8 +487,8 @@
 
 	log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_part_get_info: index=%d ptype=%d",
-	    (int)part->index, (int)part->ptype);
+	    (int)part->index, (int)part->ptype.t.num);
 	if (link_used(&part->llog))
 		pinfo->pkind = lpk_logical;
-	else if (part->ptype == mbr_pt_extended)
+	else if (part->ptype.t.num == mbr_pt_extended)
 		pinfo->pkind = lpk_extended;
 	else
@@ -503,4 +505,7 @@
 	int rc;
 
+	if (pspec->ptype.fmt != lptf_num)
+		return EINVAL;
+
 	part = calloc(1, sizeof(label_part_t));
 	if (part == NULL)
@@ -521,6 +526,7 @@
 		break;
 	case lpk_extended:
-		part->ptype = mbr_pt_extended;
-		if (pspec->ptype != 0) {
+		part->ptype.fmt = lptf_num;
+		part->ptype.t.num = mbr_pt_extended;
+		if (pspec->ptype.t.num != 0) {
 			rc = EINVAL;
 			goto error;
@@ -705,4 +711,35 @@
 }
 
+static int mbr_suggest_ptype(label_t *label, label_pcnt_t pcnt,
+    label_ptype_t *ptype)
+{
+	ptype->fmt = lptf_num;
+	ptype->t.num = 0;
+
+	switch (pcnt) {
+	case lpc_exfat:
+		ptype->t.num = mbr_pt_ms_advanced;
+		break;
+	case lpc_ext4:
+		ptype->t.num = mbr_pt_linux;
+		break;
+	case lpc_fat12_16:
+		ptype->t.num = mbr_pt_fat16_lba;
+		break;
+	case lpc_fat32:
+		ptype->t.num = mbr_pt_fat32_lba;
+		break;
+	case lpc_minix:
+		ptype->t.num = mbr_pt_minix;
+		break;
+	}
+
+	if (ptype->t.num == 0)
+		return EINVAL;
+
+	return EOK;
+}
+
+
 static void mbr_unused_pte(mbr_pte_t *pte)
 {
@@ -716,12 +753,12 @@
 	if ((part->nblocks >> 32) != 0)
 		return EINVAL;
-	if ((part->ptype >> 8) != 0)
+	if ((part->ptype.t.num >> 8) != 0)
 		return EINVAL;
 
 	log_msg(LOG_DEFAULT, LVL_NOTE, "mbr_part_to_pte: a0=%" PRIu64
 	    " len=%" PRIu64 " ptype=%d", part->block0, part->nblocks,
-	    (int)part->ptype);
+	    (int)part->ptype.t.num);
 	memset(pte, 0, sizeof(mbr_pte_t));
-	pte->ptype = part->ptype;
+	pte->ptype = part->ptype.t.num;
 	pte->first_lba = host2uint32_t_le(part->block0);
 	pte->length = host2uint32_t_le(part->nblocks);
@@ -746,5 +783,6 @@
 		return ENOMEM;
 
-	part->ptype = pte->ptype;
+	part->ptype.fmt = lptf_num;
+	part->ptype.t.num = pte->ptype;
 	part->index = index;
 	part->block0 = block0;
@@ -786,5 +824,6 @@
 	nlparts = list_count(&label->log_parts);
 
-	part->ptype = pte->ptype;
+	part->ptype.fmt = lptf_num;
+	part->ptype.t.num = pte->ptype;
 	part->index = mbr_nprimary + 1 + nlparts;
 	part->block0 = block0;
@@ -816,5 +855,5 @@
 	if (pthis != NULL) {
 		memset(pthis, 0, sizeof(mbr_pte_t));
-		pthis->ptype = part->ptype;
+		pthis->ptype = part->ptype.t.num;
 		pthis->first_lba = host2uint32_t_le(part->hdr_blocks);
 		pthis->length = host2uint32_t_le(part->nblocks);
Index: uspace/srv/bd/vbd/disk.c
===================================================================
--- uspace/srv/bd/vbd/disk.c	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/srv/bd/vbd/disk.c	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -503,5 +503,5 @@
 	rc = vbds_disk_by_svcid(sid, &disk);
 	if (rc != EOK) {
-		log_msg(LOG_DEFAULT, LVL_NOTE, "Partition %zu not found",
+		log_msg(LOG_DEFAULT, LVL_NOTE, "Disk %zu not found",
 		    sid);
 		goto error;
@@ -583,4 +583,28 @@
 
 	return EOK;
+}
+
+int vbds_suggest_ptype(service_id_t sid, label_pcnt_t pcnt,
+    label_ptype_t *ptype)
+{
+	vbds_disk_t *disk;
+	int rc;
+
+	rc = vbds_disk_by_svcid(sid, &disk);
+	if (rc != EOK) {
+		log_msg(LOG_DEFAULT, LVL_NOTE, "Disk %zu not found",
+		    sid);
+		goto error;
+	}
+
+	rc = label_suggest_ptype(disk->label, pcnt, ptype);
+	if (rc != EOK) {
+		log_msg(LOG_DEFAULT, LVL_NOTE, "label_suggest_ptype() failed");
+		goto error;
+	}
+
+	return EOK;
+error:
+	return rc;
 }
 
Index: uspace/srv/bd/vbd/disk.h
===================================================================
--- uspace/srv/bd/vbd/disk.h	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/srv/bd/vbd/disk.h	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -52,4 +52,5 @@
 extern int vbds_part_create(service_id_t, vbd_part_spec_t *,vbds_part_id_t *);
 extern int vbds_part_delete(vbds_part_id_t);
+extern int vbds_suggest_ptype(service_id_t, label_pcnt_t, label_ptype_t *);
 extern void vbds_bd_conn(ipc_callid_t, ipc_call_t *, void *);
 
Index: uspace/srv/bd/vbd/vbd.c
===================================================================
--- uspace/srv/bd/vbd/vbd.c	(revision 1b23e33bb2be0b10c8a2eff692e584cd18e05992)
+++ uspace/srv/bd/vbd/vbd.c	(revision f57ccb5dbdad2edb2def6970e5d20849ccd9daa9)
@@ -208,5 +208,4 @@
 }
 
-
 static void vbds_part_get_info_srv(ipc_callid_t iid, ipc_call_t *icall)
 {
@@ -302,4 +301,46 @@
 }
 
+static void vbds_suggest_ptype_srv(ipc_callid_t iid, ipc_call_t *icall)
+{
+	service_id_t disk_sid;
+	label_ptype_t ptype;
+	label_pcnt_t pcnt;
+	int rc;
+
+	log_msg(LOG_DEFAULT, LVL_NOTE, "vbds_suggest_ptype_srv()");
+
+	disk_sid = IPC_GET_ARG1(*icall);
+	pcnt = IPC_GET_ARG2(*icall);
+
+	rc = vbds_suggest_ptype(disk_sid, pcnt, &ptype);
+	if (rc != EOK) {
+		async_answer_0(iid, rc);
+		return;
+	}
+
+	ipc_callid_t callid;
+	size_t size;
+	if (!async_data_read_receive(&callid, &size)) {
+		async_answer_0(callid, EREFUSED);
+		async_answer_0(iid, EREFUSED);
+		return;
+	}
+
+	if (size != sizeof(label_ptype_t)) {
+		async_answer_0(callid, EINVAL);
+		async_answer_0(iid, EINVAL);
+		return;
+	}
+
+	rc = async_data_read_finalize(callid, &ptype, sizeof(label_ptype_t));
+	if (rc != EOK) {
+		async_answer_0(callid, rc);
+		async_answer_0(iid, rc);
+		return;
+	}
+
+	async_answer_0(iid, EOK);
+}
+
 static void vbds_ctl_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
@@ -348,4 +389,7 @@
 			vbds_part_delete_srv(callid, &call);
 			break;
+		case VBD_SUGGEST_PTYPE:
+			vbds_suggest_ptype_srv(callid, &call);
+			break;
 		default:
 			async_answer_0(callid, EINVAL);