exFAT file system implementation library.
Free exFAT implementation.
- Copyright (C) 2010-2016 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
#include <sys/disklabel.h>
#include <sys/dkio.h>
#include <sys/ioctl.h>
-#endif
+#elif __linux__
#include <sys/mount.h>
+#endif
+#ifdef USE_UBLIO
+#include <sys/uio.h>
+#include <ublio.h>
+#endif
struct exfat_dev
{
int fd;
enum exfat_mode mode;
off_t size; /* in bytes */
+#ifdef USE_UBLIO
+ off_t pos;
+ ublio_filehandle_t ufh;
+#endif
};
+static bool is_open(int fd)
+{
+ return fcntl(fd, F_GETFD) != -1;
+}
+
static int open_ro(const char* spec)
{
return open(spec, O_RDONLY);
{
struct exfat_dev* dev;
struct stat stbuf;
+#ifdef USE_UBLIO
+ struct ublio_param up;
+#endif
+
+ /* The system allocates file descriptors sequentially. If we have been
+ started with stdin (0), stdout (1) or stderr (2) closed, the system
+ will give us descriptor 0, 1 or 2 later when we open block device,
+ FUSE communication pipe, etc. As a result, functions using stdin,
+ stdout or stderr will actually work with a different thing and can
+ corrupt it. Protect descriptors 0, 1 and 2 from such misuse. */
+ while (!is_open(STDIN_FILENO)
+ || !is_open(STDOUT_FILENO)
+ || !is_open(STDERR_FILENO))
+ {
+ /* we don't need those descriptors, let them leak */
+ if (open("/dev/null", O_RDWR) == -1)
+ {
+ exfat_error("failed to open /dev/null");
+ return NULL;
+ }
+ }
dev = malloc(sizeof(struct exfat_dev));
if (dev == 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 rc = 0;
+#ifdef USE_UBLIO
+ if (ublio_close(dev->ufh) != 0)
+ {
+ exfat_error("failed to close ublio");
+ rc = -EIO;
+ }
+#endif
if (close(dev->fd) != 0)
{
exfat_error("failed to close device: %s", strerror(errno));
{
int rc = 0;
+#ifdef USE_UBLIO
+ if (ublio_fsync(dev->ufh) != 0)
+ {
+ exfat_error("ublio fsync failed");
+ rc = -EIO;
+ }
+#endif
if (fsync(dev->fd) != 0)
{
exfat_error("fsync failed: %s", strerror(errno));
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
}
ssize_t exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
off_t offset)
{
+#ifdef USE_UBLIO
+ return ublio_pread(dev->ufh, buffer, size, offset);
+#else
return pread(dev->fd, buffer, size, offset);
+#endif
}
ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
off_t offset)
{
+#ifdef USE_UBLIO
+ return ublio_pwrite(dev->ufh, buffer, size, offset);
+#else
return pwrite(dev->fd, buffer, size, offset);
+#endif
}
ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
return 0;
cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
- if (CLUSTER_INVALID(cluster))
+ if (CLUSTER_INVALID(*ef->sb, cluster))
{
exfat_error("invalid cluster 0x%x while reading", cluster);
- return -1;
+ return -EIO;
}
loffset = offset % CLUSTER_SIZE(*ef->sb);
remainder = MIN(size, node->size - offset);
while (remainder > 0)
{
- if (CLUSTER_INVALID(cluster))
+ if (CLUSTER_INVALID(*ef->sb, cluster))
{
exfat_error("invalid cluster 0x%x while reading", cluster);
- return -1;
+ return -EIO;
}
lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
if (exfat_pread(ef->dev, bufp, lsize,
exfat_c2o(ef, cluster) + loffset) < 0)
{
exfat_error("failed to read cluster %#x", cluster);
- return -1;
+ return -EIO;
}
bufp += lsize;
loffset = 0;
remainder -= lsize;
cluster = exfat_next_cluster(ef, node, cluster);
}
- if (!ef->ro && !ef->noatime)
+ if (!(node->attrib & EXFAT_ATTRIB_DIR) && !ef->ro && !ef->noatime)
exfat_update_atime(node);
return MIN(size, node->size - offset) - remainder;
}
ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
const void* buffer, size_t size, off_t offset)
{
+ int rc;
cluster_t cluster;
const char* bufp = buffer;
off_t lsize, loffset, remainder;
if (offset > node->size)
- if (exfat_truncate(ef, node, offset, true) != 0)
- return -1;
+ {
+ rc = exfat_truncate(ef, node, offset, true);
+ if (rc != 0)
+ return rc;
+ }
if (offset + size > node->size)
- if (exfat_truncate(ef, node, offset + size, false) != 0)
- return -1;
+ {
+ rc = exfat_truncate(ef, node, offset + size, false);
+ if (rc != 0)
+ return rc;
+ }
if (size == 0)
return 0;
cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
- if (CLUSTER_INVALID(cluster))
+ if (CLUSTER_INVALID(*ef->sb, cluster))
{
exfat_error("invalid cluster 0x%x while writing", cluster);
- return -1;
+ return -EIO;
}
loffset = offset % CLUSTER_SIZE(*ef->sb);
remainder = size;
while (remainder > 0)
{
- if (CLUSTER_INVALID(cluster))
+ if (CLUSTER_INVALID(*ef->sb, cluster))
{
exfat_error("invalid cluster 0x%x while writing", cluster);
- return -1;
+ return -EIO;
}
lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
if (exfat_pwrite(ef->dev, bufp, lsize,
exfat_c2o(ef, cluster) + loffset) < 0)
{
exfat_error("failed to write cluster %#x", cluster);
- return -1;
+ return -EIO;
}
bufp += lsize;
loffset = 0;
remainder -= lsize;
cluster = exfat_next_cluster(ef, node, cluster);
}
- exfat_update_mtime(node);
+ if (!(node->attrib & EXFAT_ATTRIB_DIR))
+ /* directory's mtime should be updated by the caller only when it
+ creates or removes something in this directory */
+ exfat_update_mtime(node);
return size - remainder;
}