X-Git-Url: http://git.sven.stormbind.net/?p=sven%2Fexfat-utils.git;a=blobdiff_plain;f=libexfat%2Fio.c;h=4413aaa52ce5b5256a5706a011e652368c0bfc6d;hp=25988f0a97ac84910e44abe993ef0984e10f36b4;hb=refs%2Ftags%2Fupstream%2F1.0.1;hpb=dbe4348df2ba88986e13163ef13d09fb7247589d diff --git a/libexfat/io.c b/libexfat/io.c index 25988f0..4413aaa 100644 --- a/libexfat/io.c +++ b/libexfat/io.c @@ -2,7 +2,7 @@ io.c (02.09.09) exFAT file system implementation library. - Copyright (C) 2009, 2010 Andrew Nayenko + 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 @@ -21,59 +21,290 @@ #include "exfat.h" #include #include -#include #include +#include #include -#define __USE_UNIX98 /* for pread() in Linux */ #include - -#if _FILE_OFFSET_BITS != 64 - #error You should define _FILE_OFFSET_BITS=64 +#include +#ifdef __APPLE__ +#include +#endif +#ifdef USE_UBLIO +#include +#include #endif -int exfat_open(const char* spec, int ro) +struct exfat_dev { int fd; - struct stat stbuf; + enum exfat_mode mode; + off_t size; /* in bytes */ +#ifdef USE_UBLIO + off_t pos; + ublio_filehandle_t ufh; +#endif +}; - fd = open(spec, ro ? O_RDONLY : O_RDWR); - if (fd < 0) +static int open_ro(const char* spec) +{ + return open(spec, O_RDONLY); +} + +static int open_rw(const char* spec) +{ + int fd = open(spec, O_RDWR); +#ifdef __linux__ + int ro = 0; + + /* + This ioctl is needed because after "blockdev --setro" kernel still + allows to open the device in read-write mode but fails writes. + */ + if (fd != -1 && ioctl(fd, BLKROGET, &ro) == 0 && ro) { - exfat_error("failed to open `%s' in read-%s mode", spec, - ro ? "only" : "write"); + close(fd); return -1; } - if (fstat(fd, &stbuf) != 0) +#endif + return fd; +} + +struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode) +{ + struct exfat_dev* dev; + struct stat stbuf; +#ifdef USE_UBLIO + struct ublio_param up; +#endif + + dev = malloc(sizeof(struct exfat_dev)); + if (dev == NULL) { - close(fd); + exfat_error("failed to allocate memory for device structure"); + return NULL; + } + + switch (mode) + { + case EXFAT_MODE_RO: + dev->fd = open_ro(spec); + if (dev->fd == -1) + { + free(dev); + exfat_error("failed to open `%s' in read-only mode", spec); + return NULL; + } + dev->mode = EXFAT_MODE_RO; + break; + case EXFAT_MODE_RW: + dev->fd = open_rw(spec); + if (dev->fd == -1) + { + free(dev); + exfat_error("failed to open `%s' in read-write mode", spec); + return NULL; + } + dev->mode = EXFAT_MODE_RW; + break; + case EXFAT_MODE_ANY: + dev->fd = open_rw(spec); + if (dev->fd != -1) + { + dev->mode = EXFAT_MODE_RW; + break; + } + dev->fd = open_ro(spec); + if (dev->fd != -1) + { + dev->mode = EXFAT_MODE_RO; + exfat_warn("`%s' is write-protected, mounting read-only", spec); + break; + } + free(dev); + exfat_error("failed to open `%s'", spec); + return NULL; + } + + if (fstat(dev->fd, &stbuf) != 0) + { + close(dev->fd); + free(dev); exfat_error("failed to fstat `%s'", spec); - return -1; + return NULL; } - if (!S_ISBLK(stbuf.st_mode) && !S_ISREG(stbuf.st_mode)) + if (!S_ISBLK(stbuf.st_mode) && + !S_ISCHR(stbuf.st_mode) && + !S_ISREG(stbuf.st_mode)) { - close(fd); - exfat_error("`%s' is neither a block device, nor a regular file", - spec); - return -1; + close(dev->fd); + free(dev); + exfat_error("`%s' is neither a device, nor a regular file", spec); + return NULL; } - return fd; + +#ifdef __APPLE__ + if (!S_ISREG(stbuf.st_mode)) + { + uint32_t block_size = 0; + uint64_t blocks = 0; + + if (ioctl(dev->fd, DKIOCGETBLOCKSIZE, &block_size) != 0) + { + close(dev->fd); + free(dev); + exfat_error("failed to get block size"); + return NULL; + } + if (ioctl(dev->fd, DKIOCGETBLOCKCOUNT, &blocks) != 0) + { + close(dev->fd); + free(dev); + exfat_error("failed to get blocks count"); + return NULL; + } + dev->size = blocks * block_size; + } + else +#endif + { + /* works for Linux, FreeBSD, Solaris */ + dev->size = exfat_seek(dev, 0, SEEK_END); + if (dev->size <= 0) + { + close(dev->fd); + free(dev); + exfat_error("failed to get size of `%s'", spec); + return NULL; + } + if (exfat_seek(dev, 0, SEEK_SET) == -1) + { + close(dev->fd); + free(dev); + exfat_error("failed to seek to the beginning of `%s'", spec); + return NULL; + } + } + +#ifdef USE_UBLIO + memset(&up, 0, sizeof(struct ublio_param)); + up.up_blocksize = 256 * 1024; + up.up_items = 64; + up.up_grace = 32; + up.up_priv = &dev->fd; + + dev->pos = 0; + dev->ufh = ublio_open(&up); + if (dev->ufh == NULL) + { + close(dev->fd); + free(dev); + exfat_error("failed to initialize ublio"); + return NULL; + } +#endif + + return dev; +} + +int exfat_close(struct exfat_dev* dev) +{ +#ifdef USE_UBLIO + if (ublio_close(dev->ufh) != 0) + exfat_error("failed to close ublio"); +#endif + if (close(dev->fd) != 0) + { + free(dev); + exfat_error("failed to close device"); + return 1; + } + free(dev); + return 0; +} + +int exfat_fsync(struct exfat_dev* dev) +{ +#ifdef USE_UBLIO + if (ublio_fsync(dev->ufh) != 0) +#else + if (fsync(dev->fd) != 0) +#endif + { + exfat_error("fsync failed"); + return 1; + } + return 0; } -void exfat_read_raw(void* buffer, size_t size, off_t offset, int fd) +enum exfat_mode exfat_get_mode(const struct exfat_dev* dev) { - if (pread(fd, buffer, size, offset) != size) + return dev->mode; +} + +off_t exfat_get_size(const struct exfat_dev* dev) +{ + return dev->size; +} + +off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence) +{ +#ifdef USE_UBLIO + /* XXX SEEK_CUR will be handled incorrectly */ + return dev->pos = lseek(dev->fd, offset, whence); +#else + return lseek(dev->fd, offset, whence); +#endif +} + +ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size) +{ +#ifdef USE_UBLIO + ssize_t result = ublio_pread(dev->ufh, buffer, size, dev->pos); + if (result >= 0) + dev->pos += size; + return result; +#else + return read(dev->fd, buffer, size); +#endif +} + +ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size) +{ +#ifdef USE_UBLIO + ssize_t result = ublio_pwrite(dev->ufh, buffer, size, dev->pos); + if (result >= 0) + dev->pos += size; + return result; +#else + return write(dev->fd, buffer, size); +#endif +} + +void exfat_pread(struct exfat_dev* dev, void* buffer, size_t size, + off_t offset) +{ +#ifdef USE_UBLIO + if (ublio_pread(dev->ufh, buffer, size, offset) != size) +#else + if (pread(dev->fd, buffer, size, offset) != size) +#endif exfat_bug("failed to read %zu bytes from file at %"PRIu64, size, (uint64_t) offset); } -void exfat_write_raw(const void* buffer, size_t size, off_t offset, int fd) +void exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size, + off_t offset) { - if (pwrite(fd, buffer, size, offset) != size) +#ifdef USE_UBLIO + if (ublio_pwrite(dev->ufh, buffer, size, offset) != size) +#else + if (pwrite(dev->fd, buffer, size, offset) != size) +#endif exfat_bug("failed to write %zu bytes to file at %"PRIu64, size, (uint64_t) offset); } -ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node, +ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node, void* buffer, size_t size, off_t offset) { cluster_t cluster; @@ -88,7 +319,7 @@ ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node, cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb)); if (CLUSTER_INVALID(cluster)) { - exfat_error("got invalid cluster"); + exfat_error("invalid cluster 0x%x while reading", cluster); return -1; } @@ -98,11 +329,11 @@ ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node, { if (CLUSTER_INVALID(cluster)) { - exfat_error("got invalid cluster"); + exfat_error("invalid cluster 0x%x while reading", cluster); return -1; } lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder); - exfat_read_raw(bufp, lsize, exfat_c2o(ef, cluster) + loffset, ef->fd); + exfat_pread(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset); bufp += lsize; loffset = 0; remainder -= lsize; @@ -110,10 +341,10 @@ ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node, } if (!ef->ro && !ef->noatime) exfat_update_atime(node); - return size - remainder; + return MIN(size, node->size - offset) - remainder; } -ssize_t exfat_write(struct exfat* ef, struct exfat_node* node, +ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node, const void* buffer, size_t size, off_t offset) { cluster_t cluster; @@ -121,18 +352,15 @@ ssize_t exfat_write(struct exfat* ef, struct exfat_node* node, off_t lsize, loffset, remainder; if (offset + size > node->size) - { - int rc = exfat_truncate(ef, node, offset + size); - if (rc != 0) - return rc; - } + if (exfat_truncate(ef, node, offset + size) != 0) + return -1; if (size == 0) return 0; cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb)); if (CLUSTER_INVALID(cluster)) { - exfat_error("got invalid cluster"); + exfat_error("invalid cluster 0x%x while writing", cluster); return -1; } @@ -142,11 +370,11 @@ ssize_t exfat_write(struct exfat* ef, struct exfat_node* node, { if (CLUSTER_INVALID(cluster)) { - exfat_error("got invalid cluster"); + exfat_error("invalid cluster 0x%x while writing", cluster); return -1; } lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder); - exfat_write_raw(bufp, lsize, exfat_c2o(ef, cluster) + loffset, ef->fd); + exfat_pwrite(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset); bufp += lsize; loffset = 0; remainder -= lsize;