Merge commit 'upstream/0.9.6'

[sven/exfat-utils.git] / libexfat / mount.c

diff --git a/libexfat/mount.c b/libexfat/mount.c
index 4240f63b7a34efece8f08f30db1feb241e64bb44..295d455eff73a6d5158f47cff4634b147dd9d423 100644 (file)
--- a/libexfat/mount.c
+++ b/libexfat/mount.c
@@ -116,6 +116,30 @@ 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_write_raw(ef->sb, sizeof(struct exfat_super_block), 0, ef->fd);
+       if (fsync(ef->fd) < 0)
+       {
+               exfat_error("fsync failed");
+               return 1;
+       }
+       return 0;
+}
+
+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;
@@ -123,23 +147,29 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        tzset();
        memset(ef, 0, sizeof(struct exfat));
 
-       ef->sb = malloc(sizeof(struct exfat_super_block));
-       if (ef->sb == NULL)
-       {
-               exfat_error("memory allocation failed");
-               return -ENOMEM;
-       }
-       memset(ef->sb, 0, sizeof(struct exfat_super_block));
-
        parse_options(ef, options);
 
        ef->fd = exfat_open(spec, ef->ro);
        if (ef->fd < 0)
        {
-               free(ef->sb);
-               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_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);
        if (memcmp(ef->sb->oem_name, "EXFAT   ", 8) != 0)
        {
@@ -173,28 +203,29 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
                return -EIO;
        }
 
-       ef->zero_sector = malloc(SECTOR_SIZE(*ef->sb));
-       if (ef->zero_sector == NULL)
+       ef->zero_cluster = malloc(CLUSTER_SIZE(*ef->sb));
+       if (ef->zero_cluster == NULL)
        {
                close(ef->fd);
                free(ef->sb);
                exfat_error("failed to allocate zero sector");
                return -ENOMEM;
        }
-       /* use zero_sector as a temporary buffer for VBR checksum verification */
-       if (verify_vbr_checksum(ef->zero_sector, SECTOR_SIZE(*ef->sb), ef->fd) != 0)
+       /* use zero_cluster as a temporary buffer for VBR checksum verification */
+       if (verify_vbr_checksum(ef->zero_cluster, SECTOR_SIZE(*ef->sb),
+                       ef->fd) != 0)
        {
-               free(ef->zero_sector);
+               free(ef->zero_cluster);
                close(ef->fd);
                free(ef->sb);
                return -EIO;
        }
-       memset(ef->zero_sector, 0, SECTOR_SIZE(*ef->sb));
+       memset(ef->zero_cluster, 0, CLUSTER_SIZE(*ef->sb));
 
        ef->root = malloc(sizeof(struct exfat_node));
        if (ef->root == NULL)
        {
-               free(ef->zero_sector);
+               free(ef->zero_cluster);
                close(ef->fd);
                free(ef->sb);
                exfat_error("failed to allocate root node");
@@ -226,33 +257,57 @@ 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:
        exfat_put_node(ef, ef->root);
        exfat_reset_cache(ef);
        free(ef->root);
-       free(ef->zero_sector);
+       free(ef->zero_cluster);
        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;
-       free(ef->zero_sector);
-       ef->zero_sector = NULL;
-       free(ef->cmap.chunk);
-       ef->cmap.chunk = NULL;
-       if (fsync(ef->fd) < 0)
-               exfat_error("fsync failed");
-       if (close(ef->fd) < 0)
+       finalize_super_block(ef);
+       if (close(ef->fd) < 0)  /* close descriptor immediately after fsync */
                exfat_error("close failed");
        ef->fd = 0;
+       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);