Added exfat_fsync() function that performs fsync against the specified descriptor.

[android-x86/external-exfat.git] / libexfat / mount.c

diff --git a/libexfat/mount.c b/libexfat/mount.c
index 254a3e6..b06fdd0 100644 (file)
--- a/libexfat/mount.c
+++ b/libexfat/mount.c
@@ -24,8 +24,6 @@
 #include <errno.h>
 #include <unistd.h>
 #include <sys/types.h>
-#define _XOPEN_SOURCE /* for tzset() in Linux */
-#include <time.h>
 
 static uint64_t rootdir_size(const struct exfat* ef)
 {
@@ -97,15 +95,15 @@ static int verify_vbr_checksum(void* sector, off_t sector_size, int fd)
        uint32_t vbr_checksum;
        int i;
 
-       exfat_read_raw(sector, sector_size, 0, fd);
+       exfat_pread(fd, sector, sector_size, 0);
        vbr_checksum = exfat_vbr_start_checksum(sector, sector_size);
        for (i = 1; i < 11; i++)
        {
-               exfat_read_raw(sector, sector_size, i * sector_size, fd);
+               exfat_pread(fd, sector, sector_size, i * sector_size);
                vbr_checksum = exfat_vbr_add_checksum(sector, sector_size,
                                vbr_checksum);
        }
-       exfat_read_raw(sector, sector_size, i * sector_size, fd);
+       exfat_pread(fd, sector, sector_size, i * sector_size);
        for (i = 0; i < sector_size / sizeof(vbr_checksum); i++)
                if (le32_to_cpu(((const le32_t*) sector)[i]) != vbr_checksum)
                {
@@ -116,39 +114,66 @@ static int verify_vbr_checksum(void* sector, off_t sector_size, int fd)
        return 0;
 }
 
+static int commit_super_block(const struct exfat* ef)
+{
+       exfat_pwrite(ef->fd, ef->sb, sizeof(struct exfat_super_block), 0);
+       return exfat_fsync(ef->fd);
+}
+
+static int prepare_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;
+
+       ef->sb->volume_state = cpu_to_le16(
+                       le16_to_cpu(ef->sb->volume_state) | EXFAT_STATE_MOUNTED);
+       return commit_super_block(ef);
+}
+
 int exfat_mount(struct exfat* ef, const char* spec, const char* options)
 {
        int rc;
 
-       tzset();
+       exfat_tzset();
        memset(ef, 0, sizeof(struct exfat));
 
        parse_options(ef, options);
 
        ef->fd = exfat_open(spec, ef->ro);
        if (ef->fd < 0)
-               return -EIO;
+       {
+               if (ef->ro || !match_option(options, "ro_fallback"))
+                       return -EIO;
+               ef->fd = exfat_open(spec, 1);
+               if (ef->fd < 0)
+                       return -EIO;
+               exfat_warn("device is write-protected, mounting read-only");
+               ef->ro_fallback = ef->ro = 1;
+       }
 
        ef->sb = malloc(sizeof(struct exfat_super_block));
        if (ef->sb == NULL)
        {
-               close(ef->fd);
+               exfat_close(ef->fd);
                exfat_error("failed to allocate memory for the super block");
                return -ENOMEM;
        }
        memset(ef->sb, 0, sizeof(struct exfat_super_block));
 
-       exfat_read_raw(ef->sb, sizeof(struct exfat_super_block), 0, ef->fd);
+       exfat_pread(ef->fd, ef->sb, sizeof(struct exfat_super_block), 0);
        if (memcmp(ef->sb->oem_name, "EXFAT   ", 8) != 0)
        {
-               close(ef->fd);
+               exfat_close(ef->fd);
                free(ef->sb);
                exfat_error("exFAT file system is not found");
                return -EIO;
        }
        if (ef->sb->version.major != 1 || ef->sb->version.minor != 0)
        {
-               close(ef->fd);
+               exfat_close(ef->fd);
                exfat_error("unsupported exFAT version: %hhu.%hhu",
                                ef->sb->version.major, ef->sb->version.minor);
                free(ef->sb);
@@ -156,7 +181,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        }
        if (ef->sb->fat_count != 1)
        {
-               close(ef->fd);
+               exfat_close(ef->fd);
                free(ef->sb);
                exfat_error("unsupported FAT count: %hhu", ef->sb->fat_count);
                return -EIO;
@@ -164,7 +189,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        /* officially exFAT supports cluster size up to 32 MB */
        if ((int) ef->sb->sector_bits + (int) ef->sb->spc_bits > 25)
        {
-               close(ef->fd);
+               exfat_close(ef->fd);
                free(ef->sb);
                exfat_error("too big cluster size: 2^%d",
                                (int) ef->sb->sector_bits + (int) ef->sb->spc_bits);
@@ -174,7 +199,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        ef->zero_cluster = malloc(CLUSTER_SIZE(*ef->sb));
        if (ef->zero_cluster == NULL)
        {
-               close(ef->fd);
+               exfat_close(ef->fd);
                free(ef->sb);
                exfat_error("failed to allocate zero sector");
                return -ENOMEM;
@@ -184,7 +209,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
                        ef->fd) != 0)
        {
                free(ef->zero_cluster);
-               close(ef->fd);
+               exfat_close(ef->fd);
                free(ef->sb);
                return -EIO;
        }
@@ -194,7 +219,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        if (ef->root == NULL)
        {
                free(ef->zero_cluster);
-               close(ef->fd);
+               exfat_close(ef->fd);
                free(ef->sb);
                exfat_error("failed to allocate root node");
                return -ENOMEM;
@@ -225,6 +250,9 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
                goto error;
        }
 
+       if (prepare_super_block(ef) != 0)
+               goto error;
+
        return 0;
 
 error:
@@ -232,26 +260,46 @@ error:
        exfat_reset_cache(ef);
        free(ef->root);
        free(ef->zero_cluster);
-       close(ef->fd);
+       exfat_close(ef->fd);
        free(ef->sb);
        return -EIO;
 }
 
+static void finalize_super_block(struct exfat* ef)
+{
+       if (ef->ro)
+               return;
+
+       ef->sb->volume_state = cpu_to_le16(
+                       le16_to_cpu(ef->sb->volume_state) & ~EXFAT_STATE_MOUNTED);
+
+       /* Some implementations set the percentage of allocated space to 0xff
+          on FS creation and never update it. In this case leave it as is. */
+       if (ef->sb->allocated_percent != 0xff)
+       {
+               uint32_t free, total;
+
+               free = exfat_count_free_clusters(ef);
+               total = le32_to_cpu(ef->sb->cluster_count);
+               ef->sb->allocated_percent = ((total - free) * 100 + total / 2) / total;
+       }
+
+       commit_super_block(ef);
+}
+
 void exfat_unmount(struct exfat* ef)
 {
        exfat_put_node(ef, ef->root);
        exfat_reset_cache(ef);
        free(ef->root);
        ef->root = NULL;
+       finalize_super_block(ef);
+       exfat_close(ef->fd);    /* close descriptor immediately after fsync */
+       ef->fd = 0;
        free(ef->zero_cluster);
        ef->zero_cluster = NULL;
        free(ef->cmap.chunk);
        ef->cmap.chunk = NULL;
-       if (fsync(ef->fd) < 0)
-               exfat_error("fsync failed");
-       if (close(ef->fd) < 0)
-               exfat_error("close failed");
-       ef->fd = 0;
        free(ef->sb);
        ef->sb = NULL;
        free(ef->upcase);