X-Git-Url: http://git.osdn.net/view?p=android-x86%2Fexternal-exfat.git;a=blobdiff_plain;f=fuse%2Fmain.c;h=6d566d9f628bdb9c63fd6a2b4040fac4533cc690;hp=4bf553e6029f61e5c065c3cdae0da47764681d69;hb=1d97b365a8cc33a0f3c22d16f737a5498f9f795b;hpb=1688f2775f1468ed5be0b01bd8518f2d7144b808 diff --git a/fuse/main.c b/fuse/main.c index 4bf553e..6d566d9 100644 --- a/fuse/main.c +++ b/fuse/main.c @@ -3,7 +3,7 @@ FUSE-based exFAT implementation. Requires FUSE 2.6 or later. Free exFAT implementation. - Copyright (C) 2010-2013 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 @@ -20,6 +20,7 @@ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#include #define FUSE_USE_VERSION 26 #include #include @@ -27,21 +28,22 @@ #include #include #include -#include #include #include #include #include #include -#define exfat_debug(format, ...) +#ifndef DEBUG + #define exfat_debug(format, ...) +#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," - "defer_permissions"; + "default_permissions"; struct exfat ef; @@ -53,6 +55,7 @@ static struct exfat_node* get_node(const struct fuse_file_info* fi) static void set_node(struct fuse_file_info* fi, struct exfat_node* node) { fi->fh = (uint64_t) (size_t) node; + fi->keep_cache = 1; } static int fuse_exfat_getattr(const char* path, struct stat* stbuf) @@ -83,6 +86,13 @@ static int fuse_exfat_truncate(const char* path, off_t size) return rc; rc = exfat_truncate(&ef, node, size, true); + if (rc != 0) + { + exfat_flush_node(&ef, node); /* ignore return code */ + exfat_put_node(&ef, node); + return rc; + } + rc = exfat_flush_node(&ef, node); exfat_put_node(&ef, node); return rc; } @@ -94,17 +104,18 @@ static int fuse_exfat_readdir(const char* path, void* buffer, 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; } @@ -115,16 +126,17 @@ static int fuse_exfat_readdir(const char* path, void* buffer, if (rc != 0) { exfat_put_node(&ef, parent); - exfat_error("failed to open directory `%s'", path); + 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); @@ -143,48 +155,80 @@ static int fuse_exfat_open(const char* path, struct fuse_file_info* fi) if (rc != 0) return rc; set_node(fi, node); - fi->keep_cache = 1; + return 0; +} + +static int fuse_exfat_create(const char* path, mode_t mode, + struct fuse_file_info* fi) +{ + struct exfat_node* node; + int rc; + + exfat_debug("[%s] %s 0%ho", __func__, path, mode); + + rc = exfat_mknod(&ef, path); + if (rc != 0) + return rc; + rc = exfat_lookup(&ef, &node, path); + if (rc != 0) + return rc; + set_node(fi, node); return 0; } static int fuse_exfat_release(const char* path, struct fuse_file_info* fi) { + /* + This handler is called by FUSE on close() syscall. If the FUSE + implementation does not call flush handler, we will flush node here. + But in this case we will not be able to return an error to the caller. + See fuse_exfat_flush() below. + */ exfat_debug("[%s] %s", __func__, path); + exfat_flush_node(&ef, get_node(fi)); exfat_put_node(&ef, get_node(fi)); - return 0; + return 0; /* FUSE ignores this return value */ +} + +static int fuse_exfat_flush(const char* path, struct fuse_file_info* fi) +{ + /* + This handler may be called by FUSE on close() syscall. FUSE also deals + with removals of open files, so we don't free clusters on close but + only on rmdir and unlink. If the FUSE implementation does not call this + handler we will flush node on release. See fuse_exfat_relase() above. + */ + exfat_debug("[%s] %s", __func__, path); + return exfat_flush_node(&ef, get_node(fi)); } static int fuse_exfat_fsync(const char* path, int datasync, struct fuse_file_info *fi) { + int rc; + exfat_debug("[%s] %s", __func__, path); - exfat_flush_node(&ef, get_node(fi)); - exfat_flush(&ef); + rc = exfat_flush_nodes(&ef); + if (rc != 0) + return rc; + rc = exfat_flush(&ef); + if (rc != 0) + return rc; return exfat_fsync(ef.dev); } static int fuse_exfat_read(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, 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) @@ -200,7 +244,9 @@ static int fuse_exfat_unlink(const char* path) rc = exfat_unlink(&ef, node); exfat_put_node(&ef, node); - return rc; + if (rc != 0) + return rc; + return exfat_cleanup_node(&ef, node); } static int fuse_exfat_rmdir(const char* path) @@ -216,7 +262,9 @@ static int fuse_exfat_rmdir(const char* path) rc = exfat_rmdir(&ef, node); exfat_put_node(&ef, node); - return rc; + if (rc != 0) + return rc; + return exfat_cleanup_node(&ef, node); } static int fuse_exfat_mknod(const char* path, mode_t mode, dev_t dev) @@ -249,8 +297,9 @@ static int fuse_exfat_utimens(const char* path, const struct timespec tv[2]) return rc; exfat_utimes(node, tv); + rc = exfat_flush_node(&ef, node); exfat_put_node(&ef, node); - return 0; + return rc; } static int fuse_exfat_chmod(const char* path, mode_t mode) @@ -289,7 +338,7 @@ static int fuse_exfat_statfs(const char* path, struct statvfs* sfs) b) no such thing as inode; So here we assume that inode = cluster. */ - sfs->f_files = (sfs->f_blocks - sfs->f_bfree) >> ef.sb->spc_bits; + sfs->f_files = le32_to_cpu(ef.sb->cluster_count); sfs->f_favail = sfs->f_bfree >> ef.sb->spc_bits; sfs->f_ffree = sfs->f_bavail; @@ -323,7 +372,9 @@ static struct fuse_operations fuse_exfat_ops = .truncate = fuse_exfat_truncate, .readdir = fuse_exfat_readdir, .open = fuse_exfat_open, + .create = fuse_exfat_create, .release = fuse_exfat_release, + .flush = fuse_exfat_flush, .fsync = fuse_exfat_fsync, .fsyncdir = fuse_exfat_fsync, .read = fuse_exfat_read, @@ -344,6 +395,7 @@ static struct fuse_operations fuse_exfat_ops = static char* add_option(char* options, const char* name, const char* value) { size_t size; + char* optionsf = options; if (value) size = strlen(options) + strlen(name) + strlen(value) + 3; @@ -353,6 +405,7 @@ static char* add_option(char* options, const char* name, const char* value) options = realloc(options, size); if (options == NULL) { + free(optionsf); exfat_error("failed to reallocate options string"); return NULL; } @@ -366,6 +419,41 @@ static char* add_option(char* options, const char* name, const char* value) 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; +} + static char* add_user_option(char* options) { struct passwd* pw; @@ -395,9 +483,12 @@ static char* add_blksize_option(char* options, long cluster_size) return add_option(options, "blksize", blksize); } -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; options = add_user_option(options); @@ -422,8 +513,7 @@ int main(int argc, char* argv[]) struct fuse* fh = NULL; int opt; - printf("FUSE exfat %u.%u.%u\n", - EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH); + printf("FUSE exfat %s\n", VERSION); mount_options = strdup(default_options); if (mount_options == NULL) @@ -448,7 +538,7 @@ int main(int argc, char* argv[]) break; case 'V': free(mount_options); - puts("Copyright (C) 2010-2013 Andrew Nayenko"); + puts("Copyright (C) 2010-2018 Andrew Nayenko"); return 0; case 'v': break; @@ -472,17 +562,7 @@ int main(int argc, char* argv[]) 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; - } - } - - mount_options = add_fuse_options(mount_options, spec); + mount_options = add_fuse_options(mount_options, spec, (ef.ro != 0)); if (mount_options == NULL) { exfat_unmount(&ef);