Index: uspace/app/fdisk/fdisk.c
===================================================================
--- uspace/app/fdisk/fdisk.c	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/app/fdisk/fdisk.c	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -520,5 +520,5 @@
 		/* Ask for volume label */
 		printf("Enter volume label for new partition.\n");
-		rc = tinput_read_i(tinput, "No name", &label);
+		rc = tinput_read_i(tinput, "New volume", &label);
 		if (rc != EOK)
 			goto error;
Index: uspace/app/mkexfat/exfat.h
===================================================================
--- uspace/app/mkexfat/exfat.h	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/app/mkexfat/exfat.h	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -37,4 +37,5 @@
 #define EXFAT_FILENAME_LEN	255
 #define EXFAT_NAME_PART_LEN	15
+#define EXFAT_VOLLABEL_LEN	11
 
 #define EXFAT_TYPE_UNUSED	0x00
Index: uspace/app/mkexfat/mkexfat.c
===================================================================
--- uspace/app/mkexfat/mkexfat.c	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/app/mkexfat/mkexfat.c	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -101,6 +101,6 @@
 	size_t   sector_size;
 	size_t   cluster_size;
+	const char *label;
 } exfat_cfg_t;
-
 
 static unsigned log2(unsigned n);
@@ -126,4 +126,5 @@
 	{"cluster-size", required_argument, 0, 'c'},
 	{"fs-size", required_argument, 0, 's'},
+	{"label", required_argument, 0, 'L' },
 };
 
@@ -132,5 +133,6 @@
 	printf("Usage: mkexfat [options] <device>\n"
 	    "-c, --cluster-size ## Specify the cluster size (Kb)\n"
-	    "-s, --fs-size ##      Specify the filesystem size (sectors)\n");
+	    "-s, --fs-size ##      Specify the filesystem size (sectors)\n"
+	    "    --label ##        Volume label\n");
 }
 
@@ -597,4 +599,5 @@
 	exfat_dentry_t *d;
 	aoff64_t rootdir_sec;
+	uint16_t wlabel[EXFAT_VOLLABEL_LEN + 1];
 	int rc;
 	uint8_t *data;
@@ -608,9 +611,22 @@
 
 	/* Initialize the volume label dentry */
-	d->type = EXFAT_TYPE_VOLLABEL;
-	str_to_utf16(d->vollabel.label, 8, "HELENOS ");
-	d->vollabel.size = 8;
-
-	d++;
+
+	if (cfg->label != NULL) {
+		memset(wlabel, 0, (EXFAT_VOLLABEL_LEN + 1) * sizeof(uint16_t));
+		rc = str_to_utf16(wlabel, EXFAT_VOLLABEL_LEN + 1, cfg->label);
+		if (rc != EOK) {
+			rc = EINVAL;
+			goto exit;
+		}
+
+		d->type = EXFAT_TYPE_VOLLABEL;
+		memcpy(d->vollabel.label, wlabel, EXFAT_VOLLABEL_LEN * 2);
+		d->vollabel.size = utf16_wsize(wlabel);
+		assert(d->vollabel.size <= EXFAT_VOLLABEL_LEN);
+
+		d++;
+	} else {
+		d->type = EXFAT_TYPE_VOLLABEL & ~EXFAT_TYPE_USED;
+	}
 
 	/* Initialize the allocation bitmap dentry */
@@ -751,7 +767,8 @@
 
 	cfg.cluster_size = 0;
+	cfg.label = NULL;
 
 	for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-		c = getopt_long(argc, argv, "hs:c:",
+		c = getopt_long(argc, argv, "hs:c:L:",
 		    long_options, &opt_ind);
 		switch (c) {
@@ -781,4 +798,7 @@
 			}
 			break;
+		case 'L':
+			cfg.label = optarg;
+			break;
 		}
 	}
Index: uspace/srv/fs/exfat/exfat_dentry.c
===================================================================
--- uspace/srv/fs/exfat/exfat_dentry.c	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/srv/fs/exfat/exfat_dentry.c	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -90,5 +90,5 @@
 void exfat_dentry_get_name(const exfat_name_dentry_t *name, size_t size, uint16_t *dst, size_t *offset)
 {
-	size_t i = 0; 
+	size_t i = 0;
 	while (i < EXFAT_NAME_PART_LEN && *offset < size) {
 		dst[*offset] = uint16_t_le2host(name->name[i]);
@@ -97,4 +97,15 @@
 	}
 	dst[*offset] = '\0';
+}
+
+void exfat_dentry_get_vollabel(const exfat_vollabel_dentry_t *vollabel,
+    size_t size, uint16_t *dst)
+{
+	size_t i = 0;
+	while (i < EXFAT_VOLLABEL_LEN && i < vollabel->size && i < size) {
+		dst[i] = uint16_t_le2host(vollabel->label[i]);
+		i++;
+	}
+	dst[i] = '\0';
 }
 
Index: uspace/srv/fs/exfat/exfat_dentry.h
===================================================================
--- uspace/srv/fs/exfat/exfat_dentry.h	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/srv/fs/exfat/exfat_dentry.h	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -40,4 +40,5 @@
 #define EXFAT_FILENAME_LEN	255
 #define EXFAT_NAME_PART_LEN	15
+#define EXFAT_VOLLABEL_LEN	11
 
 #define EXFAT_TYPE_UNUSED	0x00
@@ -156,8 +157,12 @@
 extern void exfat_dentry_get_name(const exfat_name_dentry_t *, size_t,
     uint16_t *, size_t *);
-
+extern void exfat_dentry_get_vollabel(const exfat_vollabel_dentry_t *, size_t,
+    uint16_t *);
 
 extern bool exfat_valid_char(wchar_t);
 extern bool exfat_valid_name(const char *);
+
+extern size_t exfat_utf16_length(const uint16_t *);
+
 
 #endif
Index: uspace/srv/fs/exfat/exfat_directory.c
===================================================================
--- uspace/srv/fs/exfat/exfat_directory.c	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/srv/fs/exfat/exfat_directory.c	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -260,4 +260,32 @@
 }
 
+int exfat_directory_read_vollabel(exfat_directory_t *di, char *label,
+    size_t size)
+{
+	uint16_t wlabel[EXFAT_VOLLABEL_LEN + 1];
+	exfat_dentry_t *d = NULL;
+	int rc;
+	aoff64_t start_pos = 0;
+
+	start_pos = di->pos;
+
+	rc = exfat_directory_seek(di, 0);
+	if (rc != EOK)
+		return rc;
+
+	rc = exfat_directory_find(di, EXFAT_DENTRY_VOLLABEL, &d);
+	if (rc != EOK)
+		return rc;
+
+	exfat_dentry_get_vollabel(&d->vollabel, EXFAT_VOLLABEL_LEN, wlabel);
+
+	rc = utf16_to_str(label, size, wlabel);
+	if (rc != EOK)
+		return rc;
+
+	exfat_directory_seek(di, start_pos);
+	return EOK;
+}
+
 static uint16_t exfat_directory_set_checksum(const uint8_t *bytes, size_t count)
 {
Index: uspace/srv/fs/exfat/exfat_directory.h
===================================================================
--- uspace/srv/fs/exfat/exfat_directory.h	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/srv/fs/exfat/exfat_directory.h	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -71,8 +71,10 @@
 extern int exfat_directory_read_file(exfat_directory_t *, char *, size_t,
     exfat_file_dentry_t *, exfat_stream_dentry_t *);
+extern int exfat_directory_read_vollabel(exfat_directory_t *, char *, size_t);
 extern int exfat_directory_sync_file(exfat_directory_t *, exfat_file_dentry_t *,
     exfat_stream_dentry_t *);
 extern int exfat_directory_write_file(exfat_directory_t *, const char *);
 extern int exfat_directory_erase_file(exfat_directory_t *, aoff64_t);
+
 
 extern int exfat_directory_expand(exfat_directory_t *);
Index: uspace/srv/fs/exfat/exfat_ops.c
===================================================================
--- uspace/srv/fs/exfat/exfat_ops.c	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/srv/fs/exfat/exfat_ops.c	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -1013,4 +1013,218 @@
 };
 
+static int exfat_fs_open(service_id_t service_id, enum cache_mode cmode,
+    fs_node_t **rrfn, exfat_idx_t **rridxp, vfs_fs_probe_info_t *info)
+{
+	int rc;
+	exfat_node_t *rootp = NULL, *bitmapp = NULL, *uctablep = NULL;
+	exfat_bs_t *bs;
+
+	/* initialize libblock */
+	rc = block_init(service_id, BS_SIZE);
+	if (rc != EOK)
+		return rc;
+
+	/* prepare the boot block */
+	rc = block_bb_read(service_id, BS_BLOCK);
+	if (rc != EOK) {
+		block_fini(service_id);
+		return rc;
+	}
+
+	/* get the buffer with the boot sector */
+	bs = block_bb_get(service_id);
+
+	/* Do some simple sanity checks on the file system. */
+	rc = exfat_sanity_check(bs);
+	if (rc != EOK) {
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		return rc;
+	}
+
+	/* Initialize the block cache */
+	rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
+	if (rc != EOK) {
+		block_fini(service_id);
+		return rc;
+	}
+
+	rc = exfat_idx_init_by_service_id(service_id);
+	if (rc != EOK) {
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		return rc;
+	}
+
+	/* Initialize the root node. */
+	rc = exfat_node_get_new_by_pos(&rootp, service_id, EXFAT_ROOT_PAR, 
+	    EXFAT_ROOT_POS);
+	if (rc!=EOK) {
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOMEM;
+	}
+	assert(rootp->idx->index == EXFAT_ROOT_IDX);
+
+	rootp->type = EXFAT_DIRECTORY;
+	rootp->firstc = ROOT_FC(bs);
+	rootp->fragmented = true;
+	rootp->refcnt = 1;
+	rootp->lnkcnt = 0;	/* FS root is not linked */
+
+	uint32_t clusters;
+	rc = exfat_clusters_get(&clusters, bs, service_id, rootp->firstc);
+	if (rc != EOK) {
+		free(rootp);
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOTSUP;
+	}
+	rootp->size = BPS(bs) * SPC(bs) * clusters;
+	fibril_mutex_unlock(&rootp->idx->lock);
+
+	/* Open root directory and looking for Bitmap and UC-Table */
+	exfat_directory_t di;
+	exfat_dentry_t *de;
+	rc = exfat_directory_open(rootp, &di);
+	if (rc != EOK) {
+		free(rootp);
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOTSUP;
+	}
+
+	/* Initialize the bitmap node. */
+	rc = exfat_directory_find(&di, EXFAT_DENTRY_BITMAP, &de);
+	if (rc != EOK) {
+		free(rootp);
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOTSUP;
+	}
+
+	rc = exfat_node_get_new_by_pos(&bitmapp, service_id, rootp->firstc, 
+	    di.pos);
+	if (rc != EOK) {
+		free(rootp);
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOMEM;
+	}
+	assert(bitmapp->idx->index == EXFAT_BITMAP_IDX);
+	fibril_mutex_unlock(&bitmapp->idx->lock);
+
+	bitmapp->type = EXFAT_BITMAP;
+	bitmapp->firstc = uint32_t_le2host(de->bitmap.firstc);
+	bitmapp->fragmented = true;
+	bitmapp->idx->parent_fragmented = true;
+	bitmapp->refcnt = 1;
+	bitmapp->lnkcnt = 0;
+	bitmapp->size = uint64_t_le2host(de->bitmap.size);
+
+	/* Initialize the uctable node. */
+	rc = exfat_directory_seek(&di, 0);
+	if (rc != EOK) {
+		free(rootp);
+		free(bitmapp);
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOTSUP;
+	}
+
+	rc = exfat_directory_find(&di, EXFAT_DENTRY_UCTABLE, &de);
+	if (rc != EOK) {
+		free(rootp);
+		free(bitmapp);
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOTSUP;
+	}
+
+	rc = exfat_node_get_new_by_pos(&uctablep, service_id, rootp->firstc, 
+	    di.pos);
+	if (rc != EOK) {
+		free(rootp);
+		free(bitmapp);
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOMEM;
+	}
+	assert(uctablep->idx->index == EXFAT_UCTABLE_IDX);
+	fibril_mutex_unlock(&uctablep->idx->lock);
+
+	uctablep->type = EXFAT_UCTABLE;
+	uctablep->firstc = uint32_t_le2host(de->uctable.firstc);
+	uctablep->fragmented = true;
+	uctablep->idx->parent_fragmented = true;
+	uctablep->refcnt = 1;
+	uctablep->lnkcnt = 0;
+	uctablep->size = uint64_t_le2host(de->uctable.size);
+
+	if (info != NULL) {
+		/* Read volume label. */
+		rc = exfat_directory_read_vollabel(&di, info->label,
+		    FS_LABEL_MAXLEN + 1);
+		if (rc != EOK) {
+			free(rootp);
+			free(bitmapp);
+			free(uctablep);
+			(void) block_cache_fini(service_id);
+			block_fini(service_id);
+			exfat_idx_fini_by_service_id(service_id);
+    		    return ENOTSUP;
+		}
+	}
+
+	rc = exfat_directory_close(&di);
+	if (rc != EOK) {
+		free(rootp);
+		free(bitmapp);
+		free(uctablep);
+		(void) block_cache_fini(service_id);
+		block_fini(service_id);
+		exfat_idx_fini_by_service_id(service_id);
+		return ENOMEM;
+	}
+
+	/* exfat_fsinfo(bs, service_id); */
+
+	*rrfn = FS_NODE(rootp);
+	*rridxp = rootp->idx;
+
+	if (info != NULL) {
+//		str_cpy(info->label, FS_LABEL_MAXLEN + 1, label);
+	}
+
+	return EOK;
+}
+
+static void exfat_fs_close(service_id_t service_id, fs_node_t *rfn)
+{
+	/*
+	 * Put the root node and force it to the FAT free node list.
+	 */
+	(void) exfat_node_put(rfn);
+	(void) exfat_node_put(rfn);
+
+	/*
+	 * Perform cleanup of the node structures, index structures and
+	 * associated data. Write back this file system's dirty blocks and
+	 * stop using libblock for this instance.
+	 */
+	(void) exfat_node_fini_by_service_id(service_id);
+	exfat_idx_fini_by_service_id(service_id);
+	(void) block_cache_fini(service_id);
+	block_fini(service_id);
+}
+
 
 /*
@@ -1054,27 +1268,13 @@
 {
 	int rc;
-	exfat_bs_t *bs;
-
-	/* initialize libblock */
-	rc = block_init(service_id, BS_SIZE);
-	if (rc != EOK)
-		return rc;
-
-	/* prepare the boot block */
-	rc = block_bb_read(service_id, BS_BLOCK);
-	if (rc != EOK) {
-		block_fini(service_id);
-		return rc;
-	}
-
-	/* get the buffer with the boot sector */
-	bs = block_bb_get(service_id);
-
-	/* Do some simple sanity checks on the file system. */
-	rc = exfat_sanity_check(bs);
-
-	(void) block_cache_fini(service_id);
-	block_fini(service_id);
-	return rc;
+	exfat_idx_t *ridxp;
+	fs_node_t *rfn;
+
+	rc = exfat_fs_open(service_id, CACHE_MODE_WT, &rfn, &ridxp, info);
+	if (rc != EOK)
+		return rc;
+
+	exfat_fs_close(service_id, rfn);
+	return EOK;
 }
 
@@ -1084,7 +1284,7 @@
 {
 	int rc;
-	exfat_node_t *rootp = NULL, *bitmapp = NULL, *uctablep = NULL;
 	enum cache_mode cmode;
-	exfat_bs_t *bs;
+	exfat_idx_t *ridxp;
+	fs_node_t *rfn;
 
 	/* Check for option enabling write through. */
@@ -1094,170 +1294,11 @@
 		cmode = CACHE_MODE_WB;
 
-	/* initialize libblock */
-	rc = block_init(service_id, BS_SIZE);
-	if (rc != EOK)
-		return rc;
-
-	/* prepare the boot block */
-	rc = block_bb_read(service_id, BS_BLOCK);
-	if (rc != EOK) {
-		block_fini(service_id);
-		return rc;
-	}
-
-	/* get the buffer with the boot sector */
-	bs = block_bb_get(service_id);
-
-	/* Do some simple sanity checks on the file system. */
-	rc = exfat_sanity_check(bs);
-	if (rc != EOK) {
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		return rc;
-	}
-
-	/* Initialize the block cache */
-	rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
-	if (rc != EOK) {
-		block_fini(service_id);
-		return rc;
-	}
-
-	rc = exfat_idx_init_by_service_id(service_id);
-	if (rc != EOK) {
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		return rc;
-	}
-
-	/* Initialize the root node. */
-	rc = exfat_node_get_new_by_pos(&rootp, service_id, EXFAT_ROOT_PAR, 
-	    EXFAT_ROOT_POS);
-	if (rc!=EOK) {
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOMEM;
-	}
-	assert(rootp->idx->index == EXFAT_ROOT_IDX);
-
-	rootp->type = EXFAT_DIRECTORY;
-	rootp->firstc = ROOT_FC(bs);
-	rootp->fragmented = true;
-	rootp->refcnt = 1;
-	rootp->lnkcnt = 0;	/* FS root is not linked */
-
-	uint32_t clusters;
-	rc = exfat_clusters_get(&clusters, bs, service_id, rootp->firstc);
-	if (rc != EOK) {
-		free(rootp);
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOTSUP;
-	}
-	rootp->size = BPS(bs) * SPC(bs) * clusters;
-	fibril_mutex_unlock(&rootp->idx->lock);
-
-	/* Open root directory and looking for Bitmap and UC-Table */
-	exfat_directory_t di;
-	exfat_dentry_t *de;
-	rc = exfat_directory_open(rootp, &di);
-	if (rc != EOK) {
-		free(rootp);
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOTSUP;
-	}
-
-	/* Initialize the bitmap node. */
-	rc = exfat_directory_find(&di, EXFAT_DENTRY_BITMAP, &de);
-	if (rc != EOK) {
-		free(rootp);
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOTSUP;
-	}
-
-	rc = exfat_node_get_new_by_pos(&bitmapp, service_id, rootp->firstc, 
-	    di.pos);
-	if (rc != EOK) {
-		free(rootp);
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOMEM;
-	}
-	assert(bitmapp->idx->index == EXFAT_BITMAP_IDX);
-	fibril_mutex_unlock(&bitmapp->idx->lock);
-
-	bitmapp->type = EXFAT_BITMAP;
-	bitmapp->firstc = uint32_t_le2host(de->bitmap.firstc);
-	bitmapp->fragmented = true;
-	bitmapp->idx->parent_fragmented = true;
-	bitmapp->refcnt = 1;
-	bitmapp->lnkcnt = 0;
-	bitmapp->size = uint64_t_le2host(de->bitmap.size);
-
-	/* Initialize the uctable node. */
-	rc = exfat_directory_seek(&di, 0);
-	if (rc != EOK) {
-		free(rootp);
-		free(bitmapp);
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOTSUP;
-	}
-
-	rc = exfat_directory_find(&di, EXFAT_DENTRY_UCTABLE, &de);
-	if (rc != EOK) {
-		free(rootp);
-		free(bitmapp);
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOTSUP;
-	}
-
-	rc = exfat_node_get_new_by_pos(&uctablep, service_id, rootp->firstc, 
-	    di.pos);
-	if (rc != EOK) {
-		free(rootp);
-		free(bitmapp);
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOMEM;
-	}
-	assert(uctablep->idx->index == EXFAT_UCTABLE_IDX);
-	fibril_mutex_unlock(&uctablep->idx->lock);
-
-	uctablep->type = EXFAT_UCTABLE;
-	uctablep->firstc = uint32_t_le2host(de->uctable.firstc);
-	uctablep->fragmented = true;
-	uctablep->idx->parent_fragmented = true;
-	uctablep->refcnt = 1;
-	uctablep->lnkcnt = 0;
-	uctablep->size = uint64_t_le2host(de->uctable.size);
-
-	rc = exfat_directory_close(&di);
-	if (rc != EOK) {
-		free(rootp);
-		free(bitmapp);
-		free(uctablep);
-		(void) block_cache_fini(service_id);
-		block_fini(service_id);
-		exfat_idx_fini_by_service_id(service_id);
-		return ENOMEM;
-	}
-
-	/* exfat_fsinfo(bs, service_id); */
-
-	*index = rootp->idx->index;
-	*size = rootp->size;
-	
+	rc = exfat_fs_open(service_id, cmode, &rfn, &ridxp, NULL);
+	if (rc != EOK)
+		return rc;
+
+	*index = ridxp->index;
+	*size = EXFAT_NODE(rfn)->size;
+
 	return EOK;
 }
@@ -1265,38 +1306,12 @@
 static int exfat_unmounted(service_id_t service_id)
 {
-	fs_node_t *fn;
-	exfat_node_t *nodep;
-	int rc;
-
-	rc = exfat_root_get(&fn, service_id);
-	if (rc != EOK)
-		return rc;
-	nodep = EXFAT_NODE(fn);
-
-	/*
-	 * We expect exactly two references on the root node. One for the
-	 * fat_root_get() above and one created in fat_mounted().
-	 */
-	if (nodep->refcnt != 2) {
-		(void) exfat_node_put(fn);
-		return EBUSY;
-	}
-
-	/*
-	 * Put the root node and force it to the FAT free node list.
-	 */
-	(void) exfat_node_put(fn);
-	(void) exfat_node_put(fn);
-
-	/*
-	 * Perform cleanup of the node structures, index structures and
-	 * associated data. Write back this file system's dirty blocks and
-	 * stop using libblock for this instance.
-	 */
-	(void) exfat_node_fini_by_service_id(service_id);
-	exfat_idx_fini_by_service_id(service_id);
-	(void) block_cache_fini(service_id);
-	block_fini(service_id);
-
+	fs_node_t *rfn;
+	int rc;
+
+	rc = exfat_root_get(&rfn, service_id);
+	if (rc != EOK)
+		return rc;
+
+	exfat_fs_close(service_id, rfn);
 	return EOK;
 }
@@ -1363,5 +1378,5 @@
 			return ENOTSUP;
 		}
-			
+
 		aoff64_t spos = pos;
 		char name[EXFAT_FILENAME_LEN + 1];
Index: uspace/srv/volsrv/mkfs.c
===================================================================
--- uspace/srv/volsrv/mkfs.c	(revision b2906c096fbedc1a9cbec10ad51c63e093dd375c)
+++ uspace/srv/volsrv/mkfs.c	(revision f3504c1213f39d4c7cce79c5673a64b0e2d420ba)
@@ -146,8 +146,8 @@
 
 	switch (fstype) {
+	case fs_exfat:
 	case fs_fat:
 		vlsupp->supported = true;
 		break;
-	case fs_exfat:
 	case fs_minix:
 	case fs_ext4:
