X-Git-Url: https://git.sven.stormbind.net/?p=sven%2Fexfat-utils.git;a=blobdiff_plain;f=libexfat%2Fmount.c;h=a62466b1854fb004616ee0760337c9a1bb93dcf8;hp=4240f63b7a34efece8f08f30db1feb241e64bb44;hb=70a4b10edcf53a90140e6dd80ccaa045f3647ad7;hpb=4cb393cfd9b0ab69392612521ee3dbe481ec492d diff --git a/libexfat/mount.c b/libexfat/mount.c index 4240f63..a62466b 100644 --- a/libexfat/mount.c +++ b/libexfat/mount.c @@ -2,7 +2,7 @@ mount.c (22.10.09) exFAT file system implementation library. - Copyright (C) 2009, 2010 Andrew Nayenko + Copyright (C) 2010-2012 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,8 +24,6 @@ #include #include #include -#define _XOPEN_SOURCE /* for tzset() in Linux */ -#include static uint64_t rootdir_size(const struct exfat* ef) { @@ -92,20 +90,21 @@ static void parse_options(struct exfat* ef, const char* options) ef->noatime = match_option(options, "noatime"); } -static int verify_vbr_checksum(void* sector, off_t sector_size, int fd) +static int verify_vbr_checksum(struct exfat_dev* dev, void* sector, + off_t sector_size) { uint32_t vbr_checksum; int i; - exfat_read_raw(sector, sector_size, 0, fd); + exfat_pread(dev, 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(dev, 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(dev, 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,41 +115,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->dev, ef->sb, sizeof(struct exfat_super_block), 0); + return exfat_fsync(ef->dev); +} + +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->dev = exfat_open(spec, ef->ro); + if (ef->dev == NULL) + { + if (ef->ro || !match_option(options, "ro_fallback")) + return -EIO; + ef->dev = exfat_open(spec, 1); + if (ef->dev == NULL) + 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) { - exfat_error("memory allocation failed"); + exfat_close(ef->dev); + exfat_error("failed to allocate memory for the super block"); 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; - } - - exfat_read_raw(ef->sb, sizeof(struct exfat_super_block), 0, ef->fd); + exfat_pread(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0); if (memcmp(ef->sb->oem_name, "EXFAT ", 8) != 0) { - close(ef->fd); + exfat_close(ef->dev); 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->dev); exfat_error("unsupported exFAT version: %hhu.%hhu", ef->sb->version.major, ef->sb->version.minor); free(ef->sb); @@ -158,7 +182,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->dev); free(ef->sb); exfat_error("unsupported FAT count: %hhu", ef->sb->fat_count); return -EIO; @@ -166,36 +190,37 @@ 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->dev); free(ef->sb); exfat_error("too big cluster size: 2^%d", (int) ef->sb->sector_bits + (int) ef->sb->spc_bits); 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); + exfat_close(ef->dev); 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->dev, ef->zero_cluster, + SECTOR_SIZE(*ef->sb)) != 0) { - free(ef->zero_sector); - close(ef->fd); + free(ef->zero_cluster); + exfat_close(ef->dev); 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); - close(ef->fd); + free(ef->zero_cluster); + exfat_close(ef->dev); free(ef->sb); exfat_error("failed to allocate root node"); return -ENOMEM; @@ -226,33 +251,56 @@ 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); - close(ef->fd); + free(ef->zero_cluster); + exfat_close(ef->dev); 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; + 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; - 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);