Index: uspace/app/bdsh/cmds/modules/mount/mount.c
===================================================================
--- uspace/app/bdsh/cmds/modules/mount/mount.c	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/app/bdsh/cmds/modules/mount/mount.c	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -49,4 +49,5 @@
 	{ "help", no_argument, 0, 'h' },
 	{ "instance", required_argument, 0, 'i' },
+	{ "types", no_argument, 0, 't' },
 	{ 0, 0, 0, 0 }
 };
@@ -57,5 +58,10 @@
 {
 	static char helpfmt[] =
-	    "Usage:  %s <fstype> <mp> [dev] [<moptions>]\n";
+	    "Usage:  %s <fstype> <mp> [dev] [<moptions>]\n"
+	    "Options:\n"
+	    "  -h, --help       A short option summary\n"
+	    "  -i, --instance ## Mount a specific instance\n"
+	    "  -t, --types      List available file system types\n";
+
 	if (level == HELP_SHORT) {
 		printf("'%s' mounts a file system.\n", cmdname);
@@ -101,4 +107,23 @@
 }
 
+static void print_fstypes(void)
+{
+	int rc;
+	vfs_fstypes_t fstypes;
+	char **p;
+
+	rc = vfs_fstypes(&fstypes);
+	if (rc != EOK) {
+		printf("Error getting list of available file system types.\n");
+		return;
+	}
+
+	printf("Available file system types:\n");
+	p = fstypes.fstypes;
+	while (*p != NULL)
+		printf("\t%s\n", *p++);
+	vfs_fstypes_free(&fstypes);
+}
+
 /* Main entry point for mount, accepts an array of arguments */
 int cmd_mount(char **argv)
@@ -115,5 +140,5 @@
 
 	for (c = 0, optreset = 1, optind = 0, opt_ind = 0; c != -1;) {
-		c = getopt_long(argc, argv, "i:h", long_options, &opt_ind);
+		c = getopt_long(argc, argv, "i:ht", long_options, &opt_ind);
 		switch (c) {
 		case 'h':
@@ -124,4 +149,7 @@
 			instance_set = true;
 			break;
+		case 't':
+			print_fstypes();
+			return CMD_SUCCESS;
 		}
 	}
@@ -151,4 +179,6 @@
 		printf("Unable to mount %s filesystem to %s on %s (rc=%s)\n",
 		    t_argv[2], t_argv[1], t_argv[3], str_error(rc));
+		if (rc == ENOFS)
+			print_fstypes();
 		return CMD_FAILURE;
 	}
Index: uspace/lib/c/generic/str_error.c
===================================================================
--- uspace/lib/c/generic/str_error.c	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/lib/c/generic/str_error.c	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -72,4 +72,6 @@
 	// FIXME: integrate these as first-class error values
 	switch (e) {
+		case ENOFS:
+			return "No such file system type";
 		case EBADCHECKSUM:
 			return "Bad checksum";
Index: uspace/lib/c/generic/vfs/vfs.c
===================================================================
--- uspace/lib/c/generic/vfs/vfs.c	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/lib/c/generic/vfs/vfs.c	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -346,4 +346,92 @@
 	
 	return loc_service_connect(stat.service, iface, 0);
+}
+
+/** Return a list of currently available file system types
+ *
+ * @param fstypes Points to structure where list of filesystem types is
+ *        stored. It is read as a null-terminated list of strings
+ *        fstypes->fstypes[0..]. To free the list use vfs_fstypes_free().
+ *
+ * @return                      EOK on success or a negative error code
+ */
+int vfs_fstypes(vfs_fstypes_t *fstypes)
+{
+	sysarg_t size;
+	char *buf;
+	char dummybuf[1];
+	size_t count, i;
+
+	async_exch_t *exch = vfs_exchange_begin();
+	int rc = async_req_0_1(exch, VFS_IN_FSTYPES, &size);
+
+	if (rc != EOK) {
+		vfs_exchange_end(exch);
+		return rc;
+	}
+
+	buf = malloc(size);
+	if (buf == NULL) {
+		buf = dummybuf;
+		size = 1;
+	}
+
+	rc = async_data_read_start(exch, buf, size);
+	vfs_exchange_end(exch);
+
+	if (buf == dummybuf)
+		return ENOMEM;
+
+	/*
+	 * Buffer should contain a number of null-terminated strings.
+	 * Count them so that we can allocate an index
+	 */
+	count = 0;
+	i = 0;
+	while (i < size) {
+		if (buf[i] == '\0')
+			++count;
+		++i;
+	}
+
+	if (count == 0) {
+		free(buf);
+		return EIO;
+	}
+
+	fstypes->fstypes = calloc(sizeof(char *), count + 1);
+	if (fstypes->fstypes == NULL) {
+		free(buf);
+		return ENOMEM;
+	}
+
+	/* Now fill the index */
+	if (buf[0] != '\0')
+		fstypes->fstypes[0] = &buf[0];
+	count = 0;
+	i = 0;
+	while (i < size) {
+		if (buf[i] == '\0')
+			fstypes->fstypes[++count] = &buf[i + 1];
+		++i;
+	}
+	fstypes->fstypes[count] = NULL;
+	fstypes->buf = buf;
+	fstypes->size = size;
+
+	return rc;
+}
+
+/** Free list of file system types.
+ *
+ * @param fstypes List of file system types
+ */
+void vfs_fstypes_free(vfs_fstypes_t *fstypes)
+{
+	free(fstypes->buf);
+	fstypes->buf = NULL;
+	free(fstypes->fstypes);
+	fstypes->fstypes = NULL;
+	fstypes->size = 0;
 }
 
Index: uspace/lib/c/include/errno.h
===================================================================
--- uspace/lib/c/include/errno.h	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/lib/c/include/errno.h	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -55,4 +55,5 @@
 #define EMLINK        (-267)
 #define ENXIO         (-268)
+#define ENOFS         (-269)
 
 /** Bad checksum. */
Index: uspace/lib/c/include/ipc/vfs.h
===================================================================
--- uspace/lib/c/include/ipc/vfs.h	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/lib/c/include/ipc/vfs.h	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -64,4 +64,5 @@
 typedef enum {
 	VFS_IN_CLONE = IPC_FIRST_USER_METHOD,
+	VFS_IN_FSTYPES,
 	VFS_IN_MOUNT,
 	VFS_IN_OPEN,
Index: uspace/lib/c/include/vfs/vfs.h
===================================================================
--- uspace/lib/c/include/vfs/vfs.h	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/lib/c/include/vfs/vfs.h	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -73,4 +73,11 @@
 };
 
+/** List of file system types */
+typedef struct {
+	char **fstypes;
+	char *buf;
+	size_t size;
+} vfs_fstypes_t;
+
 extern int vfs_fhandle(FILE *, int *);
 
@@ -81,4 +88,6 @@
 extern async_exch_t *vfs_exchange_begin(void);
 extern void vfs_exchange_end(async_exch_t *);
+extern int vfs_fstypes(vfs_fstypes_t *);
+extern void vfs_fstypes_free(vfs_fstypes_t *);
 extern int vfs_link(int, const char *, vfs_file_kind_t, int *);
 extern int vfs_link_path(const char *, vfs_file_kind_t, int *);
Index: uspace/srv/vfs/vfs.h
===================================================================
--- uspace/srv/vfs/vfs.h	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/srv/vfs/vfs.h	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -43,4 +43,5 @@
 #include <ipc/vfs.h>
 #include <task.h>
+#include <vfs/vfs.h>
 
 #ifndef dprintf
@@ -174,4 +175,5 @@
 extern fs_handle_t fs_name_to_handle(unsigned int instance, const char *, bool);
 extern vfs_info_t *fs_handle_to_info(fs_handle_t);
+extern int vfs_get_fstypes(vfs_fstypes_t *);
 
 extern int vfs_lookup_internal(vfs_node_t *, char *, int, vfs_lookup_res_t *);
Index: uspace/srv/vfs/vfs_ipc.c
===================================================================
--- uspace/srv/vfs/vfs_ipc.c	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/srv/vfs/vfs_ipc.c	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -27,4 +27,5 @@
  */
 
+#include <vfs/vfs.h>
 #include "vfs.h"
 
@@ -42,4 +43,32 @@
 	int ret = vfs_op_clone(oldfd, newfd, desc);
 	async_answer_0(rid, ret);
+}
+
+static void vfs_in_fstypes(ipc_callid_t rid, ipc_call_t *request)
+{
+	ipc_callid_t callid;
+	size_t len;
+	vfs_fstypes_t fstypes;
+	int rc;
+
+	rc = vfs_get_fstypes(&fstypes);
+	if (rc != EOK) {
+		async_answer_0(rid, ENOMEM);
+		return;
+	}
+
+	/* Send size of the data */
+	async_answer_1(rid, EOK, fstypes.size);
+
+	/* Now we should get a read request */
+	if (!async_data_read_receive(&callid, &len))
+		goto out;
+
+	if (len > fstypes.size)
+		len = fstypes.size;
+	(void) async_data_read_finalize(callid, fstypes.buf, len);
+
+out:
+	vfs_fstypes_free(&fstypes);
 }
 
@@ -268,4 +297,7 @@
 			vfs_in_clone(callid, &call);
 			break;
+		case VFS_IN_FSTYPES:
+			vfs_in_fstypes(callid, &call);
+			break;
 		case VFS_IN_MOUNT:
 			vfs_in_mount(callid, &call);
Index: uspace/srv/vfs/vfs_ops.c
===================================================================
--- uspace/srv/vfs/vfs_ops.c	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/srv/vfs/vfs_ops.c	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -147,5 +147,5 @@
 
 	if (fs_handle == 0)
-		return ENOENT;
+		return ENOFS;
 	
 	/* Tell the mountee that it is being mounted. */
Index: uspace/srv/vfs/vfs_register.c
===================================================================
--- uspace/srv/vfs/vfs_register.c	(revision f2338407dd7bc780955a89da886fff9b8c761691)
+++ uspace/srv/vfs/vfs_register.c	(revision b14d9f9e108f8cacda71d80e4c69fc82509d9824)
@@ -50,4 +50,5 @@
 #include <assert.h>
 #include <atomic.h>
+#include <vfs/vfs.h>
 #include "vfs.h"
 
@@ -340,4 +341,58 @@
 }
 
+/** Get list of file system types.
+ *
+ * @param fstypes Place to store list of file system types. Free using
+ *                vfs_fstypes_free().
+ *
+ * @return EOK on success or negative error code
+ */
+int vfs_get_fstypes(vfs_fstypes_t *fstypes)
+{
+	size_t size;
+	size_t count;
+	size_t l;
+
+	fibril_mutex_lock(&fs_list_lock);
+	
+	size = 0;
+	count = 0;
+	list_foreach(fs_list, fs_link, fs_info_t, fs) {
+		size += str_size(fs->vfs_info.name) + 1;
+		count++;
+	}
+	
+	if (size == 0)
+		size = 1;
+	
+	fstypes->buf = calloc(1, size);
+	if (fstypes->buf == NULL) {
+		fibril_mutex_unlock(&fs_list_lock);
+		return ENOMEM;
+	}
+	
+	fstypes->fstypes = calloc(sizeof(char *), count);
+	if (fstypes->fstypes == NULL) {
+		free(fstypes->buf);
+		fstypes->buf = NULL;
+		fibril_mutex_unlock(&fs_list_lock);
+		return ENOMEM;
+	}
+	
+	fstypes->size = size;
+	
+	size = 0; count = 0;
+	list_foreach(fs_list, fs_link, fs_info_t, fs) {
+		l = str_size(fs->vfs_info.name) + 1;
+		memcpy(fstypes->buf + size, fs->vfs_info.name, l);
+		fstypes->fstypes[count] = &fstypes->buf[size];
+		size += l;
+		count++;
+	}
+
+	fibril_mutex_unlock(&fs_list_lock);
+	return EOK;
+}
+
 /**
  * @}