X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=fuse%2Fmain.c;h=2f157c4dd21403988cda0ddc437476b2f2647c73;hb=7f46abf86d25e38d19f3b653ac3fa0fecd6e0e0a;hp=c0f14740a4b3fb2534533e5fc74a3f66099caec9;hpb=54c2ea497e86830febd716d069e3fc6eabd04143;p=android-x86%2Fexternal-exfat.git diff --git a/fuse/main.c b/fuse/main.c index c0f1474..2f157c4 100644 --- a/fuse/main.c +++ b/fuse/main.c @@ -1,12 +1,26 @@ /* - * main.c - * FUSE-based exFAT implementation. Requires FUSE 2.6 or later. - * - * Created by Andrew Nayenko on 01.09.09. - * This software is distributed under the GNU General Public License - * version 3 or any later. - */ + main.c (01.09.09) + FUSE-based exFAT implementation. Requires FUSE 2.6 or later. + Free exFAT implementation. + Copyright (C) 2010-2013 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. +*/ + +#define FUSE_USE_VERSION 26 #include #include #include @@ -14,6 +28,11 @@ #include #include #include +#include +#include +#include +#include +#include #define exfat_debug(format, ...) @@ -21,60 +40,70 @@ #error FUSE 2.6 or later is required #endif +const char* default_options = "ro_fallback,allow_other,blkdev,big_writes," + "defer_permissions"; + struct exfat ef; -static struct exfat_node* get_node(const struct fuse_file_info *fi) +static struct exfat_node* get_node(const struct fuse_file_info* fi) { return (struct exfat_node*) (size_t) fi->fh; } -static void set_node(struct fuse_file_info *fi, struct exfat_node* node) +static void set_node(struct fuse_file_info* fi, struct exfat_node* node) { fi->fh = (uint64_t) (size_t) node; } -static int fuse_exfat_getattr(const char *path, struct stat *stbuf) +static int fuse_exfat_getattr(const char* path, struct stat* stbuf) { struct exfat_node* node; int rc; - exfat_debug("[fuse_exfat_getattr] %s", path); + exfat_debug("[%s] %s", __func__, path); rc = exfat_lookup(&ef, &node, path); if (rc != 0) return rc; - exfat_stat(node, stbuf); + exfat_stat(&ef, node, stbuf); exfat_put_node(&ef, node); return 0; } -static int fuse_exfat_truncate(const char *path, off_t size) +static int fuse_exfat_truncate(const char* path, off_t size) { struct exfat_node* node; int rc; - exfat_debug("[fuse_exfat_truncate] %s, %llu", path, size); + exfat_debug("[%s] %s, %"PRId64, __func__, path, size); rc = exfat_lookup(&ef, &node, path); if (rc != 0) return rc; - exfat_truncate(&ef, node, size); + 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 0; + return rc; } -static int fuse_exfat_readdir(const char *path, void *buffer, - fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) +static int fuse_exfat_readdir(const char* path, void* buffer, + fuse_fill_dir_t filler, off_t offset, struct fuse_file_info* fi) { struct exfat_node* parent; struct exfat_node* node; struct exfat_iterator it; int rc; - char name[EXFAT_NAME_MAX + 1]; + char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; - exfat_debug("[fuse_exfat_readdir] %s", path); + exfat_debug("[%s] %s", __func__, path); rc = exfat_lookup(&ef, &parent, path); if (rc != 0) @@ -98,8 +127,8 @@ static int fuse_exfat_readdir(const char *path, void *buffer, } while ((node = exfat_readdir(&ef, &it))) { - exfat_get_name(node, name, EXFAT_NAME_MAX); - exfat_debug("[fuse_exfat_readdir] %s: %s, %llu bytes, cluster %u", + exfat_get_name(node, name, sizeof(name) - 1); + exfat_debug("[%s] %s: %s, %"PRId64" bytes, cluster 0x%x", __func__, name, IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented", node->size, node->start_cluster); filler(buffer, name, NULL, 0); @@ -110,46 +139,89 @@ static int fuse_exfat_readdir(const char *path, void *buffer, return 0; } -static int fuse_exfat_open(const char *path, struct fuse_file_info *fi) +static int fuse_exfat_open(const char* path, struct fuse_file_info* fi) { struct exfat_node* node; int rc; - exfat_debug("[fuse_exfat_open] %s", path); + exfat_debug("[%s] %s", __func__, path); rc = exfat_lookup(&ef, &node, path); if (rc != 0) return rc; set_node(fi, node); + fi->keep_cache = 1; return 0; } -static int fuse_exfat_release(const char *path, struct fuse_file_info *fi) +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_read(const char *path, char *buffer, size_t size, - off_t offset, struct fuse_file_info *fi) +static int fuse_exfat_flush(const char* path, struct fuse_file_info* fi) { - exfat_debug("[fuse_exfat_read] %s (%zu bytes)", path, size); - return exfat_read(&ef, get_node(fi), buffer, size, offset); + /* + 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_write(const char *path, const char *buffer, size_t size, - off_t offset, struct fuse_file_info *fi) +static int fuse_exfat_fsync(const char* path, int datasync, + struct fuse_file_info *fi) { - exfat_debug("[fuse_exfat_write] %s (%zu bytes)", path, size); - return exfat_write(&ef, get_node(fi), buffer, size, offset); + int rc; + + exfat_debug("[%s] %s", __func__, path); + rc = exfat_flush(&ef); + if (rc != 0) + return rc; + return exfat_fsync(ef.dev); } -int fuse_exfat_unlink(const char *path) +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; +} + +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; +} + +static int fuse_exfat_unlink(const char* path) { struct exfat_node* node; int rc; - exfat_debug("[fuse_exfat_unlink] %s", path); + exfat_debug("[%s] %s", __func__, path); rc = exfat_lookup(&ef, &node, path); if (rc != 0) @@ -157,15 +229,17 @@ 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); } -int fuse_exfat_rmdir(const char *path) +static int fuse_exfat_rmdir(const char* path) { struct exfat_node* node; int rc; - exfat_debug("[fuse_exfat_rmdir] %s", path); + exfat_debug("[%s] %s", __func__, path); rc = exfat_lookup(&ef, &node, path); if (rc != 0) @@ -173,29 +247,73 @@ 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) { - exfat_debug("[fuse_exfat_mknod] %s", path); + 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) { - exfat_debug("[fuse_exfat_mkdir] %s", path); + exfat_debug("[%s] %s 0%ho", __func__, path, mode); return exfat_mkdir(&ef, path); } -static int fuse_exfat_statfs(const char *path, struct statvfs *sfs) +static int fuse_exfat_rename(const char* old_path, const char* new_path) +{ + exfat_debug("[%s] %s => %s", __func__, old_path, new_path); + return exfat_rename(&ef, old_path, new_path); +} + +static int fuse_exfat_utimens(const char* path, const struct timespec tv[2]) +{ + struct exfat_node* node; + int rc; + + exfat_debug("[%s] %s", __func__, path); + + rc = exfat_lookup(&ef, &node, path); + if (rc != 0) + return rc; + + exfat_utimes(node, tv); + rc = exfat_flush_node(&ef, node); + exfat_put_node(&ef, node); + return rc; +} + +static int fuse_exfat_chmod(const char* path, mode_t mode) +{ + const mode_t VALID_MODE_MASK = S_IFREG | S_IFDIR | + S_IRWXU | S_IRWXG | S_IRWXO; + + exfat_debug("[%s] %s 0%ho", __func__, path, mode); + if (mode & ~VALID_MODE_MASK) + return -EPERM; + return 0; +} + +static int fuse_exfat_chown(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) + return -EPERM; + return 0; +} + +static int fuse_exfat_statfs(const char* path, struct statvfs* sfs) { - const uint64_t block_count = le64_to_cpu(ef.sb->block_count); + exfat_debug("[%s]", __func__); - sfs->f_bsize = BLOCK_SIZE(*ef.sb); + sfs->f_bsize = CLUSTER_SIZE(*ef.sb); sfs->f_frsize = CLUSTER_SIZE(*ef.sb); - sfs->f_blocks = block_count; - sfs->f_bavail = block_count - ef.sb->allocated_percent * block_count / 100; + sfs->f_blocks = le64_to_cpu(ef.sb->sector_count) >> ef.sb->spc_bits; + sfs->f_bavail = exfat_count_free_clusters(&ef); sfs->f_bfree = sfs->f_bavail; sfs->f_namemax = EXFAT_NAME_MAX; @@ -205,21 +323,31 @@ 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->bpc_bits; - sfs->f_favail = sfs->f_bfree >> ef.sb->bpc_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; return 0; } -void fuse_exfat_destroy(void* unused) +static void* fuse_exfat_init(struct fuse_conn_info* fci) { + exfat_debug("[%s]", __func__); +#ifdef FUSE_CAP_BIG_WRITES + fci->want |= FUSE_CAP_BIG_WRITES; +#endif + return NULL; +} + +static void fuse_exfat_destroy(void* unused) +{ + exfat_debug("[%s]", __func__); exfat_unmount(&ef); } static void usage(const char* prog) { - fprintf(stderr, "Usage: %s [-o options]\n", prog); + fprintf(stderr, "Usage: %s [-d] [-o options] [-V] \n", prog); exit(1); } @@ -230,68 +358,201 @@ static struct fuse_operations fuse_exfat_ops = .readdir = fuse_exfat_readdir, .open = fuse_exfat_open, .release = fuse_exfat_release, + .flush = fuse_exfat_flush, + .fsync = fuse_exfat_fsync, + .fsyncdir = fuse_exfat_fsync, .read = fuse_exfat_read, .write = fuse_exfat_write, .unlink = fuse_exfat_unlink, .rmdir = fuse_exfat_rmdir, .mknod = fuse_exfat_mknod, .mkdir = fuse_exfat_mkdir, + .rename = fuse_exfat_rename, + .utimens = fuse_exfat_utimens, + .chmod = fuse_exfat_chmod, + .chown = fuse_exfat_chown, .statfs = fuse_exfat_statfs, + .init = fuse_exfat_init, .destroy = fuse_exfat_destroy, }; +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; + else + size = strlen(options) + strlen(name) + 2; + + options = realloc(options, size); + if (options == NULL) + { + free(optionsf); + exfat_error("failed to reallocate options string"); + return NULL; + } + strcat(options, ","); + strcat(options, name); + if (value) + { + strcat(options, "="); + strcat(options, value); + } + return options; +} + +static char* add_user_option(char* options) +{ + struct passwd* pw; + + if (getuid() == 0) + return options; + + pw = getpwuid(getuid()); + if (pw == NULL || pw->pw_name == NULL) + { + free(options); + exfat_error("failed to determine username"); + return NULL; + } + return add_option(options, "user", pw->pw_name); +} + +static char* add_blksize_option(char* options, long cluster_size) +{ + long page_size = sysconf(_SC_PAGESIZE); + char blksize[20]; + + if (page_size < 1) + page_size = 0x1000; + + snprintf(blksize, sizeof(blksize), "%ld", MIN(page_size, cluster_size)); + return add_option(options, "blksize", blksize); +} + +static char* add_fuse_options(char* options, const char* spec) +{ + options = add_option(options, "fsname", spec); + if (options == NULL) + return NULL; + options = add_user_option(options); + if (options == NULL) + return NULL; + options = add_blksize_option(options, CLUSTER_SIZE(*ef.sb)); + if (options == NULL) + return NULL; + + return options; +} + 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; - const char* mount_options = ""; + char* mount_options; int debug = 0; struct fuse_chan* fc = NULL; struct fuse* fh = NULL; - char** pp; + int opt; - printf("FUSE exfat %u.%u\n", EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR); + printf("FUSE exfat %u.%u.%u\n", + EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR, EXFAT_VERSION_PATCH); - for (pp = argv + 1; *pp; pp++) + mount_options = strdup(default_options); + if (mount_options == NULL) { - if (strcmp(*pp, "-o") == 0) + exfat_error("failed to allocate options string"); + return 1; + } + + while ((opt = getopt(argc, argv, "dno:Vv")) != -1) + { + switch (opt) { - pp++; - if (*pp == NULL) - usage(argv[0]); - mount_options = *pp; - } - else if (strcmp(*pp, "-d") == 0) + case 'd': debug = 1; - else if (spec == NULL) - spec = *pp; - else if (mount_point == NULL) - mount_point = *pp; - else + break; + case 'n': + break; + case 'o': + mount_options = add_option(mount_options, optarg, NULL); + if (mount_options == NULL) + return 1; + break; + case 'V': + free(mount_options); + puts("Copyright (C) 2010-2013 Andrew Nayenko"); + return 0; + case 'v': + break; + default: + free(mount_options); usage(argv[0]); + break; + } } - if (spec == NULL || mount_point == NULL) + if (argc - optind != 2) + { + free(mount_options); usage(argv[0]); + } + spec = argv[optind]; + mount_point = argv[optind + 1]; + + if (exfat_mount(&ef, spec, mount_options) != 0) + { + free(mount_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; + } + } + + mount_options = add_fuse_options(mount_options, spec); + if (mount_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; + } + + 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; } @@ -302,32 +563,32 @@ int main(int argc, char* argv[]) 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))) + 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; } - if (exfat_mount(&ef, spec) != 0) + /* go to background (unless "-d" option is passed) and run FUSE + main loop */ + if (fuse_daemonize(debug) == 0) { - fuse_unmount(mount_point, fc); - fuse_destroy(fh); - return 1; + if (fuse_loop(fh) != 0) + exfat_error("FUSE loop failure"); } + else + exfat_error("failed to daemonize"); - /* go to background unless "-d" option is passed */ - fuse_daemonize(debug); - - /* FUSE main loop */ - fuse_loop(fh); - - /* it's quite illogical but fuse_unmount() must be called BEFORE - fuse_destroy() */ + 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;