Index: uspace/app/init/init.c
===================================================================
--- uspace/app/init/init.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/app/init/init.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -320,4 +320,6 @@
 		srv_start("/srv/tmpfs");
 	
+	srv_start("/srv/mfs");
+	
 	srv_start("/srv/klog");
 	srv_start("/srv/locfs");
Index: uspace/lib/c/generic/vfs/vfs.c
===================================================================
--- uspace/lib/c/generic/vfs/vfs.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/lib/c/generic/vfs/vfs.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -347,4 +347,39 @@
 	return loc_service_connect(stat.service, iface, 0);
 }
+
+/** Determine if a device contains the specified file system type. If so,
+ * return identification information.
+ *
+ * @param fs_name File system name
+ * @param serv    Service representing the mountee
+ * @param info    Place to store volume identification information
+ *
+ * @return                      EOK on success or a negative error code
+ */
+int vfs_fsprobe(const char *fs_name, service_id_t serv,
+    vfs_fs_probe_info_t *info)
+{
+	sysarg_t rc;
+	
+	ipc_call_t answer;
+	async_exch_t *exch = vfs_exchange_begin();
+	aid_t req = async_send_1(exch, VFS_IN_FSPROBE, serv, &answer);
+	
+	rc = async_data_write_start(exch, (void *) fs_name,
+	    str_size(fs_name));
+	
+	async_wait_for(req, &rc);
+	
+	if (rc != EOK) {
+		vfs_exchange_end(exch);
+		return rc;
+	}
+	
+	rc = async_data_read_start(exch, info, sizeof(*info));
+	vfs_exchange_end(exch);
+	
+	return rc;
+}
+
 
 /** Return a list of currently available file system types
Index: uspace/lib/c/include/ipc/vfs.h
===================================================================
--- uspace/lib/c/include/ipc/vfs.h	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/lib/c/include/ipc/vfs.h	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -41,4 +41,6 @@
 
 #define FS_NAME_MAXLEN  20
+#define FS_LABEL_MAXLEN 256
+#define FS_VUID_MAXLEN 128
 #define MAX_PATH_LEN    (32 * 1024)
 #define MAX_MNTOPTS_LEN 256
@@ -62,6 +64,13 @@
 } vfs_info_t;
 
+/** Data returned by filesystem probe regarding a specific volume. */
+typedef struct {
+	char label[FS_LABEL_MAXLEN + 1];
+	char vuid[FS_VUID_MAXLEN + 1];
+} vfs_fs_probe_info_t;
+
 typedef enum {
 	VFS_IN_CLONE = IPC_FIRST_USER_METHOD,
+	VFS_IN_FSPROBE,
 	VFS_IN_FSTYPES,
 	VFS_IN_MOUNT,
@@ -85,4 +94,5 @@
 	VFS_OUT_CLOSE = IPC_FIRST_USER_METHOD,
 	VFS_OUT_DESTROY,
+	VFS_OUT_FSPROBE,
 	VFS_OUT_IS_EMPTY,
 	VFS_OUT_LINK,
Index: uspace/lib/c/include/vfs/vfs.h
===================================================================
--- uspace/lib/c/include/vfs/vfs.h	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/lib/c/include/vfs/vfs.h	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -88,4 +88,5 @@
 extern async_exch_t *vfs_exchange_begin(void);
 extern void vfs_exchange_end(async_exch_t *);
+extern int vfs_fsprobe(const char *, service_id_t, vfs_fs_probe_info_t *);
 extern int vfs_fstypes(vfs_fstypes_t *);
 extern void vfs_fstypes_free(vfs_fstypes_t *);
Index: uspace/lib/fs/libfs.c
===================================================================
--- uspace/lib/fs/libfs.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/lib/fs/libfs.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -81,4 +81,31 @@
     ipc_call_t *);
 
+static void vfs_out_fsprobe(ipc_callid_t rid, ipc_call_t *req)
+{
+	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
+	int rc;
+	vfs_fs_probe_info_t info;
+	
+	ipc_callid_t callid;
+	size_t size;
+	if ((!async_data_read_receive(&callid, &size)) ||
+	    (size != sizeof(info))) {
+		async_answer_0(callid, EIO);
+		async_answer_0(rid, EIO);
+		return;
+	}
+	
+	memset(&info, 0, sizeof(info));
+	rc = vfs_out_ops->fsprobe(service_id, &info);
+	if (rc != EOK) {
+		async_answer_0(callid, EIO);
+		async_answer_0(rid, rc);
+		return;
+	}
+	
+	async_data_read_finalize(callid, &info, sizeof(info));
+	async_answer_0(rid, EOK);
+}
+
 static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
 {
@@ -272,4 +299,7 @@
 		
 		switch (IPC_GET_IMETHOD(call)) {
+		case VFS_OUT_FSPROBE:
+			vfs_out_fsprobe(callid, &call);
+			break;
 		case VFS_OUT_MOUNTED:
 			vfs_out_mounted(callid, &call);
Index: uspace/lib/fs/libfs.h
===================================================================
--- uspace/lib/fs/libfs.h	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/lib/fs/libfs.h	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -43,4 +43,5 @@
 
 typedef struct {
+	int (* fsprobe)(service_id_t, vfs_fs_probe_info_t *);
 	int (* mounted)(service_id_t, const char *, fs_index_t *, aoff64_t *,
 	    unsigned *);
Index: uspace/srv/fs/cdfs/cdfs_ops.c
===================================================================
--- uspace/srv/fs/cdfs/cdfs_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/fs/cdfs/cdfs_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -1021,4 +1021,9 @@
 }
 
+static int cdfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+{
+	return ENOTSUP;
+}
+
 static int cdfs_mounted(service_id_t service_id, const char *opts,
     fs_index_t *index, aoff64_t *size, unsigned int *lnkcnt)
@@ -1297,4 +1302,5 @@
 
 vfs_out_ops_t cdfs_ops = {
+	.fsprobe = cdfs_fsprobe,
 	.mounted = cdfs_mounted,
 	.unmounted = cdfs_unmounted,
Index: uspace/srv/fs/exfat/exfat_ops.c
===================================================================
--- uspace/srv/fs/exfat/exfat_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/fs/exfat/exfat_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -1050,5 +1050,10 @@
 }
 */
- 
+
+static int exfat_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+{
+	return ENOTSUP;
+}
+
 static int
 exfat_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
@@ -1571,4 +1576,5 @@
 
 vfs_out_ops_t exfat_ops = {
+	.fsprobe = exfat_fsprobe,
 	.mounted = exfat_mounted,
 	.unmounted = exfat_unmounted,
Index: uspace/srv/fs/ext4fs/ext4fs_ops.c
===================================================================
--- uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/fs/ext4fs/ext4fs_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -915,4 +915,18 @@
  * VFS operations.
  */
+
+/** Probe operation.
+ *
+ * Try to get information about specified filesystem from device.
+ *
+ * @param sevice_id Service ID
+ * @param info Place to store information
+ *
+ * @return Error code
+ */
+static int ext4fs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+{
+	return ENOTSUP;
+}
 
 /** Mount operation.
@@ -1520,4 +1534,5 @@
  */
 vfs_out_ops_t ext4fs_ops = {
+	.fsprobe = ext4fs_fsprobe,
 	.mounted = ext4fs_mounted,
 	.unmounted = ext4fs_unmounted,
Index: uspace/srv/fs/fat/fat_ops.c
===================================================================
--- uspace/srv/fs/fat/fat_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/fs/fat/fat_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -912,4 +912,9 @@
  * FAT VFS_OUT operations.
  */
+
+static int fat_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+{
+	return ENOTSUP;
+}
 
 static int
@@ -1508,4 +1513,5 @@
 
 vfs_out_ops_t fat_ops = {
+	.fsprobe = fat_fsprobe,
 	.mounted = fat_mounted,
 	.unmounted = fat_unmounted,
Index: uspace/srv/fs/locfs/locfs_ops.c
===================================================================
--- uspace/srv/fs/locfs/locfs_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/fs/locfs/locfs_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -455,4 +455,9 @@
 }
 
+static int locfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+{
+	return ENOTSUP;
+}
+
 static int locfs_mounted(service_id_t service_id, const char *opts,
     fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
@@ -763,4 +768,5 @@
 
 vfs_out_ops_t locfs_ops = {
+	.fsprobe = locfs_fsprobe,
 	.mounted = locfs_mounted,
 	.unmounted = locfs_unmounted,
Index: uspace/srv/fs/mfs/mfs_ops.c
===================================================================
--- uspace/srv/fs/mfs/mfs_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/fs/mfs/mfs_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -140,28 +140,16 @@
 }
 
-static int
-mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
-    aoff64_t *size, unsigned *linkcnt)
-{
-	enum cache_mode cmode;
+/** Read the superblock.
+ */
+static int mfs_read_sb(service_id_t service_id, struct mfs_sb_info **rsbi)
+{
 	struct mfs_superblock *sb = NULL;
 	struct mfs3_superblock *sb3 = NULL;
-	struct mfs_sb_info *sbi = NULL;
-	struct mfs_instance *instance = NULL;
+	struct mfs_sb_info *sbi;
+	size_t bsize;
 	bool native, longnames;
 	mfs_version_t version;
 	uint16_t magic;
 	int rc;
-
-	/* Check for option enabling write through. */
-	if (str_cmp(opts, "wtcache") == 0)
-		cmode = CACHE_MODE_WT;
-	else
-		cmode = CACHE_MODE_WB;
-
-	/* initialize libblock */
-	rc = block_init(service_id, 4096);
-	if (rc != EOK)
-		return rc;
 
 	/* Allocate space for generic MFS superblock */
@@ -172,14 +160,19 @@
 	}
 
-	/* Allocate space for filesystem instance */
-	instance = malloc(sizeof(*instance));
-	if (!instance) {
-		rc = ENOMEM;
-		goto out_error;
-	}
-
 	sb = malloc(MFS_SUPERBLOCK_SIZE);
 	if (!sb) {
 		rc = ENOMEM;
+		goto out_error;
+	}
+
+	rc = block_get_bsize(service_id, &bsize);
+	if (rc != EOK) {
+		rc = EIO;
+		goto out_error;
+	}
+
+	/* We don't support other block size than 512 */
+	if (bsize != 512) {
+		rc = ENOTSUP;
 		goto out_error;
 	}
@@ -269,4 +262,68 @@
 	}
 
+	mfsdebug("read superblock successful\n");
+
+	free(sb);
+	*rsbi = sbi;
+	return EOK;
+
+out_error:
+	if (sb)
+		free(sb);
+	if (sbi)
+		free(sbi);
+	return rc;
+}
+
+
+static int mfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+{
+	struct mfs_sb_info *sbi = NULL;
+	int rc;
+
+	/* Initialize libblock */
+	rc = block_init(service_id, 4096);
+	if (rc != EOK)
+		return rc;
+
+	/* Read the superblock */
+	rc = mfs_read_sb(service_id, &sbi);
+	block_fini(service_id);
+
+	return rc;
+}
+
+static int
+mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
+    aoff64_t *size, unsigned *linkcnt)
+{
+	enum cache_mode cmode;
+	struct mfs_sb_info *sbi = NULL;
+	struct mfs_instance *instance = NULL;
+	int rc;
+
+	/* Check for option enabling write through. */
+	if (str_cmp(opts, "wtcache") == 0)
+		cmode = CACHE_MODE_WT;
+	else
+		cmode = CACHE_MODE_WB;
+
+	/* Initialize libblock */
+	rc = block_init(service_id, 4096);
+	if (rc != EOK)
+		return rc;
+
+	/* Allocate space for filesystem instance */
+	instance = malloc(sizeof(*instance));
+	if (!instance) {
+		rc = ENOMEM;
+		goto out_error;
+	}
+
+	/* Read the superblock */
+	rc = mfs_read_sb(service_id, &sbi);
+	if (rc != EOK)
+		goto out_error;
+
 	rc = block_cache_init(service_id, sbi->block_size, 0, cmode);
 	if (rc != EOK) {
@@ -298,12 +355,8 @@
 	*linkcnt = 1;
 
-	free(sb);
-
 	return mfs_node_put(fn);
 
 out_error:
 	block_fini(service_id);
-	if (sb)
-		free(sb);
 	if (sbi)
 		free(sbi);
@@ -1205,4 +1258,5 @@
 
 vfs_out_ops_t mfs_ops = {
+	.fsprobe = mfs_fsprobe,
 	.mounted = mfs_mounted,
 	.unmounted = mfs_unmounted,
Index: uspace/srv/fs/tmpfs/tmpfs_ops.c
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -421,4 +421,9 @@
  */
 
+static int tmpfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+{
+	return ENOTSUP;
+}
+
 static int
 tmpfs_mounted(service_id_t service_id, const char *opts,
@@ -652,4 +657,5 @@
 
 vfs_out_ops_t tmpfs_ops = {
+	.fsprobe = tmpfs_fsprobe,
 	.mounted = tmpfs_mounted,
 	.unmounted = tmpfs_unmounted,
Index: uspace/srv/fs/udf/udf_ops.c
===================================================================
--- uspace/srv/fs/udf/udf_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/fs/udf/udf_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -299,4 +299,9 @@
 };
 
+static int udf_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+{
+	return ENOTSUP;
+}
+
 static int udf_mounted(service_id_t service_id, const char *opts,
     fs_index_t *index, aoff64_t *size, unsigned *linkcnt)
@@ -547,4 +552,5 @@
 
 vfs_out_ops_t udf_ops = {
+	.fsprobe = udf_fsprobe,
 	.mounted = udf_mounted,
 	.unmounted = udf_unmounted,
Index: uspace/srv/vfs/vfs.h
===================================================================
--- uspace/srv/vfs/vfs.h	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/vfs/vfs.h	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -206,4 +206,5 @@
 
 extern int vfs_op_clone(int oldfd, int newfd, bool desc);
+extern int vfs_op_fsprobe(const char *, service_id_t, vfs_fs_probe_info_t *);
 extern int vfs_op_mount(int mpfd, unsigned servid, unsigned flags, unsigned instance, const char *opts, const char *fsname, int *outfd);
 extern int vfs_op_mtab_get(void);
Index: uspace/srv/vfs/vfs_ipc.c
===================================================================
--- uspace/srv/vfs/vfs_ipc.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/vfs/vfs_ipc.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -45,4 +45,41 @@
 }
 
+static void vfs_in_fsprobe(ipc_callid_t rid, ipc_call_t *request)
+{
+	service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
+	char *fs_name = NULL;
+	ipc_callid_t callid;
+	vfs_fs_probe_info_t info;
+	size_t len;
+	int rc;
+	
+	/*
+	 * Now we expect the client to send us data with the name of the file 
+	 * system.
+	 */
+	rc = async_data_write_accept((void **) &fs_name, true, 0,
+	    FS_NAME_MAXLEN, 0, NULL);
+	if (rc != EOK) {
+		async_answer_0(rid, rc);
+		return;
+	}
+	
+	rc = vfs_op_fsprobe(fs_name, service_id, &info);
+	async_answer_0(rid, rc);
+	if (rc != EOK)
+		goto out;
+	
+	/* Now we should get a read request */
+	if (!async_data_read_receive(&callid, &len))
+		goto out;
+
+	if (len > sizeof(info))
+		len = sizeof(info);
+	(void) async_data_read_finalize(callid, &info, len);
+
+out:
+	free(fs_name);
+}
+
 static void vfs_in_fstypes(ipc_callid_t rid, ipc_call_t *request)
 {
@@ -297,4 +334,7 @@
 			vfs_in_clone(callid, &call);
 			break;
+		case VFS_IN_FSPROBE:
+			vfs_in_fsprobe(callid, &call);
+			break;
 		case VFS_IN_FSTYPES:
 			vfs_in_fstypes(callid, &call);
Index: uspace/srv/vfs/vfs_ops.c
===================================================================
--- uspace/srv/vfs/vfs_ops.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/vfs/vfs_ops.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -190,4 +190,38 @@
 }
 
+int vfs_op_fsprobe(const char *fs_name, service_id_t sid,
+    vfs_fs_probe_info_t *info)
+{
+	fs_handle_t fs_handle = 0;
+	sysarg_t rc;
+	int retval;
+	
+	fibril_mutex_lock(&fs_list_lock);
+	fs_handle = fs_name_to_handle(0, fs_name, false);
+	fibril_mutex_unlock(&fs_list_lock);
+	
+	if (fs_handle == 0)
+		return ENOFS;
+	
+	/* Send probe request to the file system server */
+	ipc_call_t answer;
+	async_exch_t *exch = vfs_exchange_grab(fs_handle);
+	aid_t msg = async_send_1(exch, VFS_OUT_FSPROBE, (sysarg_t) sid,
+	    &answer);
+	if (msg == 0)
+		return EINVAL;
+	
+	/* Read probe information */
+	retval = async_data_read_start(exch, info, sizeof(*info));
+	if (retval != EOK) {
+		async_forget(msg);
+		return retval;
+	}
+	
+	async_wait_for(msg, &rc);
+	vfs_exchange_release(exch);
+	return rc;
+}
+
 int vfs_op_mount(int mpfd, unsigned service_id, unsigned flags,
     unsigned instance, const char *opts, const char *fs_name, int *outfd)
Index: uspace/srv/volsrv/part.c
===================================================================
--- uspace/srv/volsrv/part.c	(revision 582a0b84b0a73672531e7b404a89997af41ba0b9)
+++ uspace/srv/volsrv/part.c	(revision d2c8533502ff5b2f8ab86192d66ca356e4b9a813)
@@ -42,4 +42,5 @@
 #include <stdlib.h>
 #include <str.h>
+#include <vfs/vfs.h>
 
 #include "empty.h"
@@ -132,4 +133,5 @@
 	vol_part_t *part;
 	bool empty;
+	vfs_fs_probe_info_t info;
 	int rc;
 
@@ -154,13 +156,23 @@
 	}
 
-	log_msg(LOG_DEFAULT, LVL_DEBUG, "Probe partition %s", part->svc_name);
-	rc = volsrv_part_is_empty(sid, &empty);
-	if (rc != EOK) {
-		log_msg(LOG_DEFAULT, LVL_ERROR, "Failed determining if "
-		    "partition is empty.");
-		goto error;
-	}
-
-	part->pcnt = empty ? vpc_empty : vpc_unknown;
+	log_msg(LOG_DEFAULT, LVL_NOTE, "Probe partition %s", part->svc_name);
+	rc = vfs_fsprobe("mfs", sid, &info);
+	if (rc == EOK) {
+		part->pcnt = vpc_fs;
+		part->fstype = fs_minix;
+	} else {
+		log_msg(LOG_DEFAULT, LVL_NOTE, "Partition does not contain "
+		    "a recognized file system.");
+
+		rc = volsrv_part_is_empty(sid, &empty);
+		if (rc != EOK) {
+			log_msg(LOG_DEFAULT, LVL_ERROR, "Failed determining if "
+			    "partition is empty.");
+			goto error;
+		}
+
+		part->pcnt = empty ? vpc_empty : vpc_unknown;
+	}
+
 	list_append(&part->lparts, &vol_parts);
 
