From 9194bf70bae623aa1be35919879585d6fbbff516 Mon Sep 17 00:00:00 2001
From: sekaiacg <sekaiacg@gmail.com>
Date: Mon, 27 Jun 2022 17:07:30 +0800
Subject: [PATCH] exfat: Update exfat to 1.3.0

https: //github.com/relan/exfat

Change-Id: I4992542cacc191c23eb68d276e1e5cbfafc0084e
(cherry picked from commit 2598c3933c69ca4361182e379fc87327f327fc0d)
---

diff --git a/exfat/ChangeLog b/exfat/ChangeLog
index d6f99d0..9e20bf5 100644
--- a/exfat/ChangeLog
+++ b/exfat/ChangeLog
@@ -1,3 +1,52 @@
+1.3.0 (2018-09-15)
+
+* exfatfsck can now repair some errors.
+* Added experimental Android support for exfat-utils [liminghao, LongPingWEI,
+Pablo Mendez Hernandez, Pierre-Hugues Husson].
+* Cleaned up FUSE code preparing for FUSE 3 support.
+* Removed OpenBSD support as it does not handle -o option in fuse_main().
+* Re-introduced FreeBSD support [Oleksii Samorukov].
+* Fixed DragonFly BSD support [Tomohiro Kusumi].
+* dirent->d_type in now filled on readdir() [Mark Browning].
+
+1.2.8 (2018-02-03)
+
+* Fixed new files or directories creation in the root directory: ensure there
+are no 0x00 entries before valid ones; otherwise Windows can corrupt them.
+* Fixed compilation on GNU/HURD platform.
+
+1.2.7 (2017-06-05)
+
+* Fixed handling of two last clusters: operations with files that occupy these
+clusters could fail.
+* Fixed crash when started with stdin, stdout or stderr closed.
+
+1.2.6 (2017-01-28)
+
+* Operations with directories (except initial listing) now make less
+read/write system calls.
+* Fixed handling of files with optional tail entries (0xe0-0xff): videoclip
+files created by Sony cameras were missing.
+* Write operations now correctly return ENOSPC (instead of EIO) when there is
+no free disk space left.
+* Fixed max file name length: it's 255 16-bit code units (not 256).
+
+1.2.5 (2016-12-05)
+
+* Added an option for dumpexfat to show file fragments [Daniel Drake].
+* Fixed crash when directory starts with an invalid cluster.
+* Daylight saving time in now properly reflected in file timestamps.
+
+1.2.4 (2016-06-03)
+
+* Fixed wrong files names hashes when upper case table is compressed.
+* Man pages are now installed by default.
+* Commas and backslashes in device names are now escaped.
+
+1.2.3 (2015-12-19)
+
+* Fixed clusters loss when file renaming replaces target.
+
 1.2.2 (2015-11-09)
 
 * Improved reliability in case of a sudden unplug: FS will be in a clean state
diff --git a/exfat/README.md b/exfat/README.md
index 3cf58b7..b012eca 100644
--- a/exfat/README.md
+++ b/exfat/README.md
@@ -8,53 +8,76 @@
 * GNU/Linux
 * Mac OS X 10.5 or later
 * FreeBSD
-* OpenBSD
 
 Most GNU/Linux distributions already have fuse-exfat and exfat-utils in their repositories, so you can just install and use them. The next chapter describes how to compile them from source.
 
 Compiling
 ---------
 
-To build this project under GNU/Linux you need to install the following packages:
+To build this project on GNU/Linux you need to install the following packages:
 
-* git
+* [git][4]
+* [autoconf][5]
+* [automake][6]
+* [pkg-config][7]
+* fuse-devel (or libfuse-dev)
+* [gcc][8]
+* [make][9]
+
+On Mac OS X:
+
 * autoconf
 * automake
 * pkg-config
-* fuse-devel (or libfuse-dev)
-* gcc
-* make
+* [OSXFUSE][10]
+* [Xcode][11] (legacy versions include autotools but their versions are too old)
+
+On OpenBSD:
+
+* git
+* autoconf (set AUTOCONF_VERSION environment variable)
+* automake (set AUTOMAKE_VERSION environment variable)
 
 Get the source code, change directory and compile:
 
     git clone https://github.com/relan/exfat.git
     cd exfat
     autoreconf --install
-    ./configure --prefix=/usr
+    ./configure
     make
 
-Then install driver and utilities:
+Then install driver and utilities (from root):
 
-    sudo make install
+    make install
 
-You can remove them using this command:
+You can remove them using this command (from root):
 
-    sudo make uninstall
+    make uninstall
 
 Mounting
 --------
 
-Modern GNU/Linux distributions will mount exFAT volumes automatically—util-linux-ng 2.18 (was renamed to util-linux in 2.19) is required for this. Anyway, you can mount manually (you will need root privileges):
+Modern GNU/Linux distributions (with [util-linux][12] 2.18 or later) will mount exFAT volumes automatically. Anyway, you can mount manually (from root):
 
-    sudo mount.exfat-fuse /dev/sdXn /mnt/exfat
+    mount.exfat-fuse /dev/spec /mnt/exfat
 
-where /dev/sdXn is the partition special file, /mnt/exfat is a mountpoint.
+where /dev/spec is the [device file][13], /mnt/exfat is a mountpoint.
 
 Feedback
 --------
 
 If you have any questions, issues, suggestions, bug reports, etc. please create an [issue][3]. Pull requests are also welcome!
 
-[1]: http://en.wikipedia.org/wiki/ExFAT
-[2]: http://en.wikipedia.org/wiki/Filesystem_in_Userspace
+[1]: https://en.wikipedia.org/wiki/ExFAT
+[2]: https://en.wikipedia.org/wiki/Filesystem_in_Userspace
 [3]: https://github.com/relan/exfat/issues
+[4]: https://www.git-scm.com/
+[5]: https://www.gnu.org/software/autoconf/
+[6]: https://www.gnu.org/software/automake/
+[7]: http://www.freedesktop.org/wiki/Software/pkg-config/
+[8]: https://gcc.gnu.org/
+[9]: https://www.gnu.org/software/make/
+[10]: https://osxfuse.github.io/
+[11]: https://en.wikipedia.org/wiki/Xcode
+[12]: https://www.kernel.org/pub/linux/utils/util-linux/
+[13]: https://en.wikipedia.org/wiki/Device_file
diff --git a/exfat/dump/dumpexfat.8 b/exfat/dump/dumpexfat.8
index 5cf3995..06022a5 100644
--- a/exfat/dump/dumpexfat.8
+++ b/exfat/dump/dumpexfat.8
@@ -1,6 +1,6 @@
-.\" Copyright (C) 2011-2015  Andrew Nayenko
+.\" Copyright (C) 2011-2018  Andrew Nayenko
 .\"
-.TH DUMPEXFAT 8 "February 2011"
+.TH DUMPEXFAT 8 "July 2016"
 .SH NAME
 .B dumpexfat
 \- dump exFAT file system
@@ -13,6 +13,10 @@
 .B \-u
 ]
 [
+.B \-f
+.I file
+]
+[
 .B \-V
 ]
 .I device
@@ -33,6 +37,11 @@
 Dump ranges of used sectors starting from 0 and separated with spaces. May be
 useful for backup tools.
 .TP
+.B \-f file
+Print out a list of fragments that compose the given file. Each fragment is
+printed on its own line, as the start offset (in bytes) into the file system,
+and the length (in bytes).
+.TP
 .BI \-V
 Print version and copyright.
 
diff --git a/exfat/dump/main.c b/exfat/dump/main.c
index 3ed3d8f..4f562f3 100644
--- a/exfat/dump/main.c
+++ b/exfat/dump/main.c
@@ -3,7 +3,7 @@
 	Prints detailed information about exFAT volume.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -106,7 +106,7 @@
 
 static void dump_sectors(struct exfat* ef)
 {
-	loff_t a = 0, b = 0;
+	off_t a = 0, b = 0;
 
 	printf("Used sectors ");
 	while (exfat_find_used_sectors(ef, &a, &b) == 0)
@@ -140,9 +140,66 @@
 	return 0;
 }
 
+static int dump_file_fragments(const char* spec, const char* path)
+{
+	struct exfat ef;
+	struct exfat_node* node;
+	cluster_t cluster;
+	cluster_t next_cluster;
+	cluster_t fragment_start_cluster;
+	off_t remainder;
+	off_t fragment_size = 0;
+	int rc = 0;
+
+	if (exfat_mount(&ef, spec, "ro") != 0)
+		return 1;
+
+	rc = exfat_lookup(&ef, &node, path);
+	if (rc != 0)
+	{
+		exfat_unmount(&ef);
+		exfat_error("'%s': %s", path, strerror(-rc));
+		return 1;
+	}
+
+	cluster = fragment_start_cluster = node->start_cluster;
+	remainder = node->size;
+	while (remainder > 0)
+	{
+		off_t lsize;
+
+		if (CLUSTER_INVALID(*ef.sb, cluster))
+		{
+			exfat_error("'%s' has invalid cluster %#x", path, cluster);
+			rc = 1;
+			break;
+		}
+
+		lsize = MIN(CLUSTER_SIZE(*ef.sb), remainder);
+		fragment_size += lsize;
+		remainder -= lsize;
+
+		next_cluster = exfat_next_cluster(&ef, node, cluster);
+		if (next_cluster != cluster + 1 || remainder == 0)
+		{
+			/* next cluster is not contiguous or this is EOF */
+			printf("%"PRIu64" %"PRIu64"\n",
+					exfat_c2o(&ef, fragment_start_cluster), fragment_size);
+			/* start a new fragment */
+			fragment_start_cluster = next_cluster;
+			fragment_size = 0;
+		}
+		cluster = next_cluster;
+	}
+
+	exfat_put_node(&ef, node);
+	exfat_unmount(&ef);
+	return rc;
+}
+
 static void usage(const char* prog)
 {
-	fprintf(stderr, "Usage: %s [-s] [-u] [-V] <device>\n", prog);
+	fprintf(stderr, "Usage: %s [-s] [-u] [-f file] [-V] <device>\n", prog);
 	exit(1);
 }
 
@@ -152,10 +209,9 @@
 	const char* spec = NULL;
 	bool sb_only = false;
 	bool used_sectors = false;
+	const char* file_path = NULL;
 
-	printf("dumpexfat %s\n", VERSION);
-
-	while ((opt = getopt(argc, argv, "suV")) != -1)
+	while ((opt = getopt(argc, argv, "suf:V")) != -1)
 	{
 		switch (opt)
 		{
@@ -165,8 +221,12 @@
 		case 'u':
 			used_sectors = true;
 			break;
+		case 'f':
+			file_path = optarg;
+			break;
 		case 'V':
-			puts("Copyright (C) 2011-2015  Andrew Nayenko");
+			printf("dumpexfat %s\n", VERSION);
+			puts("Copyright (C) 2011-2018  Andrew Nayenko");
 			return 0;
 		default:
 			usage(argv[0]);
@@ -176,6 +236,9 @@
 		usage(argv[0]);
 	spec = argv[optind];
 
+	if (file_path)
+		return dump_file_fragments(spec, file_path);
+
 	if (sb_only)
 		return dump_sb(spec);
 
diff --git a/exfat/fsck/exfatfsck.8 b/exfat/fsck/exfatfsck.8
index e950488..a641b6c 100644
--- a/exfat/fsck/exfatfsck.8
+++ b/exfat/fsck/exfatfsck.8
@@ -1,26 +1,49 @@
-.\" Copyright (C) 2011-2015  Andrew Nayenko
+.\" Copyright (C) 2011-2018  Andrew Nayenko
 .\"
-.TH EXFATFSCK 8 "February 2011"
+.TH EXFATFSCK 8 "September 2018"
 .SH NAME
 .B exfatfsck
 \- check an exFAT file system
 .SH SYNOPSIS
 .B exfatfsck
 [
-.B \-V
+.B \-a
+|
+.B \-n
+|
+.B \-p
+|
+.B \-y
 ]
 .I device
+.br
+.B exfatfsck
+[
+.B \-V
+]
 
 .SH DESCRIPTION
 .B exfatfsck
-checks an exFAT file system for errors. Note that it cannot repair corrupted
-FS, it just reports found errors.
+checks an exFAT file system for errors. It can repair some of them.
 
 .SH COMMAND LINE OPTIONS
 Command line options available:
 .TP
+.BI \-a
+Automatically repair the file system. No user intervention required.
+.TP
+.BI \-n
+No-operation mode: non-interactively check for errors, but don't write
+anything to the file system.
+.TP
+.BI \-p
+Same as \fB\-a\fR for compatibility with other *fsck.
+.TP
 .BI \-V
 Print version and copyright.
+.TP
+.BI \-y
+Same as \fB\-a\fR for compatibility with other *fsck.
 
 .SH EXIT CODES
 Zero is returned if errors were not found. Any other code means an error.
diff --git a/exfat/fsck/main.c b/exfat/fsck/main.c
index ded76b2..6a42092 100644
--- a/exfat/fsck/main.c
+++ b/exfat/fsck/main.c
@@ -3,7 +3,7 @@
 	exFAT file system checker.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -26,33 +26,33 @@
 #include <inttypes.h>
 #include <unistd.h>
 
-#define exfat_debug(format, ...)
+#define exfat_debug(format, ...) do {} while (0)
 
 uint64_t files_count, directories_count;
 
 static int nodeck(struct exfat* ef, struct exfat_node* node)
 {
 	const cluster_t cluster_size = CLUSTER_SIZE(*ef->sb);
-	cluster_t clusters = (node->size + cluster_size - 1) / cluster_size;
+	cluster_t clusters = DIV_ROUND_UP(node->size, cluster_size);
 	cluster_t c = node->start_cluster;
 	int rc = 0;
 
 	while (clusters--)
 	{
-		if (CLUSTER_INVALID(c))
+		if (CLUSTER_INVALID(*ef->sb, c))
 		{
-			char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
+			char name[EXFAT_UTF8_NAME_BUFFER_MAX];
 
-			exfat_get_name(node, name, sizeof(name) - 1);
+			exfat_get_name(node, name);
 			exfat_error("file '%s' has invalid cluster 0x%x", name, c);
 			rc = 1;
 			break;
 		}
 		if (BMAP_GET(ef->cmap.chunk, c - EXFAT_FIRST_DATA_CLUSTER) == 0)
 		{
-			char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
+			char name[EXFAT_UTF8_NAME_BUFFER_MAX];
 
-			exfat_get_name(node, name, sizeof(name) - 1);
+			exfat_get_name(node, name);
 			exfat_error("cluster 0x%x of file '%s' is not allocated", c, name);
 			rc = 1;
 		}
@@ -72,8 +72,8 @@
 
 	if (exfat_lookup(ef, &parent, path) != 0)
 		exfat_bug("directory '%s' is not found", path);
-	if (!(parent->flags & EXFAT_ATTRIB_DIR))
-		exfat_bug("'%s' is not a directory (0x%x)", path, parent->flags);
+	if (!(parent->attrib & EXFAT_ATTRIB_DIR))
+		exfat_bug("'%s' is not a directory (%#hx)", path, parent->attrib);
 	if (nodeck(ef, parent) != 0)
 	{
 		exfat_put_node(ef, parent);
@@ -81,7 +81,7 @@
 	}
 
 	path_length = strlen(path);
-	entry_path = malloc(path_length + 1 + UTF8_BYTES(EXFAT_NAME_MAX) + 1);
+	entry_path = malloc(path_length + 1 + EXFAT_UTF8_NAME_BUFFER_MAX);
 	if (entry_path == NULL)
 	{
 		exfat_put_node(ef, parent);
@@ -98,14 +98,13 @@
 		exfat_put_node(ef, parent);
 		return;
 	}
-	while ((node = exfat_readdir(ef, &it)))
+	while ((node = exfat_readdir(&it)))
 	{
-		exfat_get_name(node, entry_path + path_length + 1,
-				UTF8_BYTES(EXFAT_NAME_MAX));
+		exfat_get_name(node, entry_path + path_length + 1);
 		exfat_debug("%s: %s, %"PRIu64" bytes, cluster %u", entry_path,
-				IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented",
+				node->is_contiguous ? "contiguous" : "fragmented",
 				node->size, node->start_cluster);
-		if (node->flags & EXFAT_ATTRIB_DIR)
+		if (node->attrib & EXFAT_ATTRIB_DIR)
 		{
 			directories_count++;
 			dirck(ef, entry_path);
@@ -115,39 +114,68 @@
 			files_count++;
 			nodeck(ef, node);
 		}
+		exfat_flush_node(ef, node);
 		exfat_put_node(ef, node);
 	}
 	exfat_closedir(ef, &it);
+	exfat_flush_node(ef, parent);
 	exfat_put_node(ef, parent);
 	free(entry_path);
 }
 
-static void fsck(struct exfat* ef)
+static void fsck(struct exfat* ef, const char* spec, const char* options)
 {
+	if (exfat_mount(ef, spec, options) != 0)
+	{
+		fputs("File system checking stopped. ", stdout);
+		return;
+	}
+
 	exfat_print_info(ef->sb, exfat_count_free_clusters(ef));
+	exfat_soil_super_block(ef);
 	dirck(ef, "");
+	exfat_unmount(ef);
+
+	printf("Totally %"PRIu64" directories and %"PRIu64" files.\n",
+			directories_count, files_count);
+	fputs("File system checking finished. ", stdout);
 }
 
 static void usage(const char* prog)
 {
-	fprintf(stderr, "Usage: %s [-V] <device>\n", prog);
+	fprintf(stderr, "Usage: %s [-a | -n | -p | -y] <device>\n", prog);
+	fprintf(stderr, "       %s -V\n", prog);
 	exit(1);
 }
 
 int main(int argc, char* argv[])
 {
 	int opt;
+	const char* options;
 	const char* spec = NULL;
 	struct exfat ef;
 
 	printf("exfatfsck %s\n", VERSION);
 
-	while ((opt = getopt(argc, argv, "V")) != -1)
+	if (isatty(STDIN_FILENO))
+		options = "repair=1";
+	else
+		options = "repair=0";
+
+	while ((opt = getopt(argc, argv, "anpVy")) != -1)
 	{
 		switch (opt)
 		{
+		case 'a':
+		case 'p':
+		case 'y':
+			options = "repair=2";
+			break;
+		case 'n':
+			options = "repair=0,ro";
+			break;
 		case 'V':
-			puts("Copyright (C) 2011-2015  Andrew Nayenko");
+			puts("Copyright (C) 2011-2018  Andrew Nayenko");
 			return 0;
 		default:
 			usage(argv[0]);
@@ -158,19 +186,12 @@
 		usage(argv[0]);
 	spec = argv[optind];
 
-	if (exfat_mount(&ef, spec, "ro") != 0)
-		return 1;
-
 	printf("Checking file system on %s.\n", spec);
-	fsck(&ef);
-	exfat_unmount(&ef);
-	printf("Totally %"PRIu64" directories and %"PRIu64" files.\n",
-			directories_count, files_count);
-
-	fputs("File system checking finished. ", stdout);
+	fsck(&ef, spec, options);
 	if (exfat_errors != 0)
 	{
-		printf("ERRORS FOUND: %d.\n", exfat_errors);
+		printf("ERRORS FOUND: %d, FIXED: %d.\n",
+				exfat_errors, exfat_errors_fixed);
 		return 1;
 	}
 	puts("No errors found.");
diff --git a/exfat/fuse/main.c b/exfat/fuse/main.c
index 30958f6..3143693 100644
--- a/exfat/fuse/main.c
+++ b/exfat/fuse/main.c
@@ -3,7 +3,7 @@
 	FUSE-based exFAT implementation. Requires FUSE 2.6 or later.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -35,16 +35,13 @@
 #include <unistd.h>
 
 #ifndef DEBUG
-	#define exfat_debug(format, ...)
+	#define exfat_debug(format, ...) do {} while (0)
 #endif
 
 #if !defined(FUSE_VERSION) || (FUSE_VERSION < 26)
 	#error FUSE 2.6 or later is required
 #endif
 
-const char* default_options = "ro_fallback,allow_other,blkdev,big_writes,"
-		"default_permissions";
-
 struct exfat ef;
 
 static struct exfat_node* get_node(const struct fuse_file_info* fi)
@@ -74,7 +71,7 @@
 	return 0;
 }
 
-static int fuse_exfat_truncate(const char* path, loff_t size)
+static int fuse_exfat_truncate(const char* path, off_t size)
 {
 	struct exfat_node* node;
 	int rc;
@@ -98,23 +95,25 @@
 }
 
 static int fuse_exfat_readdir(const char* path, void* buffer,
-		fuse_fill_dir_t filler, loff_t offset, struct fuse_file_info* fi)
+		fuse_fill_dir_t filler, UNUSED off_t offset,
+		UNUSED struct fuse_file_info* fi)
 {
 	struct exfat_node* parent;
 	struct exfat_node* node;
 	struct exfat_iterator it;
 	int rc;
-	char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
+	char name[EXFAT_UTF8_NAME_BUFFER_MAX];
+	struct stat stbuf;
 
 	exfat_debug("[%s] %s", __func__, path);
 
 	rc = exfat_lookup(&ef, &parent, path);
 	if (rc != 0)
 		return rc;
-	if (!(parent->flags & EXFAT_ATTRIB_DIR))
+	if (!(parent->attrib & EXFAT_ATTRIB_DIR))
 	{
 		exfat_put_node(&ef, parent);
-		exfat_error("'%s' is not a directory (0x%x)", path, parent->flags);
+		exfat_error("'%s' is not a directory (%#hx)", path, parent->attrib);
 		return -ENOTDIR;
 	}
 
@@ -128,13 +127,14 @@
 		exfat_error("failed to open directory '%s'", path);
 		return rc;
 	}
-	while ((node = exfat_readdir(&ef, &it)))
+	while ((node = exfat_readdir(&it)))
 	{
-		exfat_get_name(node, name, sizeof(name) - 1);
+		exfat_get_name(node, name);
 		exfat_debug("[%s] %s: %s, %"PRId64" bytes, cluster 0x%x", __func__,
-				name, IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented",
+				name, node->is_contiguous ? "contiguous" : "fragmented",
 				node->size, node->start_cluster);
-		filler(buffer, name, NULL, 0);
+		exfat_stat(&ef, node, &stbuf);
+		filler(buffer, name, &stbuf, 0);
 		exfat_put_node(&ef, node);
 	}
 	exfat_closedir(&ef, &it);
@@ -156,7 +156,7 @@
 	return 0;
 }
 
-static int fuse_exfat_create(const char* path, mode_t mode,
+static int fuse_exfat_create(const char* path, UNUSED mode_t mode,
 		struct fuse_file_info* fi)
 {
 	struct exfat_node* node;
@@ -174,7 +174,8 @@
 	return 0;
 }
 
-static int fuse_exfat_release(const char* path, struct fuse_file_info* fi)
+static int fuse_exfat_release(UNUSED const char* path,
+		struct fuse_file_info* fi)
 {
 	/*
 	   This handler is called by FUSE on close() syscall. If the FUSE
@@ -188,7 +189,7 @@
 	return 0; /* FUSE ignores this return value */
 }
 
-static int fuse_exfat_flush(const char* path, struct fuse_file_info* fi)
+static int fuse_exfat_flush(UNUSED const char* path, struct fuse_file_info* fi)
 {
 	/*
 	   This handler may be called by FUSE on close() syscall. FUSE also deals
@@ -200,8 +201,8 @@
 	return exfat_flush_node(&ef, get_node(fi));
 }
 
-static int fuse_exfat_fsync(const char* path, int datasync,
-		struct fuse_file_info *fi)
+static int fuse_exfat_fsync(UNUSED const char* path, UNUSED int datasync,
+		UNUSED struct fuse_file_info *fi)
 {
 	int rc;
 
@@ -215,28 +216,18 @@
 	return exfat_fsync(ef.dev);
 }
 
-static int fuse_exfat_read(const char* path, char* buffer, size_t size,
-		loff_t offset, struct fuse_file_info* fi)
+static int fuse_exfat_read(UNUSED const char* path, char* buffer,
+		size_t size, off_t offset, struct fuse_file_info* fi)
 {
-	ssize_t ret;
-
 	exfat_debug("[%s] %s (%zu bytes)", __func__, path, size);
-	ret = exfat_generic_pread(&ef, get_node(fi), buffer, size, offset);
-	if (ret < 0)
-		return -EIO;
-	return ret;
+	return exfat_generic_pread(&ef, get_node(fi), buffer, size, offset);
 }
 
-static int fuse_exfat_write(const char* path, const char* buffer, size_t size,
-		loff_t offset, struct fuse_file_info* fi)
+static int fuse_exfat_write(UNUSED const char* path, const char* buffer,
+		size_t size, off_t offset, struct fuse_file_info* fi)
 {
-	ssize_t ret;
-
 	exfat_debug("[%s] %s (%zu bytes)", __func__, path, size);
-	ret = exfat_generic_pwrite(&ef, get_node(fi), buffer, size, offset);
-	if (ret < 0)
-		return -EIO;
-	return ret;
+	return exfat_generic_pwrite(&ef, get_node(fi), buffer, size, offset);
 }
 
 static int fuse_exfat_unlink(const char* path)
@@ -275,13 +266,14 @@
 	return exfat_cleanup_node(&ef, node);
 }
 
-static int fuse_exfat_mknod(const char* path, mode_t mode, dev_t dev)
+static int fuse_exfat_mknod(const char* path, UNUSED mode_t mode,
+		UNUSED dev_t dev)
 {
 	exfat_debug("[%s] %s 0%ho", __func__, path, mode);
 	return exfat_mknod(&ef, path);
 }
 
-static int fuse_exfat_mkdir(const char* path, mode_t mode)
+static int fuse_exfat_mkdir(const char* path, UNUSED mode_t mode)
 {
 	exfat_debug("[%s] %s 0%ho", __func__, path, mode);
 	return exfat_mkdir(&ef, path);
@@ -310,7 +302,7 @@
 	return rc;
 }
 
-static int fuse_exfat_chmod(const char* path, mode_t mode)
+static int fuse_exfat_chmod(UNUSED const char* path, mode_t mode)
 {
 	const mode_t VALID_MODE_MASK = S_IFREG | S_IFDIR |
 			S_IRWXU | S_IRWXG | S_IRWXO;
@@ -321,7 +313,7 @@
 	return 0;
 }
 
-static int fuse_exfat_chown(const char* path, uid_t uid, gid_t gid)
+static int fuse_exfat_chown(UNUSED const char* path, uid_t uid, gid_t gid)
 {
 	exfat_debug("[%s] %s %u:%u", __func__, path, uid, gid);
 	if (uid != ef.uid || gid != ef.gid)
@@ -329,7 +321,7 @@
 	return 0;
 }
 
-static int fuse_exfat_statfs(const char* path, struct statvfs* sfs)
+static int fuse_exfat_statfs(UNUSED const char* path, struct statvfs* sfs)
 {
 	exfat_debug("[%s]", __func__);
 
@@ -359,10 +351,14 @@
 #ifdef FUSE_CAP_BIG_WRITES
 	fci->want |= FUSE_CAP_BIG_WRITES;
 #endif
+
+	/* mark super block as dirty; failure isn't a big deal */
+	exfat_soil_super_block(&ef);
+
 	return NULL;
 }
 
-static void fuse_exfat_destroy(void* unused)
+static void fuse_exfat_destroy(UNUSED void* unused)
 {
 	exfat_debug("[%s]", __func__);
 	exfat_unmount(&ef);
@@ -427,6 +423,42 @@
 	return options;
 }
 
+static void escape(char* escaped, const char* orig)
+{
+	do
+	{
+		if (*orig == ',' || *orig == '\\')
+			*escaped++ = '\\';
+	}
+	while ((*escaped++ = *orig++));
+}
+
+static char* add_fsname_option(char* options, const char* spec)
+{
+	/* escaped string cannot be more than twice as big as the original one */
+	char* escaped = malloc(strlen(spec) * 2 + 1);
+
+	if (escaped == NULL)
+	{
+		free(options);
+		exfat_error("failed to allocate escaped string for %s", spec);
+		return NULL;
+	}
+
+	/* on some platforms (e.g. Android, Solaris) device names can contain
+	   commas */
+	escape(escaped, spec);
+	options = add_option(options, "fsname", escaped);
+	free(escaped);
+	return options;
+}
+
+static char* add_ro_option(char* options, bool ro)
+{
+	return ro ? add_option(options, "ro", NULL) : options;
+}
+
+#if defined(__linux__)
 static char* add_user_option(char* options)
 {
 	struct passwd* pw;
@@ -443,7 +475,9 @@
 	}
 	return add_option(options, "user", pw->pw_name);
 }
+#endif
 
+#if defined(__linux__)
 static char* add_blksize_option(char* options, long cluster_size)
 {
 	long page_size = sysconf(_SC_PAGESIZE);
@@ -455,39 +489,82 @@
 	snprintf(blksize, sizeof(blksize), "%ld", MIN(page_size, cluster_size));
 	return add_option(options, "blksize", blksize);
 }
+#endif
 
-static char* add_fuse_options(char* options, const char* spec)
+static char* add_fuse_options(char* options, const char* spec, bool ro)
 {
-	options = add_option(options, "fsname", spec);
+	options = add_fsname_option(options, spec);
 	if (options == NULL)
 		return NULL;
+	options = add_ro_option(options, ro);
+	if (options == NULL)
+		return NULL;
+#if defined(__linux__)
 	options = add_user_option(options);
 	if (options == NULL)
 		return NULL;
 	options = add_blksize_option(options, CLUSTER_SIZE(*ef.sb));
 	if (options == NULL)
 		return NULL;
-
+#endif
 	return options;
 }
 
+static char* add_passthrough_fuse_options(char* fuse_options,
+		const char* options)
+{
+	const char* passthrough_list[] =
+	{
+#if defined(__FreeBSD__)
+		"automounted",
+#endif
+		"nonempty",
+		NULL
+	};
+	int i;
+
+	for (i = 0; passthrough_list[i] != NULL; i++)
+		if (exfat_match_option(options, passthrough_list[i]))
+		{
+			fuse_options = add_option(fuse_options, passthrough_list[i], NULL);
+			if (fuse_options == NULL)
+				return NULL;
+		}
+
+	return fuse_options;
+}
+
+static int fuse_exfat_main(char* mount_options, char* mount_point)
+{
+	char* argv[] = {"exfat", "-s", "-o", mount_options, mount_point, NULL};
+	return fuse_main(sizeof(argv) / sizeof(argv[0]) - 1, argv,
+			&fuse_exfat_ops, NULL);
+}
+
 int main(int argc, char* argv[])
 {
-	struct fuse_args mount_args = FUSE_ARGS_INIT(0, NULL);
-	struct fuse_args newfs_args = FUSE_ARGS_INIT(0, NULL);
 	const char* spec = NULL;
-	const char* mount_point = NULL;
-	char* mount_options;
-	int debug = 0;
-	struct fuse_chan* fc = NULL;
-	struct fuse* fh = NULL;
+	char* mount_point = NULL;
+	char* fuse_options;
+	char* exfat_options;
 	int opt;
+	int rc;
 
 	printf("FUSE exfat %s\n", VERSION);
 
-	mount_options = strdup(default_options);
-	if (mount_options == NULL)
+	fuse_options = strdup("allow_other,"
+#if defined(__linux__) || defined(__FreeBSD__)
+			"big_writes,"
+#endif
+#if defined(__linux__)
+			"blkdev,"
+#endif
+			"default_permissions");
+	exfat_options = strdup("ro_fallback");
+	if (fuse_options == NULL || exfat_options == NULL)
 	{
+		free(fuse_options);
+		free(exfat_options);
 		exfat_error("failed to allocate options string");
 		return 1;
 	}
@@ -497,122 +574,71 @@
 		switch (opt)
 		{
 		case 'd':
-			debug = 1;
+			fuse_options = add_option(fuse_options, "debug", NULL);
+			if (fuse_options == NULL)
+			{
+				free(exfat_options);
+				return 1;
+			}
 			break;
 		case 'n':
 			break;
 		case 'o':
-			mount_options = add_option(mount_options, optarg, NULL);
-			if (mount_options == NULL)
+			exfat_options = add_option(exfat_options, optarg, NULL);
+			if (exfat_options == NULL)
+			{
+				free(fuse_options);
 				return 1;
+			}
+			fuse_options = add_passthrough_fuse_options(fuse_options, optarg);
+			if (fuse_options == NULL)
+			{
+				free(exfat_options);
+				return 1;
+			}
 			break;
 		case 'V':
-			free(mount_options);
-			puts("Copyright (C) 2010-2015  Andrew Nayenko");
+			free(exfat_options);
+			free(fuse_options);
+			puts("Copyright (C) 2010-2018  Andrew Nayenko");
 			return 0;
 		case 'v':
 			break;
 		default:
-			free(mount_options);
+			free(exfat_options);
+			free(fuse_options);
 			usage(argv[0]);
 			break;
 		}
 	}
 	if (argc - optind != 2)
 	{
-		free(mount_options);
+		free(exfat_options);
+		free(fuse_options);
 		usage(argv[0]);
 	}
 	spec = argv[optind];
 	mount_point = argv[optind + 1];
 
-	if (exfat_mount(&ef, spec, mount_options) != 0)
+	if (exfat_mount(&ef, spec, exfat_options) != 0)
 	{
-		free(mount_options);
+		free(exfat_options);
+		free(fuse_options);
 		return 1;
 	}
 
-	if (ef.ro == -1) /* read-only fallback was used */
-	{
-		mount_options = add_option(mount_options, "ro", NULL);
-		if (mount_options == NULL)
-		{
-			exfat_unmount(&ef);
-			return 1;
-		}
-	}
+	free(exfat_options);
 
-	mount_options = add_fuse_options(mount_options, spec);
-	if (mount_options == NULL)
+	fuse_options = add_fuse_options(fuse_options, spec, ef.ro != 0);
+	if (fuse_options == NULL)
 	{
 		exfat_unmount(&ef);
 		return 1;
 	}
 
-	/* create arguments for fuse_mount() */
-	if (fuse_opt_add_arg(&mount_args, "exfat") != 0 ||
-		fuse_opt_add_arg(&mount_args, "-o") != 0 ||
-		fuse_opt_add_arg(&mount_args, mount_options) != 0)
-	{
-		exfat_unmount(&ef);
-		free(mount_options);
-		return 1;
-	}
+	/* let FUSE do all its wizardry */
+	rc = fuse_exfat_main(fuse_options, mount_point);
 
-	free(mount_options);
-
-	/* create FUSE mount point */
-	fc = fuse_mount(mount_point, &mount_args);
-	fuse_opt_free_args(&mount_args);
-	if (fc == NULL)
-	{
-		exfat_unmount(&ef);
-		return 1;
-	}
-
-	/* create arguments for fuse_new() */
-	if (fuse_opt_add_arg(&newfs_args, "") != 0 ||
-		(debug && fuse_opt_add_arg(&newfs_args, "-d") != 0))
-	{
-		fuse_unmount(mount_point, fc);
-		exfat_unmount(&ef);
-		return 1;
-	}
-
-	/* create new FUSE file system */
-	fh = fuse_new(fc, &newfs_args, &fuse_exfat_ops,
-			sizeof(struct fuse_operations), NULL);
-	fuse_opt_free_args(&newfs_args);
-	if (fh == NULL)
-	{
-		fuse_unmount(mount_point, fc);
-		exfat_unmount(&ef);
-		return 1;
-	}
-
-	/* exit session on HUP, TERM and INT signals and ignore PIPE signal */
-	if (fuse_set_signal_handlers(fuse_get_session(fh)) != 0)
-	{
-		fuse_unmount(mount_point, fc);
-		fuse_destroy(fh);
-		exfat_unmount(&ef);
-		exfat_error("failed to set signal handlers");
-		return 1;
-	}
-
-	/* go to background (unless "-d" option is passed) and run FUSE
-	   main loop */
-	if (fuse_daemonize(debug) == 0)
-	{
-		if (fuse_loop(fh) != 0)
-			exfat_error("FUSE loop failure");
-	}
-	else
-		exfat_error("failed to daemonize");
-
-	fuse_remove_signal_handlers(fuse_get_session(fh));
-	/* note that fuse_unmount() must be called BEFORE fuse_destroy() */
-	fuse_unmount(mount_point, fc);
-	fuse_destroy(fh);
-	return 0;
+	free(fuse_options);
+	return rc;
 }
diff --git a/exfat/fuse/mount.exfat-fuse.8 b/exfat/fuse/mount.exfat-fuse.8
index 38586ca..e0925b2 100644
--- a/exfat/fuse/mount.exfat-fuse.8
+++ b/exfat/fuse/mount.exfat-fuse.8
@@ -1,6 +1,6 @@
-.\" Copyright (C) 2010-2015  Andrew Nayenko
+.\" Copyright (C) 2010-2016  Andrew Nayenko
 .\"
-.TH EXFAT-FUSE 8 "July 2010"
+.TH EXFAT-FUSE 8 "November 2015"
 .SH NAME
 mount.exfat-fuse \- mount an exFAT file system
 .SH SYNOPSIS
diff --git a/exfat/label/exfatlabel.8 b/exfat/label/exfatlabel.8
index bff6e79..4f55510 100644
--- a/exfat/label/exfatlabel.8
+++ b/exfat/label/exfatlabel.8
@@ -1,6 +1,6 @@
-.\" Copyright (C) 2011-2015  Andrew Nayenko
+.\" Copyright (C) 2011-2018  Andrew Nayenko
 .\"
-.TH EXFATLABEL 8 "February 2011"
+.TH EXFATLABEL 8 "September 2017"
 .SH NAME
 .B exfatlabel
 \- get or set an exFAT file system label
@@ -22,9 +22,9 @@
 .I label
 argument is present,
 .B exfatlabel
-sets the new volume name. Label can be up to 15 characters. This limit is
-shorter if characters beyond Unicode BMP are used because internally label
-is stored in UTF-16.
+sets the new volume name. Empty label ('') removes volume name. Label can be
+up to 15 characters. This limit is shorter if characters beyond Unicode BMP
+are used because internally label is stored in UTF-16.
 
 If
 .I label
diff --git a/exfat/label/main.c b/exfat/label/main.c
index b219d4e..398498a 100644
--- a/exfat/label/main.c
+++ b/exfat/label/main.c
@@ -3,7 +3,7 @@
 	Prints or changes exFAT volume label.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -34,7 +34,7 @@
 		if (strcmp(*pp, "-V") == 0)
 		{
 			printf("exfatlabel %s\n", VERSION);
-			puts("Copyright (C) 2011-2015  Andrew Nayenko");
+			puts("Copyright (C) 2011-2018  Andrew Nayenko");
 			return 0;
 		}
 
diff --git a/exfat/libexfat/Android.mk b/exfat/libexfat/Android.mk
index 64adef7..6d4c76e 100644
--- a/exfat/libexfat/Android.mk
+++ b/exfat/libexfat/Android.mk
@@ -4,8 +4,8 @@
 LOCAL_MODULE := libexfat_twrp
 LOCAL_MODULE_TAGS := optional
 LOCAL_CFLAGS = -D_FILE_OFFSET_BITS=64 -Wno-sign-compare -Wno-address-of-packed-member -Wno-missing-field-initializers
-LOCAL_SRC_FILES = cluster.c io.c log.c lookup.c mount.c node.c time.c utf.c utils.c
+LOCAL_SRC_FILES = cluster.c io.c log.c lookup.c mount.c node.c repair.c time.c utf.c utils.c
 LOCAL_C_INCLUDES += $(LOCAL_PATH)
-LOCAL_SHARED_LIBRARIES += libc
+LOCAL_SHARED_LIBRARIES += libc liblog
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/exfat/libexfat/android_config.h b/exfat/libexfat/android_config.h
index 09c3346..2bb42e8 100644
--- a/exfat/libexfat/android_config.h
+++ b/exfat/libexfat/android_config.h
@@ -11,7 +11,7 @@
 #define PACKAGE_NAME "Free exFAT implementation"
 
 /* Define to the full name and version of this package. */
-#define PACKAGE_STRING "Free exFAT implementation 1.2.2"
+#define PACKAGE_STRING "Free exFAT implementation 1.3.0"
 
 /* Define to the one symbol short name of this package. */
 #define PACKAGE_TARNAME "exfat"
@@ -20,10 +20,10 @@
 #define PACKAGE_URL "https://github.com/relan/exfat"
 
 /* Define to the version of this package. */
-#define PACKAGE_VERSION "1.2.2"
+#define PACKAGE_VERSION "1.3.0"
 
 /* Version number of package */
-#define VERSION "1.2.2"
+#define VERSION "1.3.0"
 
 /* Enable large inode numbers on Mac OS X 10.5.  */
 #ifndef _DARWIN_USE_64_BIT_INODE
diff --git a/exfat/libexfat/byteorder.h b/exfat/libexfat/byteorder.h
index 472cb48..ba54410 100644
--- a/exfat/libexfat/byteorder.h
+++ b/exfat/libexfat/byteorder.h
@@ -3,7 +3,7 @@
 	Endianness stuff. exFAT uses little-endian byte order.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
diff --git a/exfat/libexfat/cluster.c b/exfat/libexfat/cluster.c
index 394ca4a..0f2e91b 100644
--- a/exfat/libexfat/cluster.c
+++ b/exfat/libexfat/cluster.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -28,7 +28,7 @@
 /*
  * Sector to absolute offset.
  */
-static loff_t s2o(const struct exfat* ef, loff_t sector)
+static off_t s2o(const struct exfat* ef, off_t sector)
 {
 	return sector << ef->sb->sector_bits;
 }
@@ -36,18 +36,18 @@
 /*
  * Cluster to sector.
  */
-static loff_t c2s(const struct exfat* ef, cluster_t cluster)
+static off_t c2s(const struct exfat* ef, cluster_t cluster)
 {
 	if (cluster < EXFAT_FIRST_DATA_CLUSTER)
 		exfat_bug("invalid cluster number %u", cluster);
 	return le32_to_cpu(ef->sb->cluster_sector_start) +
-		((loff_t) (cluster - EXFAT_FIRST_DATA_CLUSTER) << ef->sb->spc_bits);
+		((off_t) (cluster - EXFAT_FIRST_DATA_CLUSTER) << ef->sb->spc_bits);
 }
 
 /*
  * Cluster to absolute offset.
  */
-loff_t exfat_c2o(const struct exfat* ef, cluster_t cluster)
+off_t exfat_c2o(const struct exfat* ef, cluster_t cluster)
 {
 	return s2o(ef, c2s(ef, cluster));
 }
@@ -55,7 +55,7 @@
 /*
  * Sector to cluster.
  */
-static cluster_t s2c(const struct exfat* ef, loff_t sector)
+static cluster_t s2c(const struct exfat* ef, off_t sector)
 {
 	return ((sector - le32_to_cpu(ef->sb->cluster_sector_start)) >>
 			ef->sb->spc_bits) + EXFAT_FIRST_DATA_CLUSTER;
@@ -67,19 +67,19 @@
 static uint32_t bytes2clusters(const struct exfat* ef, uint64_t bytes)
 {
 	uint64_t cluster_size = CLUSTER_SIZE(*ef->sb);
-	return (bytes + cluster_size - 1) / cluster_size;
+	return DIV_ROUND_UP(bytes, cluster_size);
 }
 
 cluster_t exfat_next_cluster(const struct exfat* ef,
 		const struct exfat_node* node, cluster_t cluster)
 {
 	le32_t next;
-	loff_t fat_offset;
+	off_t fat_offset;
 
 	if (cluster < EXFAT_FIRST_DATA_CLUSTER)
 		exfat_bug("bad cluster 0x%x", cluster);
 
-	if (IS_CONTIGUOUS(*node))
+	if (node->is_contiguous)
 		return cluster + 1;
 	fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
 		+ cluster * sizeof(cluster_t);
@@ -103,7 +103,7 @@
 	for (i = node->fptr_index; i < count; i++)
 	{
 		node->fptr_cluster = exfat_next_cluster(ef, node, node->fptr_cluster);
-		if (CLUSTER_INVALID(node->fptr_cluster))
+		if (CLUSTER_INVALID(*ef->sb, node->fptr_cluster))
 			break; /* the caller should handle this and print appropriate 
 			          error message */
 	}
@@ -122,7 +122,7 @@
 
 	for (i = start_index; i < end_index; i++)
 	{
-		if (bitmap[i] == ~((bitmap_t) 0))
+		if (bitmap[i] == (bitmap_t) ~((bitmap_t) 0))
 			continue;
 		start_bitindex = MAX(i * sizeof(bitmap_t) * 8, start);
 		end_bitindex = MIN((i + 1) * sizeof(bitmap_t) * 8, end);
@@ -174,7 +174,7 @@
 static bool set_next_cluster(const struct exfat* ef, bool contiguous,
 		cluster_t current, cluster_t next)
 {
-	loff_t fat_offset;
+	off_t fat_offset;
 	le32_t next_le32;
 
 	if (contiguous)
@@ -214,10 +214,8 @@
 
 static void free_cluster(struct exfat* ef, cluster_t cluster)
 {
-	if (CLUSTER_INVALID(cluster))
-		exfat_bug("freeing invalid cluster 0x%x", cluster);
 	if (cluster - EXFAT_FIRST_DATA_CLUSTER >= ef->cmap.size)
-		exfat_bug("freeing non-existing cluster 0x%x (0x%x)", cluster,
+		exfat_bug("caller must check cluster validity (%#x, %#x)", cluster,
 				ef->cmap.size);
 
 	BMAP_CLR(ef->cmap.chunk, cluster - EXFAT_FIRST_DATA_CLUSTER);
@@ -252,7 +250,7 @@
 	{
 		/* get the last cluster of the file */
 		previous = exfat_advance_cluster(ef, node, current - 1);
-		if (CLUSTER_INVALID(previous))
+		if (CLUSTER_INVALID(*ef->sb, previous))
 		{
 			exfat_error("invalid cluster 0x%x while growing", previous);
 			return -EIO;
@@ -265,39 +263,39 @@
 		/* file does not have clusters (i.e. is empty), allocate
 		   the first one for it */
 		previous = allocate_cluster(ef, 0);
-		if (CLUSTER_INVALID(previous))
+		if (CLUSTER_INVALID(*ef->sb, previous))
 			return -ENOSPC;
 		node->fptr_cluster = node->start_cluster = previous;
 		allocated = 1;
 		/* file consists of only one cluster, so it's contiguous */
-		node->flags |= EXFAT_ATTRIB_CONTIGUOUS;
+		node->is_contiguous = true;
 	}
 
 	while (allocated < difference)
 	{
 		next = allocate_cluster(ef, previous + 1);
-		if (CLUSTER_INVALID(next))
+		if (CLUSTER_INVALID(*ef->sb, next))
 		{
 			if (allocated != 0)
 				shrink_file(ef, node, current + allocated, allocated);
 			return -ENOSPC;
 		}
-		if (next != previous - 1 && IS_CONTIGUOUS(*node))
+		if (next != previous + 1 && node->is_contiguous)
 		{
 			/* it's a pity, but we are not able to keep the file contiguous
 			   anymore */
 			if (!make_noncontiguous(ef, node->start_cluster, previous))
 				return -EIO;
-			node->flags &= ~EXFAT_ATTRIB_CONTIGUOUS;
-			node->flags |= EXFAT_ATTRIB_DIRTY;
+			node->is_contiguous = false;
+			node->is_dirty = true;
 		}
-		if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, next))
+		if (!set_next_cluster(ef, node->is_contiguous, previous, next))
 			return -EIO;
 		previous = next;
 		allocated++;
 	}
 
-	if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous,
+	if (!set_next_cluster(ef, node->is_contiguous, previous,
 			EXFAT_CLUSTER_END))
 		return -EIO;
 	return 0;
@@ -321,13 +319,13 @@
 	{
 		cluster_t last = exfat_advance_cluster(ef, node,
 				current - difference - 1);
-		if (CLUSTER_INVALID(last))
+		if (CLUSTER_INVALID(*ef->sb, last))
 		{
 			exfat_error("invalid cluster 0x%x while shrinking", last);
 			return -EIO;
 		}
 		previous = exfat_next_cluster(ef, node, last);
-		if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), last,
+		if (!set_next_cluster(ef, node->is_contiguous, last,
 				EXFAT_CLUSTER_END))
 			return -EIO;
 	}
@@ -335,7 +333,7 @@
 	{
 		previous = node->start_cluster;
 		node->start_cluster = EXFAT_CLUSTER_FREE;
-		node->flags |= EXFAT_ATTRIB_DIRTY;
+		node->is_dirty = true;
 	}
 	node->fptr_index = 0;
 	node->fptr_cluster = node->start_cluster;
@@ -343,14 +341,15 @@
 	/* free remaining clusters */
 	while (difference--)
 	{
-		if (CLUSTER_INVALID(previous))
+		if (CLUSTER_INVALID(*ef->sb, previous))
 		{
 			exfat_error("invalid cluster 0x%x while freeing after shrink",
 					previous);
 			return -EIO;
 		}
+
 		next = exfat_next_cluster(ef, node, previous);
-		if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous,
+		if (!set_next_cluster(ef, node->is_contiguous, previous,
 				EXFAT_CLUSTER_FREE))
 			return -EIO;
 		free_cluster(ef, previous);
@@ -359,7 +358,7 @@
 	return 0;
 }
 
-static bool erase_raw(struct exfat* ef, size_t size, loff_t offset)
+static bool erase_raw(struct exfat* ef, size_t size, off_t offset)
 {
 	if (exfat_pwrite(ef->dev, ef->zero_cluster, size, offset) < 0)
 	{
@@ -381,7 +380,7 @@
 	cluster_boundary = (begin | (CLUSTER_SIZE(*ef->sb) - 1)) + 1;
 	cluster = exfat_advance_cluster(ef, node,
 			begin / CLUSTER_SIZE(*ef->sb));
-	if (CLUSTER_INVALID(cluster))
+	if (CLUSTER_INVALID(*ef->sb, cluster))
 	{
 		exfat_error("invalid cluster 0x%x while erasing", cluster);
 		return -EIO;
@@ -395,7 +394,7 @@
 	{
 		cluster = exfat_next_cluster(ef, node, cluster);
 		/* the cluster cannot be invalid because we have just allocated it */
-		if (CLUSTER_INVALID(cluster))
+		if (CLUSTER_INVALID(*ef->sb, cluster))
 			exfat_bug("invalid cluster 0x%x after allocation", cluster);
 		if (!erase_raw(ef, CLUSTER_SIZE(*ef->sb), exfat_c2o(ef, cluster)))
 			return -EIO;
@@ -434,7 +433,7 @@
 
 	exfat_update_mtime(node);
 	node->size = size;
-	node->flags |= EXFAT_ATTRIB_DIRTY;
+	node->is_dirty = true;
 	return 0;
 }
 
@@ -472,7 +471,7 @@
 	return 0;
 }
 
-int exfat_find_used_sectors(const struct exfat* ef, loff_t* a, loff_t* b)
+int exfat_find_used_sectors(const struct exfat* ef, off_t* a, off_t* b)
 {
 	cluster_t ca, cb;
 
diff --git a/exfat/libexfat/compiler.h b/exfat/libexfat/compiler.h
index 3b092a9..88d3d7c 100644
--- a/exfat/libexfat/compiler.h
+++ b/exfat/libexfat/compiler.h
@@ -4,7 +4,7 @@
 	showstopper.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -24,7 +24,7 @@
 #ifndef COMPILER_H_INCLUDED
 #define COMPILER_H_INCLUDED
 
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ < 199901L)
+#if __STDC_VERSION__ < 199901L
 #error C99-compliant compiler is required
 #endif
 
@@ -33,6 +33,7 @@
 #define PRINTF __attribute__((format(printf, 1, 2)))
 #define NORETURN __attribute__((noreturn))
 #define PACKED __attribute__((packed))
+#define UNUSED __attribute__((unused))
 #if __has_extension(c_static_assert)
 #define USE_C11_STATIC_ASSERT
 #endif
@@ -42,6 +43,7 @@
 #define PRINTF __attribute__((format(printf, 1, 2)))
 #define NORETURN __attribute__((noreturn))
 #define PACKED __attribute__((packed))
+#define UNUSED __attribute__((unused))
 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
 #define USE_C11_STATIC_ASSERT
 #endif
@@ -51,6 +53,7 @@
 #define PRINTF
 #define NORETURN
 #define PACKED
+#define UNUSED
 
 #endif
 
diff --git a/exfat/libexfat/exfat.h b/exfat/libexfat/exfat.h
index 009a0c0..e99af84 100644
--- a/exfat/libexfat/exfat.h
+++ b/exfat/libexfat/exfat.h
@@ -4,7 +4,7 @@
 	implementation.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -38,22 +38,22 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
-#define EXFAT_NAME_MAX 256
-#define EXFAT_ATTRIB_CONTIGUOUS 0x10000
-#define EXFAT_ATTRIB_CACHED     0x20000
-#define EXFAT_ATTRIB_DIRTY      0x40000
-#define EXFAT_ATTRIB_UNLINKED   0x80000
-#define IS_CONTIGUOUS(node) (((node).flags & EXFAT_ATTRIB_CONTIGUOUS) != 0)
+#define EXFAT_NAME_MAX 255
+/* UTF-16 encodes code points up to U+FFFF as single 16-bit code units.
+   UTF-8 uses up to 3 bytes (i.e. 8-bit code units) to encode code points
+   up to U+FFFF. One additional character is for null terminator. */
+#define EXFAT_UTF8_NAME_BUFFER_MAX (EXFAT_NAME_MAX * 3 + 1)
+#define EXFAT_UTF8_ENAME_BUFFER_MAX (EXFAT_ENAME_MAX * 3 + 1)
+
 #define SECTOR_SIZE(sb) (1 << (sb).sector_bits)
 #define CLUSTER_SIZE(sb) (SECTOR_SIZE(sb) << (sb).spc_bits)
-#define CLUSTER_INVALID(c) \
-	((c) < EXFAT_FIRST_DATA_CLUSTER || (c) > EXFAT_LAST_DATA_CLUSTER)
+#define CLUSTER_INVALID(sb, c) ((c) < EXFAT_FIRST_DATA_CLUSTER || \
+	(c) - EXFAT_FIRST_DATA_CLUSTER >= le32_to_cpu((sb).cluster_count))
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 #define DIV_ROUND_UP(x, d) (((x) + (d) - 1) / (d))
 #define ROUND_UP(x, d) (DIV_ROUND_UP(x, d) * (d))
-#define UTF8_BYTES(c) ((c) * 6) /* UTF-8 character can occupy up to 6 bytes */
 
 #define BMAP_SIZE(count) (ROUND_UP(count, sizeof(bitmap_t) * 8) / 8)
 #define BMAP_BLOCK(index) ((index) / sizeof(bitmap_t) / 8)
@@ -65,9 +65,12 @@
 #define BMAP_CLR(bitmap, index) \
 	((bitmap)[BMAP_BLOCK(index)] &= ~BMAP_MASK(index))
 
+#define EXFAT_REPAIR(hook, ef, ...) \
+	(exfat_ask_to_fix(ef) && exfat_fix_ ## hook(ef, __VA_ARGS__))
+
 /* The size of off_t type must be 64 bits. File systems larger than 2 GB will
-   be corrupted with 32-bit off_t. So, we use loff_t here.*/
-STATIC_ASSERT(sizeof(loff_t) == 8);
+   be corrupted with 32-bit off_t. */
+STATIC_ASSERT(sizeof(off_t) == 8);
 
 struct exfat_node
 {
@@ -79,10 +82,14 @@
 	int references;
 	uint32_t fptr_index;
 	cluster_t fptr_cluster;
-	cluster_t entry_cluster;
-	loff_t entry_offset;
+	off_t entry_offset;
 	cluster_t start_cluster;
-	int flags;
+	uint16_t attrib;
+	uint8_t continuations;
+	bool is_contiguous : 1;
+	bool is_cached : 1;
+	bool is_dirty : 1;
+	bool is_unlinked : 1;
 	uint64_t size;
 	time_t mtime, atime;
 	le16_t name[EXFAT_NAME_MAX + 1];
@@ -101,8 +108,7 @@
 {
 	struct exfat_dev* dev;
 	struct exfat_super_block* sb;
-	le16_t* upcase;
-	size_t upcase_chars;
+	uint16_t* upcase;
 	struct exfat_node* root;
 	struct
 	{
@@ -113,13 +119,14 @@
 		bool dirty;
 	}
 	cmap;
-	char label[UTF8_BYTES(EXFAT_ENAME_MAX) + 1];
+	char label[EXFAT_UTF8_ENAME_BUFFER_MAX];
 	void* zero_cluster;
 	int dmask, fmask;
 	uid_t uid;
 	gid_t gid;
 	int ro;
 	bool noatime;
+	enum { EXFAT_REPAIR_NO, EXFAT_REPAIR_ASK, EXFAT_REPAIR_YES } repair;
 };
 
 /* in-core nodes iterator */
@@ -136,6 +143,7 @@
 };
 
 extern int exfat_errors;
+extern int exfat_errors_fixed;
 
 void exfat_bug(const char* format, ...) PRINTF NORETURN;
 void exfat_error(const char* format, ...) PRINTF;
@@ -146,29 +154,29 @@
 int exfat_close(struct exfat_dev* dev);
 int exfat_fsync(struct exfat_dev* dev);
 enum exfat_mode exfat_get_mode(const struct exfat_dev* dev);
-loff_t exfat_get_size(const struct exfat_dev* dev);
-loff_t exfat_seek(struct exfat_dev* dev, loff_t offset, int whence);
+off_t exfat_get_size(const struct exfat_dev* dev);
+off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence);
 ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size);
 ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size);
 ssize_t exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
-		loff_t offset);
+		off_t offset);
 ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
-		loff_t offset);
+		off_t offset);
 ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
-		void* buffer, size_t size, loff_t offset);
+		void* buffer, size_t size, off_t offset);
 ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
-		const void* buffer, size_t size, loff_t offset);
+		const void* buffer, size_t size, off_t offset);
 
 int exfat_opendir(struct exfat* ef, struct exfat_node* dir,
 		struct exfat_iterator* it);
 void exfat_closedir(struct exfat* ef, struct exfat_iterator* it);
-struct exfat_node* exfat_readdir(struct exfat* ef, struct exfat_iterator* it);
+struct exfat_node* exfat_readdir(struct exfat_iterator* it);
 int exfat_lookup(struct exfat* ef, struct exfat_node** node,
 		const char* path);
 int exfat_split(struct exfat* ef, struct exfat_node** parent,
 		struct exfat_node** node, le16_t* name, const char* path);
 
-loff_t exfat_c2o(const struct exfat* ef, cluster_t cluster);
+off_t exfat_c2o(const struct exfat* ef, cluster_t cluster);
 cluster_t exfat_next_cluster(const struct exfat* ef,
 		const struct exfat_node* node, cluster_t cluster);
 cluster_t exfat_advance_cluster(const struct exfat* ef,
@@ -178,27 +186,29 @@
 int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size,
 		bool erase);
 uint32_t exfat_count_free_clusters(const struct exfat* ef);
-int exfat_find_used_sectors(const struct exfat* ef, loff_t* a, loff_t* b);
+int exfat_find_used_sectors(const struct exfat* ef, off_t* a, off_t* b);
 
 void exfat_stat(const struct exfat* ef, const struct exfat_node* node,
 		struct stat* stbuf);
-void exfat_get_name(const struct exfat_node* node, char* buffer, size_t n);
+void exfat_get_name(const struct exfat_node* node,
+		char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]);
 uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry);
 uint16_t exfat_add_checksum(const void* entry, uint16_t sum);
-le16_t exfat_calc_checksum(const struct exfat_entry_meta1* meta1,
-		const struct exfat_entry_meta2* meta2, const le16_t* name);
+le16_t exfat_calc_checksum(const struct exfat_entry* entries, int n);
 uint32_t exfat_vbr_start_checksum(const void* sector, size_t size);
 uint32_t exfat_vbr_add_checksum(const void* sector, size_t size, uint32_t sum);
-le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name);
+le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name,
+		size_t length);
 void exfat_humanize_bytes(uint64_t value, struct exfat_human_bytes* hb);
 void exfat_print_info(const struct exfat_super_block* sb,
 		uint32_t free_clusters);
+bool exfat_match_option(const char* options, const char* option_name);
 
-int utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
+int exfat_utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
 		size_t insize);
-int utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
+int exfat_utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
 		size_t insize);
-size_t utf16_length(const le16_t* str);
+size_t exfat_utf16_length(const le16_t* str);
 
 struct exfat_node* exfat_get_node(struct exfat_node* node);
 void exfat_put_node(struct exfat* ef, struct exfat_node* node);
@@ -217,12 +227,22 @@
 const char* exfat_get_label(struct exfat* ef);
 int exfat_set_label(struct exfat* ef, const char* label);
 
+int exfat_soil_super_block(const struct exfat* ef);
 int exfat_mount(struct exfat* ef, const char* spec, const char* options);
 void exfat_unmount(struct exfat* ef);
 
-time_t exfat_exfat2unix(le16_t date, le16_t time, uint8_t centisec);
+time_t exfat_exfat2unix(le16_t date, le16_t time, uint8_t centisec,
+		uint8_t tzoffset);
 void exfat_unix2exfat(time_t unix_time, le16_t* date, le16_t* time,
-		uint8_t* centisec);
+		uint8_t* centisec, uint8_t* tzoffset);
 void exfat_tzset(void);
 
+bool exfat_ask_to_fix(const struct exfat* ef);
+bool exfat_fix_invalid_vbr_checksum(const struct exfat* ef, void* sector,
+		uint32_t vbr_checksum);
+bool exfat_fix_invalid_node_checksum(const struct exfat* ef,
+		struct exfat_node* node);
+bool exfat_fix_unknown_entry(struct exfat* ef, struct exfat_node* dir,
+		const struct exfat_entry* entry, off_t offset);
+
 #endif /* ifndef EXFAT_H_INCLUDED */
diff --git a/exfat/libexfat/exfatfs.h b/exfat/libexfat/exfatfs.h
index eca2cac..b9ea268 100644
--- a/exfat/libexfat/exfatfs.h
+++ b/exfat/libexfat/exfatfs.h
@@ -3,7 +3,7 @@
 	Definitions of structures and constants used in exFAT file system.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -78,6 +78,9 @@
 #define EXFAT_ENTRY_FILE      (0x05 | EXFAT_ENTRY_VALID)
 #define EXFAT_ENTRY_FILE_INFO (0x00 | EXFAT_ENTRY_VALID | EXFAT_ENTRY_CONTINUED)
 #define EXFAT_ENTRY_FILE_NAME (0x01 | EXFAT_ENTRY_VALID | EXFAT_ENTRY_CONTINUED)
+#define EXFAT_ENTRY_FILE_TAIL (0x00 | EXFAT_ENTRY_VALID \
+                                    | EXFAT_ENTRY_CONTINUED \
+                                    | EXFAT_ENTRY_OPTIONAL)
 
 struct exfat_entry					/* common container for all entries */
 {
@@ -99,6 +102,8 @@
 PACKED;
 STATIC_ASSERT(sizeof(struct exfat_entry_bitmap) == 32);
 
+#define EXFAT_UPCASE_CHARS 0x10000
+
 struct exfat_entry_upcase			/* upper case translation table */
 {
 	uint8_t type;					/* EXFAT_ENTRY_UPCASE */
@@ -139,7 +144,8 @@
 	le16_t atime, adate;			/* latest access date and time */
 	uint8_t crtime_cs;				/* creation time in cs (centiseconds) */
 	uint8_t mtime_cs;				/* latest modification time in cs */
-	uint8_t __unknown2[10];
+	uint8_t crtime_tzo, mtime_tzo, atime_tzo;	/* timezone offset encoded */
+	uint8_t __unknown2[7];
 }
 PACKED;
 STATIC_ASSERT(sizeof(struct exfat_entry_meta1) == 32);
diff --git a/exfat/libexfat/io.c b/exfat/libexfat/io.c
index 60aabb5..0fc35d2 100644
--- a/exfat/libexfat/io.c
+++ b/exfat/libexfat/io.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -35,8 +35,11 @@
 #include <sys/disklabel.h>
 #include <sys/dkio.h>
 #include <sys/ioctl.h>
-#endif
+#elif defined(__NetBSD__)
+#include <sys/ioctl.h>
+#elif __linux__
 #include <sys/mount.h>
+#endif
 #ifdef USE_UBLIO
 #include <sys/uio.h>
 #include <ublio.h>
@@ -46,13 +49,18 @@
 {
 	int fd;
 	enum exfat_mode mode;
-	loff_t size; /* in bytes */
+	off_t size; /* in bytes */
 #ifdef USE_UBLIO
-	loff_t pos;
+	off_t pos;
 	ublio_filehandle_t ufh;
 #endif
 };
 
+static bool is_open(int fd)
+{
+	return fcntl(fd, F_GETFD) != -1;
+}
+
 static int open_ro(const char* spec)
 {
 	return open(spec, O_RDONLY);
@@ -86,6 +94,24 @@
 	struct ublio_param up;
 #endif
 
+	/* The system allocates file descriptors sequentially. If we have been
+	   started with stdin (0), stdout (1) or stderr (2) closed, the system
+	   will give us descriptor 0, 1 or 2 later when we open block device,
+	   FUSE communication pipe, etc. As a result, functions using stdin,
+	   stdout or stderr will actually work with a different thing and can
+	   corrupt it. Protect descriptors 0, 1 and 2 from such misuse. */
+	while (!is_open(STDIN_FILENO)
+		|| !is_open(STDOUT_FILENO)
+		|| !is_open(STDERR_FILENO))
+	{
+		/* we don't need those descriptors, let them leak */
+		if (open("/dev/null", O_RDWR) == -1)
+		{
+			exfat_error("failed to open /dev/null");
+			return NULL;
+		}
+	}
+
 	dev = malloc(sizeof(struct exfat_dev));
 	if (dev == NULL)
 	{
@@ -202,6 +228,21 @@
 					"you can fix this with fdisk(8)");
 	}
 	else
+#elif defined(__NetBSD__)
+	if (!S_ISREG(stbuf.st_mode))
+	{
+		off_t size;
+
+		if (ioctl(dev->fd, DIOCGMEDIASIZE, &size) == -1)
+		{
+			close(dev->fd);
+			free(dev);
+			exfat_error("failed to get media size");
+			return NULL;
+		}
+		dev->size = size;
+	}
+	else
 #endif
 	{
 		/* works for Linux, FreeBSD, Solaris */
@@ -287,18 +328,18 @@
 	return dev->mode;
 }
 
-loff_t exfat_get_size(const struct exfat_dev* dev)
+off_t exfat_get_size(const struct exfat_dev* dev)
 {
 	return dev->size;
 }
 
-loff_t exfat_seek(struct exfat_dev* dev, loff_t offset, int whence)
+off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence)
 {
 #ifdef USE_UBLIO
 	/* XXX SEEK_CUR will be handled incorrectly */
 	return dev->pos = lseek(dev->fd, offset, whence);
 #else
-	return lseek64(dev->fd, offset, whence);
+	return lseek(dev->fd, offset, whence);
 #endif
 }
 
@@ -317,7 +358,7 @@
 ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size)
 {
 #ifdef USE_UBLIO
-	ssize_t result = ublio_pwrite(dev->ufh, buffer, size, dev->pos);
+	ssize_t result = ublio_pwrite(dev->ufh, (void*) buffer, size, dev->pos);
 	if (result >= 0)
 		dev->pos += size;
 	return result;
@@ -327,114 +368,130 @@
 }
 
 ssize_t exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
-		loff_t offset)
+		off_t offset)
 {
 #ifdef USE_UBLIO
 	return ublio_pread(dev->ufh, buffer, size, offset);
 #else
-	return pread64(dev->fd, buffer, size, offset);
+	return pread(dev->fd, buffer, size, offset);
 #endif
 }
 
 ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
-		loff_t offset)
+		off_t offset)
 {
 #ifdef USE_UBLIO
-	return ublio_pwrite(dev->ufh, buffer, size, offset);
+	return ublio_pwrite(dev->ufh, (void*) buffer, size, offset);
 #else
-	return pwrite64(dev->fd, buffer, size, offset);
+	return pwrite(dev->fd, buffer, size, offset);
 #endif
 }
 
 ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
-		void* buffer, size_t size, loff_t offset)
+		void* buffer, size_t size, off_t offset)
 {
+	uint64_t newsize = offset;
 	cluster_t cluster;
 	char* bufp = buffer;
-	loff_t lsize, loffset, remainder;
+	off_t lsize, loffset, remainder;
 
-	if (offset >= node->size)
+	if (offset < 0)
+		return -EINVAL;
+	if (newsize >= node->size)
 		return 0;
 	if (size == 0)
 		return 0;
 
-	cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
-	if (CLUSTER_INVALID(cluster))
+	cluster = exfat_advance_cluster(ef, node, newsize / CLUSTER_SIZE(*ef->sb));
+	if (CLUSTER_INVALID(*ef->sb, cluster))
 	{
 		exfat_error("invalid cluster 0x%x while reading", cluster);
-		return -1;
+		return -EIO;
 	}
 
-	loffset = offset % CLUSTER_SIZE(*ef->sb);
-	remainder = MIN(size, node->size - offset);
+	loffset = newsize % CLUSTER_SIZE(*ef->sb);
+	remainder = MIN(size, node->size - newsize);
 	while (remainder > 0)
 	{
-		if (CLUSTER_INVALID(cluster))
+		if (CLUSTER_INVALID(*ef->sb, cluster))
 		{
 			exfat_error("invalid cluster 0x%x while reading", cluster);
-			return -1;
+			return -EIO;
 		}
 		lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
 		if (exfat_pread(ef->dev, bufp, lsize,
 					exfat_c2o(ef, cluster) + loffset) < 0)
 		{
 			exfat_error("failed to read cluster %#x", cluster);
-			return -1;
+			return -EIO;
 		}
 		bufp += lsize;
 		loffset = 0;
 		remainder -= lsize;
 		cluster = exfat_next_cluster(ef, node, cluster);
 	}
-	if (!ef->ro && !ef->noatime)
+	if (!(node->attrib & EXFAT_ATTRIB_DIR) && !ef->ro && !ef->noatime)
 		exfat_update_atime(node);
-	return MIN(size, node->size - offset) - remainder;
+	return MIN(size, node->size - newsize) - remainder;
 }
 
 ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
-		const void* buffer, size_t size, loff_t offset)
+		const void* buffer, size_t size, off_t offset)
 {
+	uint64_t newsize = offset;
+	int rc;
 	cluster_t cluster;
 	const char* bufp = buffer;
-	loff_t lsize, loffset, remainder;
+	off_t lsize, loffset, remainder;
 
- 	if (offset > node->size)
- 		if (exfat_truncate(ef, node, offset, true) != 0)
- 			return -1;
-  	if (offset + size > node->size)
- 		if (exfat_truncate(ef, node, offset + size, false) != 0)
- 			return -1;
+	if (offset < 0)
+		return -EINVAL;
+	if (newsize > node->size)
+	{
+		rc = exfat_truncate(ef, node, newsize, true);
+		if (rc != 0)
+			return rc;
+	}
+	if (newsize + size > node->size)
+	{
+		rc = exfat_truncate(ef, node, newsize + size, false);
+		if (rc != 0)
+			return rc;
+	}
 	if (size == 0)
 		return 0;
 
-	cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
-	if (CLUSTER_INVALID(cluster))
+	cluster = exfat_advance_cluster(ef, node, newsize / CLUSTER_SIZE(*ef->sb));
+	if (CLUSTER_INVALID(*ef->sb, cluster))
 	{
 		exfat_error("invalid cluster 0x%x while writing", cluster);
-		return -1;
+		return -EIO;
 	}
 
-	loffset = offset % CLUSTER_SIZE(*ef->sb);
+	loffset = newsize % CLUSTER_SIZE(*ef->sb);
 	remainder = size;
 	while (remainder > 0)
 	{
-		if (CLUSTER_INVALID(cluster))
+		if (CLUSTER_INVALID(*ef->sb, cluster))
 		{
 			exfat_error("invalid cluster 0x%x while writing", cluster);
-			return -1;
+			return -EIO;
 		}
 		lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
 		if (exfat_pwrite(ef->dev, bufp, lsize,
 				exfat_c2o(ef, cluster) + loffset) < 0)
 		{
 			exfat_error("failed to write cluster %#x", cluster);
-			return -1;
+			return -EIO;
 		}
 		bufp += lsize;
 		loffset = 0;
 		remainder -= lsize;
 		cluster = exfat_next_cluster(ef, node, cluster);
 	}
-	exfat_update_mtime(node);
+	if (!(node->attrib & EXFAT_ATTRIB_DIR))
+		/* directory's mtime should be updated by the caller only when it
+		   creates or removes something in this directory */
+		exfat_update_mtime(node);
 	return size - remainder;
 }
diff --git a/exfat/libexfat/log.c b/exfat/libexfat/log.c
index 38c79d4..22e5ccd 100644
--- a/exfat/libexfat/log.c
+++ b/exfat/libexfat/log.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -22,7 +22,11 @@
 
 #include "exfat.h"
 #include <stdarg.h>
+#ifdef __ANDROID__
+#include <android/log.h>
+#else
 #include <syslog.h>
+#endif
 #include <unistd.h>
 
 int exfat_errors;
@@ -43,15 +47,15 @@
 	va_end(ap);
 	fputs(".\n", stderr);
 
+#ifdef __ANDROID__
+	__android_log_vprint(ANDROID_LOG_FATAL, PACKAGE, format, aq);
+#else
 	if (!isatty(STDERR_FILENO))
 		vsyslog(LOG_CRIT, format, aq);
+#endif
 	va_end(aq);
 
-#if defined(__ANDROID__)
-    exit(-1);
-#else
 	abort();
-#endif
 }
 
 /*
@@ -71,8 +75,12 @@
 	va_end(ap);
 	fputs(".\n", stderr);
 
+#ifdef __ANDROID__
+	__android_log_vprint(ANDROID_LOG_ERROR, PACKAGE, format, aq);
+#else
 	if (!isatty(STDERR_FILENO))
 		vsyslog(LOG_ERR, format, aq);
+#endif
 	va_end(aq);
 }
 
@@ -93,8 +101,12 @@
 	va_end(ap);
 	fputs(".\n", stderr);
 
+#ifdef __ANDROID__
+	__android_log_vprint(ANDROID_LOG_WARN, PACKAGE, format, aq);
+#else
 	if (!isatty(STDERR_FILENO))
 		vsyslog(LOG_WARNING, format, aq);
+#endif
 	va_end(aq);
 }
 
@@ -103,12 +115,22 @@
  */
 void exfat_debug(const char* format, ...)
 {
-	va_list ap;
+	va_list ap, aq;
+
+	va_start(ap, format);
+	va_copy(aq, ap);
 
 	fflush(stdout);
 	fputs("DEBUG: ", stderr);
-	va_start(ap, format);
 	vfprintf(stderr, format, ap);
 	va_end(ap);
 	fputs(".\n", stderr);
+
+#ifdef __ANDROID__
+	__android_log_vprint(ANDROID_LOG_DEBUG, PACKAGE, format, aq);
+#else
+	if (!isatty(STDERR_FILENO))
+		vsyslog(LOG_DEBUG, format, aq);
+#endif
+	va_end(aq);
 }
diff --git a/exfat/libexfat/lookup.c b/exfat/libexfat/lookup.c
index 3caef74..50ad31f 100644
--- a/exfat/libexfat/lookup.c
+++ b/exfat/libexfat/lookup.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -46,7 +46,7 @@
 	it->current = NULL;
 }
 
-struct exfat_node* exfat_readdir(struct exfat* ef __unused, struct exfat_iterator* it)
+struct exfat_node* exfat_readdir(struct exfat_iterator* it)
 {
 	if (it->current == NULL)
 		it->current = it->parent->child;
@@ -61,10 +61,7 @@
 
 static int compare_char(struct exfat* ef, uint16_t a, uint16_t b)
 {
-	if (a >= ef->upcase_chars || b >= ef->upcase_chars)
-		return (int) a - (int) b;
-
-	return (int) le16_to_cpu(ef->upcase[a]) - (int) le16_to_cpu(ef->upcase[b]);
+	return (int) ef->upcase[a] - (int) ef->upcase[b];
 }
 
 static int compare_name(struct exfat* ef, const le16_t* a, const le16_t* b)
@@ -89,14 +86,14 @@
 
 	*node = NULL;
 
-	rc = utf8_to_utf16(buffer, name, EXFAT_NAME_MAX, n);
+	rc = exfat_utf8_to_utf16(buffer, name, EXFAT_NAME_MAX + 1, n);
 	if (rc != 0)
 		return rc;
 
 	rc = exfat_opendir(ef, parent, &it);
 	if (rc != 0)
 		return rc;
-	while ((*node = exfat_readdir(ef, &it)))
+	while ((*node = exfat_readdir(&it)))
 	{
 		if (compare_name(ef, buffer, (*node)->name) == 0)
 		{
@@ -197,7 +194,7 @@
 				exfat_put_node(ef, *parent);
 				return -ENOENT;
 			}
-			rc = utf8_to_utf16(name, p, EXFAT_NAME_MAX, n);
+			rc = exfat_utf8_to_utf16(name, p, EXFAT_NAME_MAX + 1, n);
 			if (rc != 0)
 			{
 				exfat_put_node(ef, *parent);
diff --git a/exfat/libexfat/mount.c b/exfat/libexfat/mount.c
index 45a5d49..f0ca0e3 100644
--- a/exfat/libexfat/mount.c
+++ b/exfat/libexfat/mount.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -44,7 +44,7 @@
 					clusters);
 			return 0;
 		}
-		if (CLUSTER_INVALID(rootdir_cluster))
+		if (CLUSTER_INVALID(*ef->sb, rootdir_cluster))
 		{
 			exfat_error("bad cluster %#x while reading root directory",
 					rootdir_cluster);
@@ -79,18 +79,6 @@
 	return strtol(p, NULL, base);
 }
 
-static bool match_option(const char* options, const char* option_name)
-{
-	const char* p;
-	size_t length = strlen(option_name);
-
-	for (p = strstr(options, option_name); p; p = strstr(p + 1, option_name))
-		if ((p == options || p[-1] == ',') &&
-				(p[length] == ',' || p[length] == '\0'))
-			return true;
-	return false;
-}
-
 static void parse_options(struct exfat* ef, const char* options)
 {
 	int opt_umask;
@@ -102,16 +90,29 @@
 	ef->uid = get_int_option(options, "uid", 10, geteuid());
 	ef->gid = get_int_option(options, "gid", 10, getegid());
 
-	ef->noatime = match_option(options, "noatime");
+	ef->noatime = exfat_match_option(options, "noatime");
+
+	switch (get_int_option(options, "repair", 10, 0))
+	{
+	case 1:
+		ef->repair = EXFAT_REPAIR_ASK;
+		break;
+	case 2:
+		ef->repair = EXFAT_REPAIR_YES;
+		break;
+	default:
+		ef->repair = EXFAT_REPAIR_NO;
+		break;
+	}
 }
 
-static bool verify_vbr_checksum(struct exfat_dev* dev, void* sector,
-		loff_t sector_size)
+static bool verify_vbr_checksum(const struct exfat* ef, void* sector)
 {
+	off_t sector_size = SECTOR_SIZE(*ef->sb);
 	uint32_t vbr_checksum;
-	int i;
+	size_t i;
 
-	if (exfat_pread(dev, sector, sector_size, 0) < 0)
+	if (exfat_pread(ef->dev, sector, sector_size, 0) < 0)
 	{
 		exfat_error("failed to read boot sector");
 		return false;
@@ -119,7 +120,7 @@
 	vbr_checksum = exfat_vbr_start_checksum(sector, sector_size);
 	for (i = 1; i < 11; i++)
 	{
-		if (exfat_pread(dev, sector, sector_size, i * sector_size) < 0)
+		if (exfat_pread(ef->dev, sector, sector_size, i * sector_size) < 0)
 		{
 			exfat_error("failed to read VBR sector");
 			return false;
@@ -127,7 +128,7 @@
 		vbr_checksum = exfat_vbr_add_checksum(sector, sector_size,
 				vbr_checksum);
 	}
-	if (exfat_pread(dev, sector, sector_size, i * sector_size) < 0)
+	if (exfat_pread(ef->dev, sector, sector_size, i * sector_size) < 0)
 	{
 		exfat_error("failed to read VBR checksum sector");
 		return false;
@@ -137,7 +138,8 @@
 		{
 			exfat_error("invalid VBR checksum 0x%x (expected 0x%x)",
 					le32_to_cpu(((const le32_t*) sector)[i]), vbr_checksum);
-			return false;
+			if (!EXFAT_REPAIR(invalid_vbr_checksum, ef, sector, vbr_checksum))
+				return false;
 		}
 	return true;
 }
@@ -152,11 +154,8 @@
 	return exfat_fsync(ef->dev);
 }
 
-static int prepare_super_block(const struct exfat* ef)
+int exfat_soil_super_block(const struct exfat* ef)
 {
-	if (le16_to_cpu(ef->sb->volume_state) & EXFAT_STATE_MOUNTED)
-		exfat_warn("volume was not unmounted cleanly");
-
 	if (ef->ro)
 		return 0;
 
@@ -165,6 +164,22 @@
 	return commit_super_block(ef);
 }
 
+static void exfat_free(struct exfat* ef)
+{
+	exfat_close(ef->dev);	/* first of all, close the descriptor */
+	ef->dev = NULL;			/* struct exfat_dev is freed by exfat_close() */
+	free(ef->root);
+	ef->root = NULL;
+	free(ef->zero_cluster);
+	ef->zero_cluster = NULL;
+	free(ef->cmap.chunk);
+	ef->cmap.chunk = NULL;
+	free(ef->upcase);
+	ef->upcase = NULL;
+	free(ef->sb);
+	ef->sb = NULL;
+}
+
 int exfat_mount(struct exfat* ef, const char* spec, const char* options)
 {
 	int rc;
@@ -175,9 +190,9 @@
 
 	parse_options(ef, options);
 
-	if (match_option(options, "ro"))
+	if (exfat_match_option(options, "ro"))
 		mode = EXFAT_MODE_RO;
-	else if (match_option(options, "ro_fallback"))
+	else if (exfat_match_option(options, "ro_fallback"))
 		mode = EXFAT_MODE_ANY;
 	else
 		mode = EXFAT_MODE_RW;
@@ -195,109 +210,105 @@
 	ef->sb = malloc(sizeof(struct exfat_super_block));
 	if (ef->sb == NULL)
 	{
-		exfat_close(ef->dev);
 		exfat_error("failed to allocate memory for the super block");
+		exfat_free(ef);
 		return -ENOMEM;
 	}
 	memset(ef->sb, 0, sizeof(struct exfat_super_block));
 
 	if (exfat_pread(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0) < 0)
 	{
-		exfat_close(ef->dev);
-		free(ef->sb);
 		exfat_error("failed to read boot sector");
+		exfat_free(ef);
 		return -EIO;
 	}
 	if (memcmp(ef->sb->oem_name, "EXFAT   ", 8) != 0)
 	{
-		exfat_close(ef->dev);
-		free(ef->sb);
 		exfat_error("exFAT file system is not found");
+		exfat_free(ef);
 		return -EIO;
 	}
 	/* sector cannot be smaller than 512 bytes */
 	if (ef->sb->sector_bits < 9)
 	{
-		exfat_close(ef->dev);
 		exfat_error("too small sector size: 2^%hhd", ef->sb->sector_bits);
-		free(ef->sb);
+		exfat_free(ef);
 		return -EIO;
 	}
 	/* officially exFAT supports cluster size up to 32 MB */
 	if ((int) ef->sb->sector_bits + (int) ef->sb->spc_bits > 25)
 	{
-		exfat_close(ef->dev);
 		exfat_error("too big cluster size: 2^(%hhd+%hhd)",
 				ef->sb->sector_bits, ef->sb->spc_bits);
-		free(ef->sb);
+		exfat_free(ef);
 		return -EIO;
 	}
 	ef->zero_cluster = malloc(CLUSTER_SIZE(*ef->sb));
 	if (ef->zero_cluster == NULL)
 	{
-		exfat_close(ef->dev);
-		free(ef->sb);
 		exfat_error("failed to allocate zero sector");
+		exfat_free(ef);
 		return -ENOMEM;
 	}
 	/* use zero_cluster as a temporary buffer for VBR checksum verification */
-	if (!verify_vbr_checksum(ef->dev, ef->zero_cluster, SECTOR_SIZE(*ef->sb)))
+	if (!verify_vbr_checksum(ef, ef->zero_cluster))
 	{
-		free(ef->zero_cluster);
-		exfat_close(ef->dev);
-		free(ef->sb);
+		exfat_free(ef);
 		return -EIO;
 	}
 	memset(ef->zero_cluster, 0, CLUSTER_SIZE(*ef->sb));
 	if (ef->sb->version.major != 1 || ef->sb->version.minor != 0)
 	{
-		free(ef->zero_cluster);
-		exfat_close(ef->dev);
 		exfat_error("unsupported exFAT version: %hhu.%hhu",
 				ef->sb->version.major, ef->sb->version.minor);
-		free(ef->sb);
+		exfat_free(ef);
 		return -EIO;
 	}
 	if (ef->sb->fat_count != 1)
 	{
-		free(ef->zero_cluster);
-		exfat_close(ef->dev);
 		exfat_error("unsupported FAT count: %hhu", ef->sb->fat_count);
-		free(ef->sb);
+		exfat_free(ef);
 		return -EIO;
 	}
 	if (le64_to_cpu(ef->sb->sector_count) * SECTOR_SIZE(*ef->sb) >
-			exfat_get_size(ef->dev))
+			(uint64_t) exfat_get_size(ef->dev))
 	{
 		/* this can cause I/O errors later but we don't fail mounting to let
 		   user rescue data */
-		exfat_warn("file system is larger than underlying device: "
-				"%"PRIu64" > %"PRIu64,
-				le64_to_cpu(ef->sb->sector_count) * SECTOR_SIZE(*ef->sb),
+		exfat_warn("file system in sectors is larger than device: "
+				"%"PRIu64" * %d > %"PRIu64,
+				le64_to_cpu(ef->sb->sector_count), SECTOR_SIZE(*ef->sb),
 				exfat_get_size(ef->dev));
 	}
+	if ((off_t) le32_to_cpu(ef->sb->cluster_count) * CLUSTER_SIZE(*ef->sb) >
+			exfat_get_size(ef->dev))
+	{
+		exfat_error("file system in clusters is larger than device: "
+				"%u * %d > %"PRIu64,
+				le32_to_cpu(ef->sb->cluster_count), CLUSTER_SIZE(*ef->sb),
+				exfat_get_size(ef->dev));
+		exfat_free(ef);
+		return -EIO;
+	}
+	if (le16_to_cpu(ef->sb->volume_state) & EXFAT_STATE_MOUNTED)
+		exfat_warn("volume was not unmounted cleanly");
 
 	ef->root = malloc(sizeof(struct exfat_node));
 	if (ef->root == NULL)
 	{
-		free(ef->zero_cluster);
-		exfat_close(ef->dev);
-		free(ef->sb);
 		exfat_error("failed to allocate root node");
+		exfat_free(ef);
 		return -ENOMEM;
 	}
 	memset(ef->root, 0, sizeof(struct exfat_node));
-	ef->root->flags = EXFAT_ATTRIB_DIR;
+	ef->root->attrib = EXFAT_ATTRIB_DIR;
 	ef->root->start_cluster = le32_to_cpu(ef->sb->rootdir_cluster);
 	ef->root->fptr_cluster = ef->root->start_cluster;
 	ef->root->name[0] = cpu_to_le16('\0');
 	ef->root->size = rootdir_size(ef);
 	if (ef->root->size == 0)
 	{
-		free(ef->root);
-		free(ef->zero_cluster);
-		exfat_close(ef->dev);
-		free(ef->sb);
+		exfat_free(ef);
 		return -EIO;
 	}
 	/* exFAT does not have time attributes for the root directory */
@@ -320,18 +331,12 @@
 		goto error;
 	}
 
-	if (prepare_super_block(ef) != 0)
-		goto error;
-
 	return 0;
 
 error:
 	exfat_put_node(ef, ef->root);
 	exfat_reset_cache(ef);
-	free(ef->root);
-	free(ef->zero_cluster);
-	exfat_close(ef->dev);
-	free(ef->sb);
+	exfat_free(ef);
 	return -EIO;
 }
 
@@ -363,18 +368,6 @@
 	exfat_flush(ef);		/* ignore return code */
 	exfat_put_node(ef, ef->root);
 	exfat_reset_cache(ef);
-	free(ef->root);
-	ef->root = NULL;
 	finalize_super_block(ef);
-	exfat_close(ef->dev);	/* close descriptor immediately after fsync */
-	ef->dev = NULL;
-	free(ef->zero_cluster);
-	ef->zero_cluster = NULL;
-	free(ef->cmap.chunk);
-	ef->cmap.chunk = NULL;
-	free(ef->sb);
-	ef->sb = NULL;
-	free(ef->upcase);
-	ef->upcase = NULL;
-	ef->upcase_chars = 0;
+	exfat_free(ef);			/* will close the descriptor */
 }
diff --git a/exfat/libexfat/node.c b/exfat/libexfat/node.c
index e4fd32f..9cffbcb 100644
--- a/exfat/libexfat/node.c
+++ b/exfat/libexfat/node.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -25,14 +25,7 @@
 #include <string.h>
 #include <inttypes.h>
 
-/* on-disk nodes iterator */
-struct iterator
-{
-	cluster_t cluster;
-	loff_t offset;
-	int contiguous;
-	char* chunk;
-};
+#define EXFAT_ENTRY_NONE (-1)
 
 struct exfat_node* exfat_get_node(struct exfat_node* node)
 {
@@ -44,19 +37,19 @@
 
 void exfat_put_node(struct exfat* ef, struct exfat_node* node)
 {
-	char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
+	char buffer[EXFAT_UTF8_NAME_BUFFER_MAX];
 
 	--node->references;
 	if (node->references < 0)
 	{
-		exfat_get_name(node, buffer, sizeof(buffer) - 1);
+		exfat_get_name(node, buffer);
 		exfat_bug("reference counter of '%s' is below zero", buffer);
 	}
 	else if (node->references == 0 && node != ef->root)
 	{
-		if (node->flags & EXFAT_ATTRIB_DIRTY)
+		if (node->is_dirty)
 		{
-			exfat_get_name(node, buffer, sizeof(buffer) - 1);
+			exfat_get_name(node, buffer);
 			exfat_warn("dirty node '%s' with zero references", buffer);
 		}
 	}
@@ -74,7 +67,7 @@
 		exfat_bug("unable to cleanup a node with %d references",
 				node->references);
 
-	if (node->flags & EXFAT_ATTRIB_UNLINKED)
+	if (node->is_unlinked)
 	{
 		/* free all clusters and node structure itself */
 		rc = exfat_truncate(ef, node, 0, true);
@@ -84,74 +77,44 @@
 	return rc;
 }
 
-/**
- * Cluster + offset from the beginning of the directory to absolute offset.
- */
-static loff_t co2o(struct exfat* ef, cluster_t cluster, loff_t offset)
+static int read_entries(struct exfat* ef, struct exfat_node* dir,
+		struct exfat_entry* entries, int n, off_t offset)
 {
-	return exfat_c2o(ef, cluster) + offset % CLUSTER_SIZE(*ef->sb);
-}
+	ssize_t size;
 
-static int opendir(struct exfat* ef, const struct exfat_node* dir,
-		struct iterator* it)
-{
-	if (!(dir->flags & EXFAT_ATTRIB_DIR))
-		exfat_bug("not a directory");
-	it->cluster = dir->start_cluster;
-	it->offset = 0;
-	it->contiguous = IS_CONTIGUOUS(*dir);
-	it->chunk = malloc(CLUSTER_SIZE(*ef->sb));
-	if (it->chunk == NULL)
-	{
-		exfat_error("out of memory");
-		return -ENOMEM;
-	}
-	if (exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
-			exfat_c2o(ef, it->cluster)) < 0)
-	{
-		exfat_error("failed to read directory cluster %#x", it->cluster);
+	if (!(dir->attrib & EXFAT_ATTRIB_DIR))
+		exfat_bug("attempted to read entries from a file");
+
+	size = exfat_generic_pread(ef, dir, entries,
+			sizeof(struct exfat_entry[n]), offset);
+	if (size == (ssize_t) sizeof(struct exfat_entry) * n)
+		return 0; /* success */
+	if (size == 0)
+		return -ENOENT;
+	if (size < 0)
 		return -EIO;
-	}
-	return 0;
+	exfat_error("read %zd bytes instead of %zu bytes", size,
+			sizeof(struct exfat_entry[n]));
+	return -EIO;
 }
 
-static void closedir(struct iterator* it)
+static int write_entries(struct exfat* ef, struct exfat_node* dir,
+		const struct exfat_entry* entries, int n, off_t offset)
 {
-	it->cluster = 0;
-	it->offset = 0;
-	it->contiguous = 0;
-	free(it->chunk);
-	it->chunk = NULL;
-}
+	ssize_t size;
 
-static bool fetch_next_entry(struct exfat* ef, const struct exfat_node* parent,
-		struct iterator* it)
-{
-	/* move iterator to the next entry in the directory */
-	it->offset += sizeof(struct exfat_entry);
-	/* fetch the next cluster if needed */
-	if ((it->offset & (CLUSTER_SIZE(*ef->sb) - 1)) == 0)
-	{
-		/* reached the end of directory; the caller should check this
-		   condition too */
-		if (it->offset >= parent->size)
-			return true;
-		it->cluster = exfat_next_cluster(ef, parent, it->cluster);
-		if (CLUSTER_INVALID(it->cluster))
-		{
-			exfat_error("invalid cluster 0x%x while reading directory",
-					it->cluster);
-			return false;
-		}
-		if (exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
-				exfat_c2o(ef, it->cluster)) < 0)
-		{
-			exfat_error("failed to read the next directory cluster %#x",
-					it->cluster);
-			return false;
-		}
-	}
-	return true;
+	if (!(dir->attrib & EXFAT_ATTRIB_DIR))
+		exfat_bug("attempted to write entries into a file");
+
+	size = exfat_generic_pwrite(ef, dir, entries,
+			sizeof(struct exfat_entry[n]), offset);
+	if (size == (ssize_t) sizeof(struct exfat_entry) * n)
+		return 0; /* success */
+	if (size < 0)
+		return -EIO;
+	exfat_error("wrote %zd bytes instead of %zu bytes", size,
+			sizeof(struct exfat_entry[n]));
+	return -EIO;
 }
 
 static struct exfat_node* allocate_node(void)
@@ -169,11 +132,13 @@
 static void init_node_meta1(struct exfat_node* node,
 		const struct exfat_entry_meta1* meta1)
 {
-	node->flags = le16_to_cpu(meta1->attrib);
+	node->attrib = le16_to_cpu(meta1->attrib);
+	node->continuations = meta1->continuations;
 	node->mtime = exfat_exfat2unix(meta1->mdate, meta1->mtime,
-			meta1->mtime_cs);
+			meta1->mtime_cs, meta1->mtime_tzo);
 	/* there is no centiseconds field for atime */
-	node->atime = exfat_exfat2unix(meta1->adate, meta1->atime, 0);
+	node->atime = exfat_exfat2unix(meta1->adate, meta1->atime,
+			0, meta1->atime_tzo);
 }
 
 static void init_node_meta2(struct exfat_node* node,
@@ -182,32 +147,85 @@
 	node->size = le64_to_cpu(meta2->size);
 	node->start_cluster = le32_to_cpu(meta2->start_cluster);
 	node->fptr_cluster = node->start_cluster;
-	if (meta2->flags & EXFAT_FLAG_CONTIGUOUS)
-		node->flags |= EXFAT_ATTRIB_CONTIGUOUS;
+	node->is_contiguous = ((meta2->flags & EXFAT_FLAG_CONTIGUOUS) != 0);
 }
 
-static const struct exfat_entry* get_entry_ptr(const struct exfat* ef,
-		const struct iterator* it)
+static void init_node_name(struct exfat_node* node,
+		const struct exfat_entry* entries, int n)
 {
-	return (const struct exfat_entry*)
-			(it->chunk + it->offset % CLUSTER_SIZE(*ef->sb));
+	int i;
+
+	for (i = 0; i < n; i++)
+		memcpy(node->name + i * EXFAT_ENAME_MAX,
+				((const struct exfat_entry_name*) &entries[i])->name,
+				EXFAT_ENAME_MAX * sizeof(le16_t));
 }
 
-static bool check_node(const struct exfat_node* node, uint16_t actual_checksum,
-		uint16_t reference_checksum, uint64_t valid_size)
+static bool check_entries(const struct exfat_entry* entry, int n)
 {
-	char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
+	int previous = EXFAT_ENTRY_NONE;
+	int current;
+	int i;
+
+	/* check transitions between entries types */
+	for (i = 0; i < n + 1; previous = current, i++)
+	{
+		bool valid = false;
+
+		current = (i < n) ? entry[i].type : EXFAT_ENTRY_NONE;
+		switch (previous)
+		{
+		case EXFAT_ENTRY_NONE:
+			valid = (current == EXFAT_ENTRY_FILE);
+			break;
+		case EXFAT_ENTRY_FILE:
+			valid = (current == EXFAT_ENTRY_FILE_INFO);
+			break;
+		case EXFAT_ENTRY_FILE_INFO:
+			valid = (current == EXFAT_ENTRY_FILE_NAME);
+			break;
+		case EXFAT_ENTRY_FILE_NAME:
+			valid = (current == EXFAT_ENTRY_FILE_NAME ||
+			         current == EXFAT_ENTRY_NONE ||
+			         current >= EXFAT_ENTRY_FILE_TAIL);
+			break;
+		case EXFAT_ENTRY_FILE_TAIL ... 0xff:
+			valid = (current >= EXFAT_ENTRY_FILE_TAIL ||
+			         current == EXFAT_ENTRY_NONE);
+			break;
+		}
+
+		if (!valid)
+		{
+			exfat_error("unexpected entry type %#x after %#x at %d/%d",
+					current, previous, i, n);
+			return false;
+		}
+	}
+	return true;
+}
+
+static bool check_node(const struct exfat* ef, struct exfat_node* node,
+		le16_t actual_checksum, const struct exfat_entry_meta1* meta1,
+		const struct exfat_entry_meta2* meta2)
+{
+	int cluster_size = CLUSTER_SIZE(*ef->sb);
+	uint64_t clusters_heap_size =
+			(uint64_t) le32_to_cpu(ef->sb->cluster_count) * cluster_size;
+	char buffer[EXFAT_UTF8_NAME_BUFFER_MAX];
+	bool ret = true;
 
 	/*
 	   Validate checksum first. If it's invalid all other fields probably
 	   contain just garbage.
 	*/
-	if (actual_checksum != reference_checksum)
+	if (le16_to_cpu(actual_checksum) != le16_to_cpu(meta1->checksum))
 	{
-		exfat_get_name(node, buffer, sizeof(buffer) - 1);
+		exfat_get_name(node, buffer);
 		exfat_error("'%s' has invalid checksum (%#hx != %#hx)", buffer,
-				actual_checksum, reference_checksum);
-		return false;
+				le16_to_cpu(actual_checksum), le16_to_cpu(meta1->checksum));
+		if (!EXFAT_REPAIR(invalid_node_checksum, ef, node))
+			ret = false;
 	}
 
 	/*
@@ -216,208 +234,252 @@
 	   cannot be greater than file size. See SetFileValidData() function
 	   description in MSDN.
 	*/
-	if (valid_size > node->size)
+	if (le64_to_cpu(meta2->valid_size) > node->size)
 	{
-		exfat_get_name(node, buffer, sizeof(buffer) - 1);
+		exfat_get_name(node, buffer);
 		exfat_error("'%s' has valid size (%"PRIu64") greater than size "
-				"(%"PRIu64")", buffer, valid_size, node->size);
-		return false;
+				"(%"PRIu64")", buffer, le64_to_cpu(meta2->valid_size),
+				node->size);
+		ret = false;
 	}
 
-	return true;
+	/*
+	   Empty file must have zero start cluster. Non-empty file must start
+	   with a valid cluster. Directories cannot be empty (i.e. must always
+	   have a valid start cluster), but we will check this later while
+	   reading that directory to give user a chance to read this directory.
+	*/
+	if (node->size == 0 && node->start_cluster != EXFAT_CLUSTER_FREE)
+	{
+		exfat_get_name(node, buffer);
+		exfat_error("'%s' is empty but start cluster is %#x", buffer,
+				node->start_cluster);
+		ret = false;
+	}
+	if (node->size > 0 && CLUSTER_INVALID(*ef->sb, node->start_cluster))
+	{
+		exfat_get_name(node, buffer);
+		exfat_error("'%s' points to invalid cluster %#x", buffer,
+				node->start_cluster);
+		ret = false;
+	}
+
+	/* File or directory cannot be larger than clusters heap. */
+	if (node->size > clusters_heap_size)
+	{
+		exfat_get_name(node, buffer);
+		exfat_error("'%s' is larger than clusters heap: %"PRIu64" > %"PRIu64,
+				buffer, node->size, clusters_heap_size);
+		ret = false;
+	}
+
+	/* Empty file or directory must be marked as non-contiguous. */
+	if (node->size == 0 && node->is_contiguous)
+	{
+		exfat_get_name(node, buffer);
+		exfat_error("'%s' is empty but marked as contiguous (%#hx)", buffer,
+				node->attrib);
+		ret = false;
+	}
+
+	/* Directory size must be aligned on at cluster boundary. */
+	if ((node->attrib & EXFAT_ATTRIB_DIR) && node->size % cluster_size != 0)
+	{
+		exfat_get_name(node, buffer);
+		exfat_error("'%s' directory size %"PRIu64" is not divisible by %d", buffer,
+				node->size, cluster_size);
+		ret = false;
+	}
+
+	return ret;
+}
+
+static int parse_file_entries(struct exfat* ef, struct exfat_node* node,
+		const struct exfat_entry* entries, int n)
+{
+	const struct exfat_entry_meta1* meta1;
+	const struct exfat_entry_meta2* meta2;
+	int mandatory_entries;
+
+	if (!check_entries(entries, n))
+		return -EIO;
+
+	meta1 = (const struct exfat_entry_meta1*) &entries[0];
+	if (meta1->continuations < 2)
+	{
+		exfat_error("too few continuations (%hhu)", meta1->continuations);
+		return -EIO;
+	}
+	meta2 = (const struct exfat_entry_meta2*) &entries[1];
+	if (meta2->flags & ~(EXFAT_FLAG_ALWAYS1 | EXFAT_FLAG_CONTIGUOUS))
+	{
+		exfat_error("unknown flags in meta2 (%#hhx)", meta2->flags);
+		return -EIO;
+	}
+	mandatory_entries = 2 + DIV_ROUND_UP(meta2->name_length, EXFAT_ENAME_MAX);
+	if (meta1->continuations < mandatory_entries - 1)
+	{
+		exfat_error("too few continuations (%hhu < %d)",
+				meta1->continuations, mandatory_entries - 1);
+		return -EIO;
+	}
+
+	init_node_meta1(node, meta1);
+	init_node_meta2(node, meta2);
+	init_node_name(node, entries + 2, mandatory_entries - 2);
+
+	if (!check_node(ef, node, exfat_calc_checksum(entries, n), meta1, meta2))
+		return -EIO;
+
+	return 0;
+}
+
+static int parse_file_entry(struct exfat* ef, struct exfat_node* parent,
+		struct exfat_node** node, off_t* offset, int n)
+{
+	struct exfat_entry entries[n];
+	int rc;
+
+	rc = read_entries(ef, parent, entries, n, *offset);
+	if (rc != 0)
+		return rc;
+
+	/* a new node has zero references */
+	*node = allocate_node();
+	if (*node == NULL)
+		return -ENOMEM;
+	(*node)->entry_offset = *offset;
+
+	rc = parse_file_entries(ef, *node, entries, n);
+	if (rc != 0)
+	{
+		free(*node);
+		return rc;
+	}
+
+	*offset += sizeof(struct exfat_entry[n]);
+	return 0;
+}
+
+static void decompress_upcase(uint16_t* output, const le16_t* source,
+		size_t size)
+{
+	size_t si;
+	size_t oi;
+
+	for (oi = 0; oi < EXFAT_UPCASE_CHARS; oi++)
+		output[oi] = oi;
+
+	for (si = 0, oi = 0; si < size && oi < EXFAT_UPCASE_CHARS; si++)
+	{
+		uint16_t ch = le16_to_cpu(source[si]);
+
+		if (ch == 0xffff && si + 1 < size)	/* indicates a run */
+			oi += le16_to_cpu(source[++si]);
+		else
+			output[oi++] = ch;
+	}
 }
 
 /*
- * Reads one entry in directory at position pointed by iterator and fills
- * node structure.
+ * Read one entry in a directory at offset position and build a new node
+ * structure.
  */
-static int readdir(struct exfat* ef, const struct exfat_node* parent,
-		struct exfat_node** node, struct iterator* it)
+static int readdir(struct exfat* ef, struct exfat_node* parent,
+		struct exfat_node** node, off_t* offset)
 {
-	int rc = -EIO;
-	const struct exfat_entry* entry;
+	int rc;
+	struct exfat_entry entry;
 	const struct exfat_entry_meta1* meta1;
-	const struct exfat_entry_meta2* meta2;
-	const struct exfat_entry_name* file_name;
 	const struct exfat_entry_upcase* upcase;
 	const struct exfat_entry_bitmap* bitmap;
 	const struct exfat_entry_label* label;
-	uint8_t continuations = 0;
-	le16_t* namep = NULL;
-	uint16_t reference_checksum = 0;
-	uint16_t actual_checksum = 0;
-	uint64_t valid_size = 0;
-
-	*node = NULL;
+	uint64_t upcase_size = 0;
+	le16_t* upcase_comp = NULL;
+	le16_t label_name[EXFAT_ENAME_MAX];
 
 	for (;;)
 	{
-		if (it->offset >= parent->size)
-		{
-			if (continuations != 0)
-			{
-				exfat_error("expected %hhu continuations", continuations);
-				goto error;
-			}
-			return -ENOENT; /* that's OK, means end of directory */
-		}
+		rc = read_entries(ef, parent, &entry, 1, *offset);
+		if (rc != 0)
+			return rc;
 
-		entry = get_entry_ptr(ef, it);
-		switch (entry->type)
+		switch (entry.type)
 		{
 		case EXFAT_ENTRY_FILE:
-			if (continuations != 0)
-			{
-				exfat_error("expected %hhu continuations before new entry",
-						continuations);
-				goto error;
-			}
-			meta1 = (const struct exfat_entry_meta1*) entry;
-			continuations = meta1->continuations;
-			/* each file entry must have at least 2 continuations:
-			   info and name */
-			if (continuations < 2)
-			{
-				exfat_error("too few continuations (%hhu)", continuations);
-				goto error;
-			}
-			if (continuations > 1 +
-					DIV_ROUND_UP(EXFAT_NAME_MAX, EXFAT_ENAME_MAX))
-			{
-				exfat_error("too many continuations (%hhu)", continuations);
-				goto error;
-			}
-			reference_checksum = le16_to_cpu(meta1->checksum);
-			actual_checksum = exfat_start_checksum(meta1);
-			*node = allocate_node();
-			if (*node == NULL)
-			{
-				rc = -ENOMEM;
-				goto error;
-			}
-			/* new node has zero reference counter */
-			(*node)->entry_cluster = it->cluster;
-			(*node)->entry_offset = it->offset;
-			init_node_meta1(*node, meta1);
-			namep = (*node)->name;
-			break;
-
-		case EXFAT_ENTRY_FILE_INFO:
-			if (continuations < 2)
-			{
-				exfat_error("unexpected continuation (%hhu)",
-						continuations);
-				goto error;
-			}
-			meta2 = (const struct exfat_entry_meta2*) entry;
-			if (meta2->flags & ~(EXFAT_FLAG_ALWAYS1 | EXFAT_FLAG_CONTIGUOUS))
-			{
-				exfat_error("unknown flags in meta2 (0x%hhx)", meta2->flags);
-				goto error;
-			}
-			init_node_meta2(*node, meta2);
-			actual_checksum = exfat_add_checksum(entry, actual_checksum);
-			valid_size = le64_to_cpu(meta2->valid_size);
-			/* empty files must be marked as non-contiguous */
-			if ((*node)->size == 0 && (meta2->flags & EXFAT_FLAG_CONTIGUOUS))
-			{
-				exfat_error("empty file marked as contiguous (0x%hhx)",
-						meta2->flags);
-				goto error;
-			}
-			/* directories must be aligned on at cluster boundary */
-			if (((*node)->flags & EXFAT_ATTRIB_DIR) &&
-				(*node)->size % CLUSTER_SIZE(*ef->sb) != 0)
-			{
-				exfat_error("directory has invalid size %"PRIu64" bytes",
-						(*node)->size);
-				goto error;
-			}
-			--continuations;
-			break;
-
-		case EXFAT_ENTRY_FILE_NAME:
-			if (continuations == 0)
-			{
-				exfat_error("unexpected continuation");
-				goto error;
-			}
-			file_name = (const struct exfat_entry_name*) entry;
-			actual_checksum = exfat_add_checksum(entry, actual_checksum);
-
-			memcpy(namep, file_name->name,
-					MIN(EXFAT_ENAME_MAX,
-						((*node)->name + EXFAT_NAME_MAX - namep)) *
-					sizeof(le16_t));
-			namep += EXFAT_ENAME_MAX;
-			if (--continuations == 0)
-			{
-				if (!check_node(*node, actual_checksum, reference_checksum,
-						valid_size))
-					goto error;
-				if (!fetch_next_entry(ef, parent, it))
-					goto error;
-				return 0; /* entry completed */
-			}
-			break;
+			meta1 = (const struct exfat_entry_meta1*) &entry;
+			return parse_file_entry(ef, parent, node, offset,
+					1 + meta1->continuations);
 
 		case EXFAT_ENTRY_UPCASE:
 			if (ef->upcase != NULL)
 				break;
-			upcase = (const struct exfat_entry_upcase*) entry;
-			if (CLUSTER_INVALID(le32_to_cpu(upcase->start_cluster)))
+			upcase = (const struct exfat_entry_upcase*) &entry;
+			if (CLUSTER_INVALID(*ef->sb, le32_to_cpu(upcase->start_cluster)))
 			{
 				exfat_error("invalid cluster 0x%x in upcase table",
 						le32_to_cpu(upcase->start_cluster));
-				goto error;
+				return -EIO;
 			}
-			if (le64_to_cpu(upcase->size) == 0 ||
-				le64_to_cpu(upcase->size) > 0xffff * sizeof(uint16_t) ||
-				le64_to_cpu(upcase->size) % sizeof(uint16_t) != 0)
+			upcase_size = le64_to_cpu(upcase->size);
+			if (upcase_size == 0 ||
+				upcase_size > EXFAT_UPCASE_CHARS * sizeof(uint16_t) ||
+				upcase_size % sizeof(uint16_t) != 0)
 			{
 				exfat_error("bad upcase table size (%"PRIu64" bytes)",
-						le64_to_cpu(upcase->size));
-				goto error;
+						upcase_size);
+				return -EIO;
 			}
-			ef->upcase = malloc(le64_to_cpu(upcase->size));
-			if (ef->upcase == NULL)
+			upcase_comp = malloc(upcase_size);
+			if (upcase_comp == NULL)
 			{
 				exfat_error("failed to allocate upcase table (%"PRIu64" bytes)",
-						le64_to_cpu(upcase->size));
-				rc = -ENOMEM;
-				goto error;
+						upcase_size);
+				return -ENOMEM;
 			}
-			ef->upcase_chars = le64_to_cpu(upcase->size) / sizeof(le16_t);
 
-			if (exfat_pread(ef->dev, ef->upcase, le64_to_cpu(upcase->size),
+			/* read compressed upcase table */
+			if (exfat_pread(ef->dev, upcase_comp, upcase_size,
 					exfat_c2o(ef, le32_to_cpu(upcase->start_cluster))) < 0)
 			{
+				free(upcase_comp);
 				exfat_error("failed to read upper case table "
 						"(%"PRIu64" bytes starting at cluster %#x)",
-						le64_to_cpu(upcase->size),
+						upcase_size,
 						le32_to_cpu(upcase->start_cluster));
-				goto error;
+				return -EIO;
 			}
+
+			/* decompress upcase table */
+			ef->upcase = calloc(EXFAT_UPCASE_CHARS, sizeof(uint16_t));
+			if (ef->upcase == NULL)
+			{
+				free(upcase_comp);
+				exfat_error("failed to allocate decompressed upcase table");
+				return -ENOMEM;
+			}
+			decompress_upcase(ef->upcase, upcase_comp,
+					upcase_size / sizeof(uint16_t));
+			free(upcase_comp);
 			break;
 
 		case EXFAT_ENTRY_BITMAP:
-			bitmap = (const struct exfat_entry_bitmap*) entry;
+			bitmap = (const struct exfat_entry_bitmap*) &entry;
 			ef->cmap.start_cluster = le32_to_cpu(bitmap->start_cluster);
-			if (CLUSTER_INVALID(ef->cmap.start_cluster))
+			if (CLUSTER_INVALID(*ef->sb, ef->cmap.start_cluster))
 			{
 				exfat_error("invalid cluster 0x%x in clusters bitmap",
 						ef->cmap.start_cluster);
-				goto error;
+				return -EIO;
 			}
-			ef->cmap.size = le32_to_cpu(ef->sb->cluster_count) -
-				EXFAT_FIRST_DATA_CLUSTER;
+			ef->cmap.size = le32_to_cpu(ef->sb->cluster_count);
 			if (le64_to_cpu(bitmap->size) < DIV_ROUND_UP(ef->cmap.size, 8))
 			{
 				exfat_error("invalid clusters bitmap size: %"PRIu64
 						" (expected at least %u)",
 						le64_to_cpu(bitmap->size),
 						DIV_ROUND_UP(ef->cmap.size, 8));
-				goto error;
+				return -EIO;
 			}
 			/* FIXME bitmap can be rather big, up to 512 MB */
 			ef->cmap.chunk_size = ef->cmap.size;
@@ -426,8 +488,7 @@
 			{
 				exfat_error("failed to allocate clusters bitmap chunk "
 						"(%"PRIu64" bytes)", le64_to_cpu(bitmap->size));
-				rc = -ENOMEM;
-				goto error;
+				return -ENOMEM;
 			}
 
 			if (exfat_pread(ef->dev, ef->cmap.chunk,
@@ -437,66 +498,49 @@
 				exfat_error("failed to read clusters bitmap "
 						"(%"PRIu64" bytes starting at cluster %#x)",
 						le64_to_cpu(bitmap->size), ef->cmap.start_cluster);
-				goto error;
+				return -EIO;
 			}
 			break;
 
 		case EXFAT_ENTRY_LABEL:
-			label = (const struct exfat_entry_label*) entry;
+			label = (const struct exfat_entry_label*) &entry;
 			if (label->length > EXFAT_ENAME_MAX)
 			{
 				exfat_error("too long label (%hhu chars)", label->length);
-				goto error;
+				return -EIO;
 			}
-			if (utf16_to_utf8(ef->label, label->name,
-						sizeof(ef->label) - 1, EXFAT_ENAME_MAX) != 0)
-				goto error;
+			/* copy to a temporary buffer to avoid unaligned access to a
+			   packed member */
+			memcpy(label_name, label->name, sizeof(label_name));
+			if (exfat_utf16_to_utf8(ef->label, label_name,
+						sizeof(ef->label), EXFAT_ENAME_MAX) != 0)
+				return -EIO;
 			break;
 
 		default:
-			if (!(entry->type & EXFAT_ENTRY_VALID))
+			if (!(entry.type & EXFAT_ENTRY_VALID))
 				break; /* deleted entry, ignore it */
-			if (!(entry->type & EXFAT_ENTRY_OPTIONAL))
-			{
-				exfat_error("unknown entry type %#hhx", entry->type);
-				goto error;
-			}
-			/* optional entry, warn and skip */
-			exfat_warn("unknown entry type %#hhx", entry->type);
-			if (continuations == 0)
-			{
-				exfat_error("unexpected continuation");
-				goto error;
-			}
-			--continuations;
-			break;
-		}
 
-		if (!fetch_next_entry(ef, parent, it))
-			goto error;
+			exfat_error("unknown entry type %#hhx", entry.type);
+			if (!EXFAT_REPAIR(unknown_entry, ef, parent, &entry, *offset))
+				return -EIO;
+		}
+		*offset += sizeof(entry);
 	}
 	/* we never reach here */
-
-error:
-	free(*node);
-	*node = NULL;
-	return rc;
 }
 
 int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir)
 {
-	struct iterator it;
+	off_t offset = 0;
 	int rc;
 	struct exfat_node* node;
 	struct exfat_node* current = NULL;
 
-	if (dir->flags & EXFAT_ATTRIB_CACHED)
+	if (dir->is_cached)
 		return 0; /* already cached */
 
-	rc = opendir(ef, dir, &it);
-	if (rc != 0)
-		return rc;
-	while ((rc = readdir(ef, dir, &node, &it)) == 0)
+	while ((rc = readdir(ef, dir, &node, &offset)) == 0)
 	{
 		node->parent = dir;
 		if (current != NULL)
@@ -509,7 +553,6 @@
 
 		current = node;
 	}
-	closedir(&it);
 
 	if (rc != -ENOENT)
 	{
@@ -523,7 +566,7 @@
 		return rc;
 	}
 
-	dir->flags |= EXFAT_ATTRIB_CACHED;
+	dir->is_cached = true;
 	return 0;
 }
 
@@ -553,7 +596,7 @@
 
 static void reset_cache(struct exfat* ef, struct exfat_node* node)
 {
-	char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
+	char buffer[EXFAT_UTF8_NAME_BUFFER_MAX];
 
 	while (node->child)
 	{
@@ -562,16 +605,16 @@
 		tree_detach(p);
 		free(p);
 	}
-	node->flags &= ~EXFAT_ATTRIB_CACHED;
+	node->is_cached = false;
 	if (node->references != 0)
 	{
-		exfat_get_name(node, buffer, sizeof(buffer) - 1);
+		exfat_get_name(node, buffer);
 		exfat_warn("non-zero reference counter (%d) for '%s'",
 				node->references, buffer);
 	}
-	if (node != ef->root && (node->flags & EXFAT_ATTRIB_DIRTY))
+	if (node != ef->root && node->is_dirty)
 	{
-		exfat_get_name(node, buffer, sizeof(buffer) - 1);
+		exfat_get_name(node, buffer);
 		exfat_bug("node '%s' is dirty", buffer);
 	}
 	while (node->references)
@@ -583,32 +626,15 @@
 	reset_cache(ef, ef->root);
 }
 
-static bool next_entry(struct exfat* ef, const struct exfat_node* parent,
-		cluster_t* cluster, loff_t* offset)
-{
-	*offset += sizeof(struct exfat_entry);
-	if (*offset % CLUSTER_SIZE(*ef->sb) == 0)
-	{
-		*cluster = exfat_next_cluster(ef, parent, *cluster);
-		if (CLUSTER_INVALID(*cluster))
-		{
-			exfat_error("invalid cluster %#x while getting next entry",
-					*cluster);
-			return false;
-		}
-	}
-	return true;
-}
-
 int exfat_flush_node(struct exfat* ef, struct exfat_node* node)
 {
-	cluster_t cluster;
-	loff_t offset;
-	loff_t meta1_offset, meta2_offset;
-	struct exfat_entry_meta1 meta1;
-	struct exfat_entry_meta2 meta2;
+	struct exfat_entry entries[1 + node->continuations];
+	struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0];
+	struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1];
+	int rc;
+	le16_t edate, etime;
 
-	if (!(node->flags & EXFAT_ATTRIB_DIRTY))
+	if (!node->is_dirty)
 		return 0; /* no need to flush */
 
 	if (ef->ro)
@@ -617,105 +643,83 @@
 	if (node->parent == NULL)
 		return 0; /* do not flush unlinked node */
 
-	cluster = node->entry_cluster;
-	offset = node->entry_offset;
-	meta1_offset = co2o(ef, cluster, offset);
-	if (!next_entry(ef, node->parent, &cluster, &offset))
+	rc = read_entries(ef, node->parent, entries, 1 + node->continuations,
+			node->entry_offset);
+	if (rc != 0)
+		return rc;
+	if (!check_entries(entries, 1 + node->continuations))
 		return -EIO;
-	meta2_offset = co2o(ef, cluster, offset);
 
-	if (exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0)
-	{
-		exfat_error("failed to read meta1 entry on flush");
-		return -EIO;
-	}
-	if (meta1.type != EXFAT_ENTRY_FILE)
-		exfat_bug("invalid type of meta1: 0x%hhx", meta1.type);
-	meta1.attrib = cpu_to_le16(node->flags);
-	exfat_unix2exfat(node->mtime, &meta1.mdate, &meta1.mtime, &meta1.mtime_cs);
-	exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL);
-
-	if (exfat_pread(ef->dev, &meta2, sizeof(meta2), meta2_offset) < 0)
-	{
-		exfat_error("failed to read meta2 entry on flush");
-		return -EIO;
-	}
-	if (meta2.type != EXFAT_ENTRY_FILE_INFO)
-		exfat_bug("invalid type of meta2: 0x%hhx", meta2.type);
-	meta2.size = meta2.valid_size = cpu_to_le64(node->size);
-	meta2.start_cluster = cpu_to_le32(node->start_cluster);
-	meta2.flags = EXFAT_FLAG_ALWAYS1;
+	meta1->attrib = cpu_to_le16(node->attrib);
+	exfat_unix2exfat(node->mtime, &edate, &etime,
+			&meta1->mtime_cs, &meta1->mtime_tzo);
+	meta1->mdate = edate;
+	meta1->mtime = etime;
+	exfat_unix2exfat(node->atime, &edate, &etime,
+			NULL, &meta1->atime_tzo);
+	meta1->adate = edate;
+	meta1->atime = etime;
+	meta2->size = meta2->valid_size = cpu_to_le64(node->size);
+	meta2->start_cluster = cpu_to_le32(node->start_cluster);
+	meta2->flags = EXFAT_FLAG_ALWAYS1;
 	/* empty files must not be marked as contiguous */
-	if (node->size != 0 && IS_CONTIGUOUS(*node))
-		meta2.flags |= EXFAT_FLAG_CONTIGUOUS;
+	if (node->size != 0 && node->is_contiguous)
+		meta2->flags |= EXFAT_FLAG_CONTIGUOUS;
 	/* name hash remains unchanged, no need to recalculate it */
 
-	meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
+	meta1->checksum = exfat_calc_checksum(entries, 1 + node->continuations);
+	rc = write_entries(ef, node->parent, entries, 1 + node->continuations,
+			node->entry_offset);
+	if (rc != 0)
+		return rc;
 
-	if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0)
-	{
-		exfat_error("failed to write meta1 entry on flush");
-		return -EIO;
-	}
-	if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2), meta2_offset) < 0)
-	{
-		exfat_error("failed to write meta2 entry on flush");
-		return -EIO;
-	}
-
-	node->flags &= ~EXFAT_ATTRIB_DIRTY;
+	node->is_dirty = false;
 	return exfat_flush(ef);
 }
 
-static bool erase_entry(struct exfat* ef, struct exfat_node* node)
+static int erase_entries(struct exfat* ef, struct exfat_node* dir, int n,
+		off_t offset)
 {
-	cluster_t cluster = node->entry_cluster;
-	loff_t offset = node->entry_offset;
-	int name_entries = DIV_ROUND_UP(utf16_length(node->name), EXFAT_ENAME_MAX);
-	uint8_t entry_type;
+	struct exfat_entry entries[n];
+	int rc;
+	int i;
 
-	entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID;
-	if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0)
-	{
-		exfat_error("failed to erase meta1 entry");
-		return false;
-	}
+	rc = read_entries(ef, dir, entries, n, offset);
+	if (rc != 0)
+		return rc;
+	for (i = 0; i < n; i++)
+		entries[i].type &= ~EXFAT_ENTRY_VALID;
+	return write_entries(ef, dir, entries, n, offset);
+}
 
-	if (!next_entry(ef, node->parent, &cluster, &offset))
-		return false;
-	entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;
-	if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0)
-	{
-		exfat_error("failed to erase meta2 entry");
-		return false;
-	}
+static int erase_node(struct exfat* ef, struct exfat_node* node)
+{
+	int rc;
 
-	while (name_entries--)
+	exfat_get_node(node->parent);
+	rc = erase_entries(ef, node->parent, 1 + node->continuations,
+			node->entry_offset);
+	if (rc != 0)
 	{
-		if (!next_entry(ef, node->parent, &cluster, &offset))
-			return false;
-		entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID;
-		if (exfat_pwrite(ef->dev, &entry_type, 1,
-				co2o(ef, cluster, offset)) < 0)
-		{
-			exfat_error("failed to erase name entry");
-			return false;
-		}
+		exfat_put_node(ef, node->parent);
+		return rc;
 	}
-	return true;
+	rc = exfat_flush_node(ef, node->parent);
+	exfat_put_node(ef, node->parent);
+	return rc;
 }
 
 static int shrink_directory(struct exfat* ef, struct exfat_node* dir,
-		loff_t deleted_offset)
+		off_t deleted_offset)
 {
 	const struct exfat_node* node;
 	const struct exfat_node* last_node;
 	uint64_t entries = 0;
 	uint64_t new_size;
 
-	if (!(dir->flags & EXFAT_ATTRIB_DIR))
+	if (!(dir->attrib & EXFAT_ATTRIB_DIR))
 		exfat_bug("attempted to shrink a file");
-	if (!(dir->flags & EXFAT_ATTRIB_CACHED))
+	if (!dir->is_cached)
 		exfat_bug("attempted to shrink uncached directory");
 
 	for (last_node = node = dir->child; node; node = node->next)
@@ -737,7 +741,7 @@
 		/* two subentries with meta info */
 		entries += 2;
 		/* subentries with file name */
-		entries += DIV_ROUND_UP(utf16_length(last_node->name),
+		entries += DIV_ROUND_UP(exfat_utf16_length(last_node->name),
 				EXFAT_ENAME_MAX);
 	}
 
@@ -753,25 +757,26 @@
 static int delete(struct exfat* ef, struct exfat_node* node)
 {
 	struct exfat_node* parent = node->parent;
-	loff_t deleted_offset = node->entry_offset;
+	off_t deleted_offset = node->entry_offset;
 	int rc;
 
 	exfat_get_node(parent);
-	if (!erase_entry(ef, node))
+	rc = erase_node(ef, node);
+	if (rc != 0)
 	{
 		exfat_put_node(ef, parent);
-		return -EIO;
+		return rc;
 	}
-	exfat_update_mtime(parent);
 	tree_detach(node);
 	rc = shrink_directory(ef, parent, deleted_offset);
-	node->flags |= EXFAT_ATTRIB_UNLINKED;
+	node->is_unlinked = true;
 	if (rc != 0)
 	{
 		exfat_flush_node(ef, parent);
 		exfat_put_node(ef, parent);
 		return rc;
 	}
+	exfat_update_mtime(parent);
 	rc = exfat_flush_node(ef, parent);
 	exfat_put_node(ef, parent);
 	return rc;
@@ -779,7 +784,7 @@
 
 int exfat_unlink(struct exfat* ef, struct exfat_node* node)
 {
-	if (node->flags & EXFAT_ATTRIB_DIR)
+	if (node->attrib & EXFAT_ATTRIB_DIR)
 		return -EISDIR;
 	return delete(ef, node);
 }
@@ -788,7 +793,7 @@
 {
 	int rc;
 
-	if (!(node->flags & EXFAT_ATTRIB_DIR))
+	if (!(node->attrib & EXFAT_ATTRIB_DIR))
 		return -ENOTDIR;
 	/* check that directory is empty */
 	rc = exfat_cache_directory(ef, node);
@@ -799,130 +804,149 @@
 	return delete(ef, node);
 }
 
-static int grow_directory(struct exfat* ef, struct exfat_node* dir,
-		uint64_t asize, uint32_t difference)
+static int check_slot(struct exfat* ef, struct exfat_node* dir, off_t offset,
+		int n)
 {
-	return exfat_truncate(ef, dir,
-			DIV_ROUND_UP(asize + difference, CLUSTER_SIZE(*ef->sb))
-				* CLUSTER_SIZE(*ef->sb), true);
-}
-
-static int find_slot(struct exfat* ef, struct exfat_node* dir,
-		cluster_t* cluster, loff_t* offset, int subentries)
-{
-	struct iterator it;
+	struct exfat_entry entries[n];
 	int rc;
-	const struct exfat_entry* entry;
-	int contiguous = 0;
+	int i;
 
-	rc = opendir(ef, dir, &it);
+	/* Root directory contains entries, that don't have any nodes associated
+	   with them (clusters bitmap, upper case table, label). We need to be
+	   careful not to overwrite them. */
+	if (dir != ef->root)
+		return 0;
+
+	rc = read_entries(ef, dir, entries, n, offset);
 	if (rc != 0)
 		return rc;
-	for (;;)
-	{
-		if (contiguous == 0)
-		{
-			*cluster = it.cluster;
-			*offset = it.offset;
-		}
-		entry = get_entry_ptr(ef, &it);
-		if (entry->type & EXFAT_ENTRY_VALID)
-			contiguous = 0;
-		else
-			contiguous++;
-		if (contiguous == subentries)
-			break;	/* suitable slot is found */
-		if (it.offset + sizeof(struct exfat_entry) >= dir->size)
-		{
-			rc = grow_directory(ef, dir, dir->size,
-					(subentries - contiguous) * sizeof(struct exfat_entry));
-			if (rc != 0)
-			{
-				closedir(&it);
-				return rc;
-			}
-		}
-		if (!fetch_next_entry(ef, dir, &it))
-		{
-			closedir(&it);
-			return -EIO;
-		}
-	}
-	closedir(&it);
+	for (i = 0; i < n; i++)
+		if (entries[i].type & EXFAT_ENTRY_VALID)
+			return -EINVAL;
 	return 0;
 }
 
-static int write_entry(struct exfat* ef, struct exfat_node* dir,
-		const le16_t* name, cluster_t cluster, loff_t offset, uint16_t attrib)
+static int find_slot(struct exfat* ef, struct exfat_node* dir,
+		off_t* offset, int n)
+{
+	bitmap_t* dmap;
+	struct exfat_node* p;
+	size_t i;
+	int contiguous = 0;
+
+	if (!dir->is_cached)
+		exfat_bug("directory is not cached");
+
+	/* build a bitmap of valid entries in the directory */
+	dmap = calloc(BMAP_SIZE(dir->size / sizeof(struct exfat_entry)),
+			sizeof(bitmap_t));
+	if (dmap == NULL)
+	{
+		exfat_error("failed to allocate directory bitmap (%"PRIu64")",
+				dir->size / sizeof(struct exfat_entry));
+		return -ENOMEM;
+	}
+	for (p = dir->child; p != NULL; p = p->next)
+		for (i = 0; i < 1u + p->continuations; i++)
+			BMAP_SET(dmap, p->entry_offset / sizeof(struct exfat_entry) + i);
+
+	/* find a slot in the directory entries bitmap */
+	for (i = 0; i < dir->size / sizeof(struct exfat_entry); i++)
+	{
+		if (BMAP_GET(dmap, i) == 0)
+		{
+			if (contiguous++ == 0)
+				*offset = (off_t) i * sizeof(struct exfat_entry);
+			if (contiguous == n)
+			{
+				int rc;
+
+				/* suitable slot is found, check that it's not occupied */
+				rc = check_slot(ef, dir, *offset, n);
+				if (rc == -EINVAL)
+				{
+					/* slot at (i-n) is occupied, go back and check (i-n+1) */
+					i -= contiguous - 1;
+					contiguous = 0;
+				}
+				else
+				{
+					/* slot is free or an error occurred */
+					free(dmap);
+					return rc;
+				}
+			}
+		}
+		else
+			contiguous = 0;
+	}
+	free(dmap);
+
+	/* no suitable slots found, extend the directory */
+	if (contiguous == 0)
+		*offset = dir->size;
+	return exfat_truncate(ef, dir,
+			ROUND_UP(dir->size + sizeof(struct exfat_entry[n - contiguous]),
+					CLUSTER_SIZE(*ef->sb)),
+			true);
+}
+
+static int commit_entry(struct exfat* ef, struct exfat_node* dir,
+		const le16_t* name, off_t offset, uint16_t attrib)
 {
 	struct exfat_node* node;
-	struct exfat_entry_meta1 meta1;
-	struct exfat_entry_meta2 meta2;
-	const size_t name_length = utf16_length(name);
+	const size_t name_length = exfat_utf16_length(name);
 	const int name_entries = DIV_ROUND_UP(name_length, EXFAT_ENAME_MAX);
+	struct exfat_entry entries[2 + name_entries];
+	struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0];
+	struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1];
 	int i;
+	int rc;
+	le16_t edate, etime;
+
+	memset(entries, 0, sizeof(struct exfat_entry[2]));
+
+	meta1->type = EXFAT_ENTRY_FILE;
+	meta1->continuations = 1 + name_entries;
+	meta1->attrib = cpu_to_le16(attrib);
+	exfat_unix2exfat(time(NULL), &edate, &etime,
+			&meta1->crtime_cs, &meta1->crtime_tzo);
+	meta1->adate = meta1->mdate = meta1->crdate = edate;
+	meta1->atime = meta1->mtime = meta1->crtime = etime;
+	meta1->mtime_cs = meta1->crtime_cs; /* there is no atime_cs */
+	meta1->atime_tzo = meta1->mtime_tzo = meta1->crtime_tzo;
+
+	meta2->type = EXFAT_ENTRY_FILE_INFO;
+	meta2->flags = EXFAT_FLAG_ALWAYS1;
+	meta2->name_length = name_length;
+	meta2->name_hash = exfat_calc_name_hash(ef, name, name_length);
+	meta2->start_cluster = cpu_to_le32(EXFAT_CLUSTER_FREE);
+
+	for (i = 0; i < name_entries; i++)
+	{
+		struct exfat_entry_name* name_entry;
+
+		name_entry = (struct exfat_entry_name*) &entries[2 + i];
+		name_entry->type = EXFAT_ENTRY_FILE_NAME;
+		name_entry->__unknown = 0;
+		memcpy(name_entry->name, name + i * EXFAT_ENAME_MAX,
+				EXFAT_ENAME_MAX * sizeof(le16_t));
+	}
+
+	meta1->checksum = exfat_calc_checksum(entries, 2 + name_entries);
+	rc = write_entries(ef, dir, entries, 2 + name_entries, offset);
+	if (rc != 0)
+		return rc;
 
 	node = allocate_node();
 	if (node == NULL)
 		return -ENOMEM;
-	node->entry_cluster = cluster;
 	node->entry_offset = offset;
 	memcpy(node->name, name, name_length * sizeof(le16_t));
-
-	memset(&meta1, 0, sizeof(meta1));
-	meta1.type = EXFAT_ENTRY_FILE;
-	meta1.continuations = 1 + name_entries;
-	meta1.attrib = cpu_to_le16(attrib);
-	exfat_unix2exfat(time(NULL), &meta1.crdate, &meta1.crtime,
-			&meta1.crtime_cs);
-	meta1.adate = meta1.mdate = meta1.crdate;
-	meta1.atime = meta1.mtime = meta1.crtime;
-	meta1.mtime_cs = meta1.crtime_cs; /* there is no atime_cs */
-
-	memset(&meta2, 0, sizeof(meta2));
-	meta2.type = EXFAT_ENTRY_FILE_INFO;
-	meta2.flags = EXFAT_FLAG_ALWAYS1;
-	meta2.name_length = name_length;
-	meta2.name_hash = exfat_calc_name_hash(ef, node->name);
-	meta2.start_cluster = cpu_to_le32(EXFAT_CLUSTER_FREE);
-
-	meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
-
-	if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1),
-			co2o(ef, cluster, offset)) < 0)
-	{
-		exfat_error("failed to write meta1 entry");
-		return -EIO;
-	}
-	if (!next_entry(ef, dir, &cluster, &offset))
-		return -EIO;
-	if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2),
-			co2o(ef, cluster, offset)) < 0)
-	{
-		exfat_error("failed to write meta2 entry");
-		return -EIO;
-	}
-	for (i = 0; i < name_entries; i++)
-	{
-		struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0};
-		memcpy(name_entry.name, node->name + i * EXFAT_ENAME_MAX,
-				MIN(EXFAT_ENAME_MAX, EXFAT_NAME_MAX - i * EXFAT_ENAME_MAX) *
-				sizeof(le16_t));
-		if (!next_entry(ef, dir, &cluster, &offset))
-			return -EIO;
-		if (exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
-				co2o(ef, cluster, offset)) < 0)
-		{
-			exfat_error("failed to write name entry");
-			return -EIO;
-		}
-	}
-
-	init_node_meta1(node, &meta1);
-	init_node_meta2(node, &meta2);
+	init_node_meta1(node, meta1);
+	init_node_meta2(node, meta2);
 
 	tree_attach(dir, node);
-	exfat_update_mtime(dir);
 	return 0;
 }
 
@@ -930,8 +954,7 @@
 {
 	struct exfat_node* dir;
 	struct exfat_node* existing;
-	cluster_t cluster = EXFAT_CLUSTER_BAD;
-	loff_t offset = -1;
+	off_t offset = -1;
 	le16_t name[EXFAT_NAME_MAX + 1];
 	int rc;
 
@@ -945,19 +968,20 @@
 		return -EEXIST;
 	}
 
-	rc = find_slot(ef, dir, &cluster, &offset,
-			2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX));
+	rc = find_slot(ef, dir, &offset,
+			2 + DIV_ROUND_UP(exfat_utf16_length(name), EXFAT_ENAME_MAX));
 	if (rc != 0)
 	{
 		exfat_put_node(ef, dir);
 		return rc;
 	}
-	rc = write_entry(ef, dir, name, cluster, offset, attrib);
+	rc = commit_entry(ef, dir, name, offset, attrib);
 	if (rc != 0)
 	{
 		exfat_put_node(ef, dir);
 		return rc;
 	}
+	exfat_update_mtime(dir);
 	rc = exfat_flush_node(ef, dir);
 	exfat_put_node(ef, dir);
 	return rc;
@@ -999,72 +1023,47 @@
 }
 
 static int rename_entry(struct exfat* ef, struct exfat_node* dir,
-		struct exfat_node* node, const le16_t* name, cluster_t new_cluster,
-		loff_t new_offset)
+		struct exfat_node* node, const le16_t* name, off_t new_offset)
 {
-	struct exfat_entry_meta1 meta1;
-	struct exfat_entry_meta2 meta2;
-	cluster_t old_cluster = node->entry_cluster;
-	loff_t old_offset = node->entry_offset;
-	const size_t name_length = utf16_length(name);
+	const size_t name_length = exfat_utf16_length(name);
 	const int name_entries = DIV_ROUND_UP(name_length, EXFAT_ENAME_MAX);
+	struct exfat_entry entries[2 + name_entries];
+	struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0];
+	struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1];
+	int rc;
 	int i;
 
-	if (exfat_pread(ef->dev, &meta1, sizeof(meta1),
-			co2o(ef, old_cluster, old_offset)) < 0)
-	{
-		exfat_error("failed to read meta1 entry on rename");
-		return -EIO;
-	}
-	if (!next_entry(ef, node->parent, &old_cluster, &old_offset))
-		return -EIO;
-	if (exfat_pread(ef->dev, &meta2, sizeof(meta2),
-			co2o(ef, old_cluster, old_offset)) < 0)
-	{
-		exfat_error("failed to read meta2 entry on rename");
-		return -EIO;
-	}
-	meta1.continuations = 1 + name_entries;
-	meta2.name_hash = exfat_calc_name_hash(ef, name);
-	meta2.name_length = name_length;
-	meta1.checksum = exfat_calc_checksum(&meta1, &meta2, name);
+	rc = read_entries(ef, node->parent, entries, 2, node->entry_offset);
+	if (rc != 0)
+		return rc;
 
-	if (!erase_entry(ef, node))
-		return -EIO;
+	meta1->continuations = 1 + name_entries;
+	meta2->name_length = name_length;
+	meta2->name_hash = exfat_calc_name_hash(ef, name, name_length);
 
-	node->entry_cluster = new_cluster;
+	rc = erase_node(ef, node);
+	if (rc != 0)
+		return rc;
+
 	node->entry_offset = new_offset;
-
-	if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1),
-			co2o(ef, new_cluster, new_offset)) < 0)
-	{
-		exfat_error("failed to write meta1 entry on rename");
-		return -EIO;
-	}
-	if (!next_entry(ef, dir, &new_cluster, &new_offset))
-		return -EIO;
-	if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2),
-			co2o(ef, new_cluster, new_offset)) < 0)
-	{
-		exfat_error("failed to write meta2 entry on rename");
-		return -EIO;
-	}
+	node->continuations = 1 + name_entries;
 
 	for (i = 0; i < name_entries; i++)
 	{
-		struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0};
-		memcpy(name_entry.name, name + i * EXFAT_ENAME_MAX,
+		struct exfat_entry_name* name_entry;
+
+		name_entry = (struct exfat_entry_name*) &entries[2 + i];
+		name_entry->type = EXFAT_ENTRY_FILE_NAME;
+		name_entry->__unknown = 0;
+		memcpy(name_entry->name, name + i * EXFAT_ENAME_MAX,
 				EXFAT_ENAME_MAX * sizeof(le16_t));
-		if (!next_entry(ef, dir, &new_cluster, &new_offset))
-			return -EIO;
-		if (exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
-				co2o(ef, new_cluster, new_offset)) < 0)
-		{
-			exfat_error("failed to write name entry on rename");
-			return -EIO;
-		}
 	}
 
+	meta1->checksum = exfat_calc_checksum(entries, 2 + name_entries);
+	rc = write_entries(ef, dir, entries, 2 + name_entries, new_offset);
+	if (rc != 0)
+		return rc;
+
 	memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t));
 	tree_detach(node);
 	tree_attach(dir, node);
@@ -1076,8 +1075,7 @@
 	struct exfat_node* node;
 	struct exfat_node* existing;
 	struct exfat_node* dir;
-	cluster_t cluster = EXFAT_CLUSTER_BAD;
-	loff_t offset = -1;
+	off_t offset = -1;
 	le16_t name[EXFAT_NAME_MAX + 1];
 	int rc;
 
@@ -1093,7 +1091,7 @@
 	}
 
 	/* check that target is not a subdirectory of the source */
-	if (node->flags & EXFAT_ATTRIB_DIR)
+	if (node->attrib & EXFAT_ATTRIB_DIR)
 	{
 		struct exfat_node* p;
 
@@ -1113,16 +1111,16 @@
 		/* remove target if it's not the same node as source */
 		if (existing != node)
 		{
-			if (existing->flags & EXFAT_ATTRIB_DIR)
+			if (existing->attrib & EXFAT_ATTRIB_DIR)
 			{
-				if (node->flags & EXFAT_ATTRIB_DIR)
+				if (node->attrib & EXFAT_ATTRIB_DIR)
 					rc = exfat_rmdir(ef, existing);
 				else
 					rc = -ENOTDIR;
 			}
 			else
 			{
-				if (!(node->flags & EXFAT_ATTRIB_DIR))
+				if (!(node->attrib & EXFAT_ATTRIB_DIR))
 					rc = exfat_unlink(ef, existing);
 				else
 					rc = -EISDIR;
@@ -1130,6 +1128,16 @@
 			exfat_put_node(ef, existing);
 			if (rc != 0)
 			{
+				/* free clusters even if something went wrong; overwise they
+				   will be just lost */
+				exfat_cleanup_node(ef, existing);
+				exfat_put_node(ef, dir);
+				exfat_put_node(ef, node);
+				return rc;
+			}
+			rc = exfat_cleanup_node(ef, existing);
+			if (rc != 0)
+			{
 				exfat_put_node(ef, dir);
 				exfat_put_node(ef, node);
 				return rc;
@@ -1139,17 +1147,25 @@
 			exfat_put_node(ef, existing);
 	}
 
-	rc = find_slot(ef, dir, &cluster, &offset,
-			2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX));
+	rc = find_slot(ef, dir, &offset,
+			2 + DIV_ROUND_UP(exfat_utf16_length(name), EXFAT_ENAME_MAX));
 	if (rc != 0)
 	{
 		exfat_put_node(ef, dir);
 		exfat_put_node(ef, node);
 		return rc;
 	}
-	rc = rename_entry(ef, dir, node, name, cluster, offset);
+	rc = rename_entry(ef, dir, node, name, offset);
+	if (rc != 0)
+	{
+		exfat_put_node(ef, dir);
+		exfat_put_node(ef, node);
+		return rc;
+	}
+	rc = exfat_flush_node(ef, dir);
 	exfat_put_node(ef, dir);
 	exfat_put_node(ef, node);
+	/* node itself is not marked as dirty, no need to flush it */
 	return rc;
 }
 
@@ -1157,19 +1173,19 @@
 {
 	node->atime = tv[0].tv_sec;
 	node->mtime = tv[1].tv_sec;
-	node->flags |= EXFAT_ATTRIB_DIRTY;
+	node->is_dirty = true;
 }
 
 void exfat_update_atime(struct exfat_node* node)
 {
 	node->atime = time(NULL);
-	node->flags |= EXFAT_ATTRIB_DIRTY;
+	node->is_dirty = true;
 }
 
 void exfat_update_mtime(struct exfat_node* node)
 {
 	node->mtime = time(NULL);
-	node->flags |= EXFAT_ATTRIB_DIRTY;
+	node->is_dirty = true;
 }
 
 const char* exfat_get_label(struct exfat* ef)
@@ -1177,36 +1193,19 @@
 	return ef->label;
 }
 
-static int find_label(struct exfat* ef, cluster_t* cluster, loff_t* offset)
+static int find_label(struct exfat* ef, off_t* offset)
 {
-	struct iterator it;
+	struct exfat_entry entry;
 	int rc;
 
-	rc = opendir(ef, ef->root, &it);
-	if (rc != 0)
-		return rc;
-
-	for (;;)
+	for (*offset = 0; ; *offset += sizeof(entry))
 	{
-		if (it.offset >= ef->root->size)
-		{
-			closedir(&it);
-			return -ENOENT;
-		}
+		rc = read_entries(ef, ef->root, &entry, 1, *offset);
+		if (rc != 0)
+			return rc;
 
-		if (get_entry_ptr(ef, &it)->type == EXFAT_ENTRY_LABEL)
-		{
-			*cluster = it.cluster;
-			*offset = it.offset;
-			closedir(&it);
+		if (entry.type == EXFAT_ENTRY_LABEL)
 			return 0;
-		}
-
-		if (!fetch_next_entry(ef, ef->root, &it))
-		{
-			closedir(&it);
-			return -EIO;
-		}
 	}
 }
 
@@ -1214,33 +1213,31 @@
 {
 	le16_t label_utf16[EXFAT_ENAME_MAX + 1];
 	int rc;
-	cluster_t cluster;
-	loff_t offset;
+	off_t offset;
 	struct exfat_entry_label entry;
 
 	memset(label_utf16, 0, sizeof(label_utf16));
-	rc = utf8_to_utf16(label_utf16, label, EXFAT_ENAME_MAX, strlen(label));
+	rc = exfat_utf8_to_utf16(label_utf16, label, EXFAT_ENAME_MAX + 1,
+			strlen(label));
 	if (rc != 0)
 		return rc;
 
-	rc = find_label(ef, &cluster, &offset);
+	rc = find_label(ef, &offset);
 	if (rc == -ENOENT)
-		rc = find_slot(ef, ef->root, &cluster, &offset, 1);
+		rc = find_slot(ef, ef->root, &offset, 1);
 	if (rc != 0)
 		return rc;
 
 	entry.type = EXFAT_ENTRY_LABEL;
-	entry.length = utf16_length(label_utf16);
+	entry.length = exfat_utf16_length(label_utf16);
 	memcpy(entry.name, label_utf16, sizeof(entry.name));
 	if (entry.length == 0)
 		entry.type ^= EXFAT_ENTRY_VALID;
 
-	if (exfat_pwrite(ef->dev, &entry, sizeof(struct exfat_entry_label),
-			co2o(ef, cluster, offset)) < 0)
-	{
-		exfat_error("failed to write label entry");
-		return -EIO;
-	}
+	rc = write_entries(ef, ef->root, (struct exfat_entry*) &entry, 1, offset);
+	if (rc != 0)
+		return rc;
+
 	strcpy(ef->label, label);
 	return 0;
 }
diff --git a/exfat/libexfat/platform.h b/exfat/libexfat/platform.h
index d2ad6d1..d42e1ee 100644
--- a/exfat/libexfat/platform.h
+++ b/exfat/libexfat/platform.h
@@ -4,7 +4,7 @@
 	same kernel can use different libc implementations.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -46,7 +46,7 @@
 #define EXFAT_LITTLE_ENDIAN LITTLE_ENDIAN
 #define EXFAT_BIG_ENDIAN BIG_ENDIAN
 
-#elif defined(__ANDROID__) || defined(__FreeBSD__) || defined(__DragonFlyBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__)
 
 #include <sys/endian.h>
 #define exfat_bswap16(x) bswap16(x)
@@ -56,6 +56,16 @@
 #define EXFAT_LITTLE_ENDIAN _LITTLE_ENDIAN
 #define EXFAT_BIG_ENDIAN _BIG_ENDIAN
 
+#elif defined(__sun)
+
+#include <endian.h>
+#define exfat_bswap16(x) bswap_16(x)
+#define exfat_bswap32(x) bswap_32(x)
+#define exfat_bswap64(x) bswap_64(x)
+#define EXFAT_BYTE_ORDER __BYTE_ORDER
+#define EXFAT_LITTLE_ENDIAN __LITTLE_ENDIAN
+#define EXFAT_BIG_ENDIAN __BIG_ENDIAN
+
 #else 
 #error Unknown platform
 #endif
diff --git a/exfat/libexfat/repair.c b/exfat/libexfat/repair.c
new file mode 100644
index 0000000..8e8e962
--- /dev/null
+++ b/exfat/libexfat/repair.c
@@ -0,0 +1,102 @@
+/*
+	repair.c (09.03.17)
+	exFAT file system implementation library.
+
+	Free exFAT implementation.
+	Copyright (C) 2010-2018  Andrew Nayenko
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License along
+	with this program; if not, write to the Free Software Foundation, Inc.,
+	51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "exfat.h"
+#include <strings.h>
+
+int exfat_errors_fixed;
+
+bool exfat_ask_to_fix(const struct exfat* ef)
+{
+	const char* question = "Fix (Y/N)?";
+	char answer[8];
+	bool yeah, nope;
+
+	switch (ef->repair)
+	{
+	case EXFAT_REPAIR_NO:
+		return false;
+	case EXFAT_REPAIR_YES:
+		printf("%s %s", question, "Y\n");
+		return true;
+	case EXFAT_REPAIR_ASK:
+		do
+		{
+			printf("%s ", question);
+			fflush(stdout);
+			if (fgets(answer, sizeof(answer), stdin))
+			{
+				yeah = strcasecmp(answer, "Y\n") == 0;
+				nope = strcasecmp(answer, "N\n") == 0;
+			}
+			else
+			{
+				yeah = false;
+				nope = true;
+			}
+		}
+		while (!yeah && !nope);
+		return yeah;
+	}
+	exfat_bug("invalid repair option value: %d", ef->repair);
+}
+
+bool exfat_fix_invalid_vbr_checksum(const struct exfat* ef, void* sector,
+		uint32_t vbr_checksum)
+{
+	size_t i;
+	off_t sector_size = SECTOR_SIZE(*ef->sb);
+
+	for (i = 0; i < sector_size / sizeof(vbr_checksum); i++)
+		((le32_t*) sector)[i] = cpu_to_le32(vbr_checksum);
+	if (exfat_pwrite(ef->dev, sector, sector_size, 11 * sector_size) < 0)
+	{
+		exfat_error("failed to write correct VBR checksum");
+		return false;
+	}
+	exfat_errors_fixed++;
+	return true;
+}
+
+bool exfat_fix_invalid_node_checksum(UNUSED const struct exfat* ef,
+		struct exfat_node* node)
+{
+	/* checksum will be rewritten by exfat_flush_node() */
+	node->is_dirty = true;
+
+	exfat_errors_fixed++;
+	return true;
+}
+
+bool exfat_fix_unknown_entry(struct exfat* ef, struct exfat_node* dir,
+		const struct exfat_entry* entry, off_t offset)
+{
+	struct exfat_entry deleted = *entry;
+
+	deleted.type &= ~EXFAT_ENTRY_VALID;
+	if (exfat_generic_pwrite(ef, dir, &deleted, sizeof(struct exfat_entry),
+			offset) != sizeof(struct exfat_entry))
+		return false;
+
+	exfat_errors_fixed++;
+	return true;
+}
diff --git a/exfat/libexfat/time.c b/exfat/libexfat/time.c
index 45c4aff..e2a3b23 100644
--- a/exfat/libexfat/time.c
+++ b/exfat/libexfat/time.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -53,7 +53,8 @@
 	0,   0,  31,  59,  90, 120, 151, 181, 212, 243, 273, 304, 334
 };
 
-time_t exfat_exfat2unix(le16_t date, le16_t time, uint8_t centisec)
+time_t exfat_exfat2unix(le16_t date, le16_t time, uint8_t centisec,
+		uint8_t tzoffset)
 {
 	time_t unix_time = EPOCH_DIFF_SEC;
 	uint16_t ndate = le16_to_cpu(date);
@@ -100,13 +101,18 @@
 	unix_time += centisec / 100;
 
 	/* exFAT stores timestamps in local time, so we correct it to UTC */
-	unix_time += exfat_timezone;
+	if (tzoffset & 0x80)
+		/* lower 7 bits are signed timezone offset in 15 minute increments */
+		unix_time -= (int8_t)(tzoffset << 1) * 15 * 60 / 2;
+	else
+		/* timezone offset not present, assume our local timezone */
+		unix_time += exfat_timezone;
 
 	return unix_time;
 }
 
 void exfat_unix2exfat(time_t unix_time, le16_t* date, le16_t* time,
-		uint8_t* centisec)
+		uint8_t* centisec, uint8_t* tzoffset)
 {
 	time_t shift = EPOCH_DIFF_SEC + exfat_timezone;
 	uint16_t day, month, year;
@@ -146,13 +152,22 @@
 	*time = cpu_to_le16(twosec | (min << 5) | (hour << 11));
 	if (centisec)
 		*centisec = (unix_time % 2) * 100;
+
+	/* record our local timezone offset in exFAT (15 minute increment) format */
+	*tzoffset = (uint8_t)(-exfat_timezone / 60 / 15) | 0x80;
 }
 
 void exfat_tzset(void)
 {
 	time_t now;
+	struct tm* utc;
 
 	tzset();
 	now = time(NULL);
-	exfat_timezone = mktime(gmtime(&now)) - now;
+	utc = gmtime(&now);
+	/* gmtime() always sets tm_isdst to 0 because daylight savings never
+	   affect UTC. Setting tm_isdst to -1 makes mktime() to determine whether
+	   summer time is in effect. */
+	utc->tm_isdst = -1;
+	exfat_timezone = mktime(utc) - now;
 }
diff --git a/exfat/libexfat/utf.c b/exfat/libexfat/utf.c
index 6f14882..96f4608 100644
--- a/exfat/libexfat/utf.c
+++ b/exfat/libexfat/utf.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -101,81 +101,95 @@
 	}
 }
 
-int utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
+int exfat_utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
 		size_t insize)
 {
-	const le16_t* inp = input;
-	char* outp = output;
+	const le16_t* iptr = input;
+	const le16_t* iend = input + insize;
+	char* optr = output;
+	const char* oend = output + outsize;
 	wchar_t wc;
 
-	while (inp - input < insize && le16_to_cpu(*inp))
+	while (iptr < iend)
 	{
-		inp = utf16_to_wchar(inp, &wc, insize - (inp - input));
-		if (inp == NULL)
+		iptr = utf16_to_wchar(iptr, &wc, iend - iptr);
+		if (iptr == NULL)
 		{
 			exfat_error("illegal UTF-16 sequence");
 			return -EILSEQ;
 		}
-		outp = wchar_to_utf8(outp, wc, outsize - (outp - output));
-		if (outp == NULL)
+		optr = wchar_to_utf8(optr, wc, oend - optr);
+		if (optr == NULL)
 		{
 			exfat_error("name is too long");
 			return -ENAMETOOLONG;
 		}
+		if (wc == 0)
+			return 0;
 	}
-	*outp = '\0';
+	if (optr >= oend)
+	{
+		exfat_error("name is too long");
+		return -ENAMETOOLONG;
+	}
+	*optr = '\0';
 	return 0;
 }
 
 static const char* utf8_to_wchar(const char* input, wchar_t* wc,
 		size_t insize)
 {
-	if ((input[0] & 0x80) == 0 && insize >= 1)
+	size_t size;
+	size_t i;
+
+	if (insize == 0)
+		exfat_bug("no input for utf8_to_wchar");
+
+	if ((input[0] & 0x80) == 0)
 	{
 		*wc = (wchar_t) input[0];
 		return input + 1;
 	}
-	if ((input[0] & 0xe0) == 0xc0 && insize >= 2)
+	else if ((input[0] & 0xe0) == 0xc0)
 	{
-		*wc = (((wchar_t) input[0] & 0x1f) << 6) |
-		       ((wchar_t) input[1] & 0x3f);
-		return input + 2;
+		*wc = ((wchar_t) input[0] & 0x1f) << 6;
+		size = 2;
 	}
-	if ((input[0] & 0xf0) == 0xe0 && insize >= 3)
+	else if ((input[0] & 0xf0) == 0xe0)
 	{
-		*wc = (((wchar_t) input[0] & 0x0f) << 12) |
-		      (((wchar_t) input[1] & 0x3f) << 6) |
-		       ((wchar_t) input[2] & 0x3f);
-		return input + 3;
+		*wc = ((wchar_t) input[0] & 0x0f) << 12;
+		size = 3;
 	}
-	if ((input[0] & 0xf8) == 0xf0 && insize >= 4)
+	else if ((input[0] & 0xf8) == 0xf0)
 	{
-		*wc = (((wchar_t) input[0] & 0x07) << 18) |
-		      (((wchar_t) input[1] & 0x3f) << 12) |
-		      (((wchar_t) input[2] & 0x3f) << 6) |
-		       ((wchar_t) input[3] & 0x3f);
-		return input + 4;
+		*wc = ((wchar_t) input[0] & 0x07) << 18;
+		size = 4;
 	}
-	if ((input[0] & 0xfc) == 0xf8 && insize >= 5)
+	else if ((input[0] & 0xfc) == 0xf8)
 	{
-		*wc = (((wchar_t) input[0] & 0x03) << 24) |
-		      (((wchar_t) input[1] & 0x3f) << 18) |
-		      (((wchar_t) input[2] & 0x3f) << 12) |
-		      (((wchar_t) input[3] & 0x3f) << 6) |
-		       ((wchar_t) input[4] & 0x3f);
-		return input + 5;
+		*wc = ((wchar_t) input[0] & 0x03) << 24;
+		size = 5;
 	}
-	if ((input[0] & 0xfe) == 0xfc && insize >= 6)
+	else if ((input[0] & 0xfe) == 0xfc)
 	{
-		*wc = (((wchar_t) input[0] & 0x01) << 30) |
-		      (((wchar_t) input[1] & 0x3f) << 24) |
-		      (((wchar_t) input[2] & 0x3f) << 18) |
-		      (((wchar_t) input[3] & 0x3f) << 12) |
-		      (((wchar_t) input[4] & 0x3f) << 6) |
-		       ((wchar_t) input[5] & 0x3f);
-		return input + 6;
+		*wc = ((wchar_t) input[0] & 0x01) << 30;
+		size = 6;
 	}
-	return NULL;
+	else
+		return NULL;
+
+	if (insize < size)
+		return NULL;
+
+	/* the first byte is handled above */
+	for (i = 1; i < size; i++)
+	{
+		if ((input[i] & 0xc0) != 0x80)
+			return NULL;
+		*wc |= (input[i] & 0x3f) << ((size - i - 1) * 6);
+	}
+
+	return input + size;
 }
 
 static le16_t* wchar_to_utf16(le16_t* output, wchar_t wc, size_t outsize)
@@ -195,33 +209,42 @@
 	return output + 2;
 }
 
-int utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
+int exfat_utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
 		size_t insize)
 {
-	const char* inp = input;
-	le16_t* outp = output;
+	const char* iptr = input;
+	const char* iend = input + insize;
+	le16_t* optr = output;
+	const le16_t* oend = output + outsize;
 	wchar_t wc;
 
-	while (inp - input < insize && *inp)
+	while (iptr < iend)
 	{
-		inp = utf8_to_wchar(inp, &wc, insize - (inp - input));
-		if (inp == NULL)
+		iptr = utf8_to_wchar(iptr, &wc, iend - iptr);
+		if (iptr == NULL)
 		{
 			exfat_error("illegal UTF-8 sequence");
 			return -EILSEQ;
 		}
-		outp = wchar_to_utf16(outp, wc, outsize - (outp - output));
-		if (outp == NULL)
+		optr = wchar_to_utf16(optr, wc, oend - optr);
+		if (optr == NULL)
 		{
 			exfat_error("name is too long");
 			return -ENAMETOOLONG;
 		}
+		if (wc == 0)
+			break;
 	}
-	*outp = cpu_to_le16(0);
+	if (optr >= oend)
+	{
+		exfat_error("name is too long");
+		return -ENAMETOOLONG;
+	}
+	*optr = cpu_to_le16(0);
 	return 0;
 }
 
-size_t utf16_length(const le16_t* str)
+size_t exfat_utf16_length(const le16_t* str)
 {
 	size_t i = 0;
 
diff --git a/exfat/libexfat/utils.c b/exfat/libexfat/utils.c
index 39d708e..3a1154e 100644
--- a/exfat/libexfat/utils.c
+++ b/exfat/libexfat/utils.c
@@ -3,7 +3,7 @@
 	exFAT file system implementation library.
 
 	Free exFAT implementation.
-	Copyright (C) 2010-2015  Andrew Nayenko
+	Copyright (C) 2010-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -29,7 +29,7 @@
 		struct stat* stbuf)
 {
 	memset(stbuf, 0, sizeof(struct stat));
-	if (node->flags & EXFAT_ATTRIB_DIR)
+	if (node->attrib & EXFAT_ATTRIB_DIR)
 		stbuf->st_mode = S_IFDIR | (0777 & ~ef->dmask);
 	else
 		stbuf->st_mode = S_IFREG | (0777 & ~ef->fmask);
@@ -37,8 +37,7 @@
 	stbuf->st_uid = ef->uid;
 	stbuf->st_gid = ef->gid;
 	stbuf->st_size = node->size;
-	stbuf->st_blocks = DIV_ROUND_UP(node->size, CLUSTER_SIZE(*ef->sb)) *
-		CLUSTER_SIZE(*ef->sb) / 512;
+	stbuf->st_blocks = ROUND_UP(node->size, CLUSTER_SIZE(*ef->sb)) / 512;
 	stbuf->st_mtime = node->mtime;
 	stbuf->st_atime = node->atime;
 	/* set ctime to mtime to ensure we don't break programs that rely on ctime
@@ -46,49 +45,52 @@
 	stbuf->st_ctime = node->mtime;
 }
 
-void exfat_get_name(const struct exfat_node* node, char* buffer, size_t n)
+void exfat_get_name(const struct exfat_node* node,
+		char buffer[EXFAT_UTF8_NAME_BUFFER_MAX])
 {
-	if (utf16_to_utf8(buffer, node->name, n, EXFAT_NAME_MAX) != 0)
+	if (exfat_utf16_to_utf8(buffer, node->name, EXFAT_UTF8_NAME_BUFFER_MAX,
+				EXFAT_NAME_MAX) != 0)
 		exfat_bug("failed to convert name to UTF-8");
 }
 
+static uint16_t add_checksum_byte(uint16_t sum, uint8_t byte)
+{
+	return ((sum << 15) | (sum >> 1)) + byte;
+}
+
+static uint16_t add_checksum_bytes(uint16_t sum, const void* buffer, size_t n)
+{
+	size_t i;
+
+	for (i = 0; i < n; i++)
+		sum = add_checksum_byte(sum, ((const uint8_t*) buffer)[i]);
+	return sum;
+}
+
 uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry)
 {
 	uint16_t sum = 0;
-	int i;
+	size_t i;
 
 	for (i = 0; i < sizeof(struct exfat_entry); i++)
 		if (i != 2 && i != 3) /* skip checksum field itself */
-			sum = ((sum << 15) | (sum >> 1)) + ((const uint8_t*) entry)[i];
+			sum = add_checksum_byte(sum, ((const uint8_t*) entry)[i]);
 	return sum;
 }
 
 uint16_t exfat_add_checksum(const void* entry, uint16_t sum)
 {
-	int i;
-
-	for (i = 0; i < sizeof(struct exfat_entry); i++)
-		sum = ((sum << 15) | (sum >> 1)) + ((const uint8_t*) entry)[i];
-	return sum;
+	return add_checksum_bytes(sum, entry, sizeof(struct exfat_entry));
 }
 
-le16_t exfat_calc_checksum(const struct exfat_entry_meta1* meta1,
-		const struct exfat_entry_meta2* meta2, const le16_t* name)
+le16_t exfat_calc_checksum(const struct exfat_entry* entries, int n)
 {
 	uint16_t checksum;
-	const int name_entries = DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX);
 	int i;
 
-	checksum = exfat_start_checksum(meta1);
-	checksum = exfat_add_checksum(meta2, checksum);
-	for (i = 0; i < name_entries; i++)
-	{
-		struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0};
-		memcpy(name_entry.name, name + i * EXFAT_ENAME_MAX,
-				MIN(EXFAT_ENAME_MAX, EXFAT_NAME_MAX - i * EXFAT_ENAME_MAX) *
-				sizeof(le16_t));
-		checksum = exfat_add_checksum(&name_entry, checksum);
-	}
+	checksum = exfat_start_checksum((const struct exfat_entry_meta1*) entries);
+	for (i = 1; i < n; i++)
+		checksum = exfat_add_checksum(entries + i, checksum);
 	return cpu_to_le16(checksum);
 }
 
@@ -113,10 +115,10 @@
 	return sum;
 }
 
-le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name)
+le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name,
+		size_t length)
 {
 	size_t i;
-	size_t length = utf16_length(name);
 	uint16_t hash = 0;
 
 	for (i = 0; i < length; i++)
@@ -124,8 +126,7 @@
 		uint16_t c = le16_to_cpu(name[i]);
 
 		/* convert to upper case */
-		if (c < ef->upcase_chars)
-			c = le16_to_cpu(ef->upcase[c]);
+		c = ef->upcase[c];
 
 		hash = ((hash << 15) | (hash >> 1)) + (c & 0xff);
 		hash = ((hash << 15) | (hash >> 1)) + (c >> 8);
@@ -161,8 +162,8 @@
 		uint32_t free_clusters)
 {
 	struct exfat_human_bytes hb;
-	loff_t total_space = le64_to_cpu(sb->sector_count) * SECTOR_SIZE(*sb);
-	loff_t avail_space = (loff_t) free_clusters * CLUSTER_SIZE(*sb);
+	off_t total_space = le64_to_cpu(sb->sector_count) * SECTOR_SIZE(*sb);
+	off_t avail_space = (off_t) free_clusters * CLUSTER_SIZE(*sb);
 
 	printf("File system version           %hhu.%hhu\n",
 			sb->version.major, sb->version.minor);
@@ -177,3 +178,15 @@
 	exfat_humanize_bytes(avail_space, &hb);
 	printf("Available space      %10"PRIu64" %s\n", hb.value, hb.unit);
 }
+
+bool exfat_match_option(const char* options, const char* option_name)
+{
+	const char* p;
+	size_t length = strlen(option_name);
+
+	for (p = strstr(options, option_name); p; p = strstr(p + 1, option_name))
+		if ((p == options || p[-1] == ',') &&
+				(p[length] == ',' || p[length] == '\0'))
+			return true;
+	return false;
+}
diff --git a/exfat/mkfs/cbm.c b/exfat/mkfs/cbm.c
index eb67592..ad5accc 100644
--- a/exfat/mkfs/cbm.c
+++ b/exfat/mkfs/cbm.c
@@ -3,7 +3,7 @@
 	Clusters Bitmap creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -27,12 +27,12 @@
 #include <limits.h>
 #include <string.h>
 
-static loff_t cbm_alignment(void)
+static off_t cbm_alignment(void)
 {
 	return get_cluster_size();
 }
 
-static loff_t cbm_size(void)
+static off_t cbm_size(void)
 {
 	return DIV_ROUND_UP(
 			(get_volume_size() - get_position(&cbm)) / get_cluster_size(),
diff --git a/exfat/mkfs/cbm.h b/exfat/mkfs/cbm.h
index 414b0d7..3803b79 100644
--- a/exfat/mkfs/cbm.h
+++ b/exfat/mkfs/cbm.h
@@ -3,7 +3,7 @@
 	Clusters Bitmap creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
diff --git a/exfat/mkfs/fat.c b/exfat/mkfs/fat.c
index d8dff2b..c5174a7 100644
--- a/exfat/mkfs/fat.c
+++ b/exfat/mkfs/fat.c
@@ -3,7 +3,7 @@
 	File Allocation Table creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -26,12 +26,12 @@
 #include "rootdir.h"
 #include <unistd.h>
 
-static loff_t fat_alignment(void)
+static off_t fat_alignment(void)
 {
-	return (loff_t) 128 * get_sector_size();
+	return (off_t) 128 * get_sector_size();
 }
 
-static loff_t fat_size(void)
+static off_t fat_size(void)
 {
 	return get_volume_size() / get_cluster_size() * sizeof(cluster_t);
 }
diff --git a/exfat/mkfs/fat.h b/exfat/mkfs/fat.h
index 9370cf3..fbecaa2 100644
--- a/exfat/mkfs/fat.h
+++ b/exfat/mkfs/fat.h
@@ -3,7 +3,7 @@
 	File Allocation Table creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
diff --git a/exfat/mkfs/main.c b/exfat/mkfs/main.c
index 43bc0fb..0762024 100644
--- a/exfat/mkfs/main.c
+++ b/exfat/mkfs/main.c
@@ -3,7 +3,7 @@
 	Creates exFAT file system.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -51,7 +51,7 @@
 {
 	int sector_bits;
 	int spc_bits;
-	loff_t volume_size;
+	off_t volume_size;
 	le16_t volume_label[EXFAT_ENAME_MAX + 1];
 	uint32_t volume_serial;
 	uint64_t first_sector;
@@ -68,7 +68,7 @@
 	return param.spc_bits;
 }
 
-loff_t get_volume_size(void)
+off_t get_volume_size(void)
 {
 	return param.volume_size;
 }
@@ -98,13 +98,13 @@
 	return get_sector_size() << get_spc_bits();
 }
 
-static int setup_spc_bits(int sector_bits, int user_defined, loff_t volume_size)
+static int setup_spc_bits(int sector_bits, int user_defined, off_t volume_size)
 {
 	int i;
 
 	if (user_defined != -1)
 	{
-		loff_t cluster_size = 1 << sector_bits << user_defined;
+		off_t cluster_size = 1 << sector_bits << user_defined;
 		if (volume_size / cluster_size > EXFAT_LAST_DATA_CLUSTER)
 		{
 			struct exfat_human_bytes chb, vhb;
@@ -121,9 +121,9 @@
 		return user_defined;
 	}
 
-	if (volume_size < 256ull * 1024 * 1024)
+	if (volume_size < 256LL * 1024 * 1024)
 		return MAX(0, 12 - sector_bits);	/* 4 KB */
-	if (volume_size < 32ull * 1024 * 1024 * 1024)
+	if (volume_size < 32LL * 1024 * 1024 * 1024)
 		return MAX(0, 15 - sector_bits);	/* 32 KB */
 
 	for (i = 17; ; i++)						/* 128 KB or more */
@@ -136,7 +136,7 @@
 	memset(label, 0, (EXFAT_ENAME_MAX + 1) * sizeof(le16_t));
 	if (s == NULL)
 		return 0;
-	return utf8_to_utf16(label, s, EXFAT_ENAME_MAX, strlen(s));
+	return exfat_utf8_to_utf16(label, s, EXFAT_ENAME_MAX + 1, strlen(s));
 }
 
 static uint32_t setup_volume_serial(uint32_t user_defined)
@@ -178,7 +178,7 @@
 
 static int logarithm2(int n)
 {
-	int i;
+	size_t i;
 
 	for (i = 0; i < sizeof(int) * CHAR_BIT - 1; i++)
 		if ((1 << i) == n)
@@ -228,7 +228,7 @@
 			}
 			break;
 		case 'V':
-			puts("Copyright (C) 2011-2015  Andrew Nayenko");
+			puts("Copyright (C) 2011-2018  Andrew Nayenko");
 			return 0;
 		default:
 			usage(argv[0]);
diff --git a/exfat/mkfs/mkexfat.c b/exfat/mkfs/mkexfat.c
index 0929062..eadbe96 100644
--- a/exfat/mkfs/mkexfat.c
+++ b/exfat/mkfs/mkexfat.c
@@ -3,7 +3,7 @@
 	FS creation engine.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -27,10 +27,10 @@
 #include <stdio.h>
 #include <string.h>
 
-static int check_size(loff_t volume_size)
+static int check_size(off_t volume_size)
 {
 	const struct fs_object** pp;
-	loff_t position = 0;
+	off_t position = 0;
 
 	for (pp = objects; *pp; pp++)
 	{
@@ -52,12 +52,12 @@
 }
 
 static int erase_object(struct exfat_dev* dev, const void* block,
-		size_t block_size, loff_t start, loff_t size)
+		off_t block_size, off_t start, off_t size)
 {
-	const loff_t block_count = DIV_ROUND_UP(size, block_size);
-	loff_t i;
+	const off_t block_count = DIV_ROUND_UP(size, block_size);
+	off_t i;
 
-	if (exfat_seek(dev, start, SEEK_SET) == (loff_t) -1)
+	if (exfat_seek(dev, start, SEEK_SET) == (off_t) -1)
 	{
 		exfat_error("seek to 0x%"PRIx64" failed", start);
 		return 1;
@@ -77,13 +77,13 @@
 static int erase(struct exfat_dev* dev)
 {
 	const struct fs_object** pp;
-	loff_t position = 0;
-	const size_t block_size = 1024 * 1024;
+	off_t position = 0;
+	const off_t block_size = 1024 * 1024;
 	void* block = malloc(block_size);
 
 	if (block == NULL)
 	{
-		exfat_error("failed to allocate erase block of %zu bytes", block_size);
+		exfat_error("failed to allocate erase block");
 		return 1;
 	}
 	memset(block, 0, block_size);
@@ -107,12 +107,12 @@
 static int create(struct exfat_dev* dev)
 {
 	const struct fs_object** pp;
-	loff_t position = 0;
+	off_t position = 0;
 
 	for (pp = objects; *pp; pp++)
 	{
 		position = ROUND_UP(position, (*pp)->get_alignment());
-		if (exfat_seek(dev, position, SEEK_SET) == (loff_t) -1)
+		if (exfat_seek(dev, position, SEEK_SET) == (off_t) -1)
 		{
 			exfat_error("seek to 0x%"PRIx64" failed", position);
 			return 1;
@@ -124,7 +124,7 @@
 	return 0;
 }
 
-int mkfs(struct exfat_dev* dev, loff_t volume_size)
+int mkfs(struct exfat_dev* dev, off_t volume_size)
 {
 	if (check_size(volume_size) != 0)
 		return 1;
@@ -146,10 +146,10 @@
 	return 0;
 }
 
-loff_t get_position(const struct fs_object* object)
+off_t get_position(const struct fs_object* object)
 {
 	const struct fs_object** pp;
-	loff_t position = 0;
+	off_t position = 0;
 
 	for (pp = objects; *pp; pp++)
 	{
diff --git a/exfat/mkfs/mkexfat.h b/exfat/mkfs/mkexfat.h
index 6e15c59..963b3e5 100644
--- a/exfat/mkfs/mkexfat.h
+++ b/exfat/mkfs/mkexfat.h
@@ -3,7 +3,7 @@
 	FS creation engine.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -27,8 +27,8 @@
 
 struct fs_object
 {
-	loff_t (*get_alignment)(void);
-	loff_t (*get_size)(void);
+	off_t (*get_alignment)(void);
+	off_t (*get_size)(void);
 	int (*write)(struct exfat_dev* dev);
 };
 
@@ -36,14 +36,14 @@
 
 int get_sector_bits(void);
 int get_spc_bits(void);
-loff_t get_volume_size(void);
+off_t get_volume_size(void);
 const le16_t* get_volume_label(void);
 uint32_t get_volume_serial(void);
 uint64_t get_first_sector(void);
 int get_sector_size(void);
 int get_cluster_size(void);
 
-int mkfs(struct exfat_dev* dev, loff_t volume_size);
-loff_t get_position(const struct fs_object* object);
+int mkfs(struct exfat_dev* dev, off_t volume_size);
+off_t get_position(const struct fs_object* object);
 
 #endif /* ifndef MKFS_MKEXFAT_H_INCLUDED */
diff --git a/exfat/mkfs/mkexfatfs.8 b/exfat/mkfs/mkexfatfs.8
index e339468..6d3c653 100644
--- a/exfat/mkfs/mkexfatfs.8
+++ b/exfat/mkfs/mkexfatfs.8
@@ -1,6 +1,6 @@
-.\" Copyright (C) 2011-2015  Andrew Nayenko
+.\" Copyright (C) 2011-2018  Andrew Nayenko
 .\"
-.TH MKEXFATFS 8 "January 2011"
+.TH MKEXFATFS 8 "January 2014"
 .SH NAME
 .B mkexfatfs
 \- create an exFAT file system
diff --git a/exfat/mkfs/rootdir.c b/exfat/mkfs/rootdir.c
index 33ac3f9..4f9b0e8 100644
--- a/exfat/mkfs/rootdir.c
+++ b/exfat/mkfs/rootdir.c
@@ -3,7 +3,7 @@
 	Root directory creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -26,12 +26,12 @@
 #include "uctc.h"
 #include <string.h>
 
-static loff_t rootdir_alignment(void)
+static off_t rootdir_alignment(void)
 {
 	return get_cluster_size();
 }
 
-static loff_t rootdir_size(void)
+static off_t rootdir_size(void)
 {
 	return get_cluster_size();
 }
@@ -41,12 +41,12 @@
 	memset(label_entry, 0, sizeof(struct exfat_entry_label));
 	label_entry->type = EXFAT_ENTRY_LABEL ^ EXFAT_ENTRY_VALID;
 
-	if (utf16_length(get_volume_label()) == 0)
+	if (exfat_utf16_length(get_volume_label()) == 0)
 		return;
 
 	memcpy(label_entry->name, get_volume_label(),
 			EXFAT_ENAME_MAX * sizeof(le16_t));
-	label_entry->length = utf16_length(get_volume_label());
+	label_entry->length = exfat_utf16_length(get_volume_label());
 	label_entry->type |= EXFAT_ENTRY_VALID;
 }
 
diff --git a/exfat/mkfs/rootdir.h b/exfat/mkfs/rootdir.h
index 56db5b0..87f437f 100644
--- a/exfat/mkfs/rootdir.h
+++ b/exfat/mkfs/rootdir.h
@@ -3,7 +3,7 @@
 	Root directory creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
diff --git a/exfat/mkfs/uct.c b/exfat/mkfs/uct.c
index 14fa56f..98cdce8 100644
--- a/exfat/mkfs/uct.c
+++ b/exfat/mkfs/uct.c
@@ -3,7 +3,7 @@
 	Upper Case Table creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -23,12 +23,12 @@
 #include "uct.h"
 #include "uctc.h"
 
-static loff_t uct_alignment(void)
+static off_t uct_alignment(void)
 {
 	return get_cluster_size();
 }
 
-static loff_t uct_size(void)
+static off_t uct_size(void)
 {
 	return sizeof(upcase_table);
 }
diff --git a/exfat/mkfs/uct.h b/exfat/mkfs/uct.h
index 3a08db9..ce619ec 100644
--- a/exfat/mkfs/uct.h
+++ b/exfat/mkfs/uct.h
@@ -3,7 +3,7 @@
 	Upper Case Table creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
diff --git a/exfat/mkfs/uctc.c b/exfat/mkfs/uctc.c
index 5849f37..518219c 100644
--- a/exfat/mkfs/uctc.c
+++ b/exfat/mkfs/uctc.c
@@ -3,7 +3,7 @@
 	Upper Case Table contents.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
diff --git a/exfat/mkfs/uctc.h b/exfat/mkfs/uctc.h
index 3e200f1..bd5ebb2 100644
--- a/exfat/mkfs/uctc.h
+++ b/exfat/mkfs/uctc.h
@@ -3,7 +3,7 @@
 	Upper Case Table declaration.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
diff --git a/exfat/mkfs/vbr.c b/exfat/mkfs/vbr.c
index a45cc90..e40081f 100644
--- a/exfat/mkfs/vbr.c
+++ b/exfat/mkfs/vbr.c
@@ -3,7 +3,7 @@
 	Volume Boot Record creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -27,12 +27,12 @@
 #include "rootdir.h"
 #include <string.h>
 
-static loff_t vbr_alignment(void)
+static off_t vbr_alignment(void)
 {
 	return get_sector_size();
 }
 
-static loff_t vbr_size(void)
+static off_t vbr_size(void)
 {
 	return 12 * get_sector_size();
 }
@@ -43,7 +43,7 @@
 	uint32_t fat_sectors;
 
 	clusters_max = get_volume_size() / get_cluster_size();
-	fat_sectors = DIV_ROUND_UP((loff_t) clusters_max * sizeof(cluster_t),
+	fat_sectors = DIV_ROUND_UP((off_t) clusters_max * sizeof(cluster_t),
 			get_sector_size());
 
 	memset(sb, 0, sizeof(struct exfat_super_block));
diff --git a/exfat/mkfs/vbr.h b/exfat/mkfs/vbr.h
index 74e60e5..c1f59a6 100644
--- a/exfat/mkfs/vbr.h
+++ b/exfat/mkfs/vbr.h
@@ -3,7 +3,7 @@
 	Volume Boot Record creation code.
 
 	Free exFAT implementation.
-	Copyright (C) 2011-2015  Andrew Nayenko
+	Copyright (C) 2011-2018  Andrew Nayenko
 
 	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by