From: Chih-Wei Huang Date: Thu, 23 Mar 2017 14:52:59 +0000 (+0800) Subject: Merge branch 'master' of git://github.com/relan/exfat into marshmallow-x86 X-Git-Tag: android-x86-6.0-r3 X-Git-Url: http://git.osdn.net/view?p=android-x86%2Fexternal-exfat.git;a=commitdiff_plain;h=refs%2Ftags%2Fandroid-x86-6.0-r3;hp=-c Merge branch 'master' of git://github.com/relan/exfat into marshmallow-x86 --- 49421bf5ddbb3d16000d858a0c576b65eb7a4e61 diff --combined libexfat/compiler.h index 9de2c60,e4f40de..babdbfa --- a/libexfat/compiler.h +++ b/libexfat/compiler.h @@@ -4,7 -4,7 +4,7 @@@ showstopper. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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,7 -24,7 +24,7 @@@ #ifndef COMPILER_H_INCLUDED #define COMPILER_H_INCLUDED -#if __STDC_VERSION__ < 199901L +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ < 199901L) #error C99-compliant compiler is required #endif diff --combined libexfat/exfat.h index a3b2b1a,21b760e..240cde1 --- a/libexfat/exfat.h +++ b/libexfat/exfat.h @@@ -4,7 -4,7 +4,7 @@@ implementation. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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,11 -24,7 +24,11 @@@ #ifndef EXFAT_H_INCLUDED #define EXFAT_H_INCLUDED +#if defined(__ANDROID__) +#include "android_config.h" +#else #include "config.h" +#endif #include "compiler.h" #include "exfatfs.h" #include @@@ -38,12 -34,13 +38,13 @@@ #include #include - #define EXFAT_NAME_MAX 256 - #define EXFAT_ATTRIB_CONTIGUOUS 0x10000 - #define EXFAT_ATTRIB_CACHED 0x20000 - #define EXFAT_ATTRIB_DIRTY 0x40000 - #define EXFAT_ATTRIB_UNLINKED 0x80000 - #define IS_CONTIGUOUS(node) (((node).flags & EXFAT_ATTRIB_CONTIGUOUS) != 0) + #define EXFAT_NAME_MAX 255 + /* UTF-16 encodes code points up to U+FFFF as single 16-bit code units. + UTF-8 uses up to 3 bytes (i.e. 8-bit code units) to encode code points + up to U+FFFF. One additional character is for null terminator. */ + #define EXFAT_UTF8_NAME_BUFFER_MAX (EXFAT_NAME_MAX * 3 + 1) + #define EXFAT_UTF8_ENAME_BUFFER_MAX (EXFAT_ENAME_MAX * 3 + 1) + #define SECTOR_SIZE(sb) (1 << (sb).sector_bits) #define CLUSTER_SIZE(sb) (SECTOR_SIZE(sb) << (sb).spc_bits) #define CLUSTER_INVALID(c) \ @@@ -53,7 -50,6 +54,6 @@@ #define MAX(a, b) ((a) > (b) ? (a) : (b)) #define DIV_ROUND_UP(x, d) (((x) + (d) - 1) / (d)) #define ROUND_UP(x, d) (DIV_ROUND_UP(x, d) * (d)) - #define UTF8_BYTES(c) ((c) * 6) /* UTF-8 character can occupy up to 6 bytes */ #define BMAP_SIZE(count) (ROUND_UP(count, sizeof(bitmap_t) * 8) / 8) #define BMAP_BLOCK(index) ((index) / sizeof(bitmap_t) / 8) @@@ -79,10 -75,14 +79,14 @@@ struct exfat_nod int references; uint32_t fptr_index; cluster_t fptr_cluster; - cluster_t entry_cluster; off_t entry_offset; cluster_t start_cluster; - int flags; + uint16_t attrib; + uint8_t continuations; + bool is_contiguous : 1; + bool is_cached : 1; + bool is_dirty : 1; + bool is_unlinked : 1; uint64_t size; time_t mtime, atime; le16_t name[EXFAT_NAME_MAX + 1]; @@@ -112,7 -112,7 +116,7 @@@ struct exfa bool dirty; } cmap; - char label[UTF8_BYTES(EXFAT_ENAME_MAX) + 1]; + char label[EXFAT_UTF8_ENAME_BUFFER_MAX]; void* zero_cluster; int dmask, fmask; uid_t uid; @@@ -181,18 -181,25 +185,19 @@@ int exfat_find_used_sectors(const struc void exfat_stat(const struct exfat* ef, const struct exfat_node* node, struct stat* stbuf); - void exfat_get_name(const struct exfat_node* node, char* buffer, size_t n); + void exfat_get_name(const struct exfat_node* node, + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]); uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry); uint16_t exfat_add_checksum(const void* entry, uint16_t sum); - le16_t exfat_calc_checksum(const struct exfat_entry_meta1* meta1, - const struct exfat_entry_meta2* meta2, const le16_t* name); + le16_t exfat_calc_checksum(const struct exfat_entry* entries, int n); uint32_t exfat_vbr_start_checksum(const void* sector, size_t size); uint32_t exfat_vbr_add_checksum(const void* sector, size_t size, uint32_t sum); - le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name); + le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name, + size_t length); void exfat_humanize_bytes(uint64_t value, struct exfat_human_bytes* hb); void exfat_print_info(const struct exfat_super_block* sb, uint32_t free_clusters); -int utf16_to_utf8(char* output, const le16_t* input, size_t outsize, - size_t insize); -int utf8_to_utf16(le16_t* output, const char* input, size_t outsize, - size_t insize); -size_t utf16_length(const le16_t* str); - struct exfat_node* exfat_get_node(struct exfat_node* node); void exfat_put_node(struct exfat* ef, struct exfat_node* node); int exfat_cleanup_node(struct exfat* ef, struct exfat_node* node); diff --combined libexfat/io.c index 9762aa6,514383c..6228f0a --- a/libexfat/io.c +++ b/libexfat/io.c @@@ -3,7 -3,7 +3,7 @@@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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 @@@ -251,11 -251,7 +251,11 @@@ off_t exfat_get_size(const struct exfat off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence) { +#if defined(__ANDROID__) + return lseek64(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) @@@ -271,21 -267,13 +271,21 @@@ ssize_t exfat_write(struct exfat_dev* d ssize_t exfat_pread(struct exfat_dev* dev, void* buffer, size_t size, off_t offset) { +#if defined(__ANDROID__) + return pread64(dev->fd, 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) { +#if defined(__ANDROID__) + return pwrite64(dev->fd, 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, @@@ -304,7 -292,7 +304,7 @@@ if (CLUSTER_INVALID(cluster)) { exfat_error("invalid cluster 0x%x while reading", cluster); - return -1; + return -EIO; } loffset = offset % CLUSTER_SIZE(*ef->sb); @@@ -314,21 -302,21 +314,21 @@@ if (CLUSTER_INVALID(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; } @@@ -336,16 -324,23 +336,23 @@@ 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; @@@ -353,7 -348,7 +360,7 @@@ if (CLUSTER_INVALID(cluster)) { exfat_error("invalid cluster 0x%x while writing", cluster); - return -1; + return -EIO; } loffset = offset % CLUSTER_SIZE(*ef->sb); @@@ -363,20 -358,23 +370,23 @@@ if (CLUSTER_INVALID(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; } diff --combined libexfat/log.c index 580e1cd,5d99d30..34bcb22 --- a/libexfat/log.c +++ b/libexfat/log.c @@@ -3,7 -3,7 +3,7 @@@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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 @@@ -47,11 -47,7 +47,11 @@@ void exfat_bug(const char* format, ... vsyslog(LOG_CRIT, format, aq); va_end(aq); +#if defined(__ANDROID__) + exit(-1); +#else abort(); +#endif } /* diff --combined libexfat/lookup.c index d229e11,4b27cc5..503cc4c --- a/libexfat/lookup.c +++ b/libexfat/lookup.c @@@ -3,7 -3,7 +3,7 @@@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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,7 -21,6 +21,7 @@@ */ #include "exfat.h" +#include "utf.h" #include #include #include @@@ -87,7 -86,7 +87,7 @@@ static int lookup_name(struct exfat* ef *node = NULL; - rc = utf8_to_utf16(buffer, name, EXFAT_NAME_MAX, n); + rc = utf8_to_utf16(buffer, name, EXFAT_NAME_MAX + 1, n); if (rc != 0) return rc; @@@ -195,7 -194,7 +195,7 @@@ int exfat_split(struct exfat* ef, struc exfat_put_node(ef, *parent); return -ENOENT; } - rc = utf8_to_utf16(name, p, EXFAT_NAME_MAX, n); + rc = utf8_to_utf16(name, p, EXFAT_NAME_MAX + 1, n); if (rc != 0) { exfat_put_node(ef, *parent); diff --combined libexfat/node.c index 68873a0,a3f00af..ce513fd --- a/libexfat/node.c +++ b/libexfat/node.c @@@ -3,7 -3,7 +3,7 @@@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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,19 -21,11 +21,12 @@@ */ #include "exfat.h" +#include "utf.h" #include #include #include - /* on-disk nodes iterator */ - struct iterator - { - cluster_t cluster; - off_t offset; - int contiguous; - char* chunk; - }; + #define EXFAT_ENTRY_NONE (-1) struct exfat_node* exfat_get_node(struct exfat_node* node) { @@@ -45,19 -37,19 +38,19 @@@ void exfat_put_node(struct exfat* ef, struct exfat_node* node) { - char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]; --node->references; if (node->references < 0) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_bug("reference counter of '%s' is below zero", buffer); } else if (node->references == 0 && node != ef->root) { - if (node->flags & EXFAT_ATTRIB_DIRTY) + if (node->is_dirty) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_warn("dirty node '%s' with zero references", buffer); } } @@@ -75,7 -67,7 +68,7 @@@ int exfat_cleanup_node(struct exfat* ef exfat_bug("unable to cleanup a node with %d references", node->references); - if (node->flags & EXFAT_ATTRIB_UNLINKED) + if (node->is_unlinked) { /* free all clusters and node structure itself */ rc = exfat_truncate(ef, node, 0, true); @@@ -85,74 -77,44 +78,44 @@@ return rc; } - /** - * Cluster + offset from the beginning of the directory to absolute offset. - */ - static off_t co2o(struct exfat* ef, cluster_t cluster, off_t offset) + static int read_entries(struct exfat* ef, struct exfat_node* dir, + struct exfat_entry* entries, int n, off_t offset) { - return exfat_c2o(ef, cluster) + offset % CLUSTER_SIZE(*ef->sb); - } - - static int opendir(struct exfat* ef, const struct exfat_node* dir, - struct iterator* it) - { - if (!(dir->flags & EXFAT_ATTRIB_DIR)) - exfat_bug("not a directory"); - it->cluster = dir->start_cluster; - it->offset = 0; - it->contiguous = IS_CONTIGUOUS(*dir); - it->chunk = malloc(CLUSTER_SIZE(*ef->sb)); - if (it->chunk == NULL) - { - exfat_error("out of memory"); - return -ENOMEM; - } - if (exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb), - exfat_c2o(ef, it->cluster)) < 0) - { - exfat_error("failed to read directory cluster %#x", it->cluster); + ssize_t size; + + if (!(dir->attrib & EXFAT_ATTRIB_DIR)) + exfat_bug("attempted to read entries from a file"); + + size = exfat_generic_pread(ef, dir, entries, + sizeof(struct exfat_entry[n]), offset); + if (size == sizeof(struct exfat_entry[n])) + return 0; /* success */ + if (size == 0) + return -ENOENT; + if (size < 0) return -EIO; - } - return 0; + exfat_error("read %zd bytes instead of %zu bytes", size, + sizeof(struct exfat_entry[n])); + return -EIO; } - static void closedir(struct iterator* it) + static int write_entries(struct exfat* ef, struct exfat_node* dir, + const struct exfat_entry* entries, int n, off_t offset) { - it->cluster = 0; - it->offset = 0; - it->contiguous = 0; - free(it->chunk); - it->chunk = NULL; - } + ssize_t size; - static bool fetch_next_entry(struct exfat* ef, const struct exfat_node* parent, - struct iterator* it) - { - /* move iterator to the next entry in the directory */ - it->offset += sizeof(struct exfat_entry); - /* fetch the next cluster if needed */ - if ((it->offset & (CLUSTER_SIZE(*ef->sb) - 1)) == 0) - { - /* reached the end of directory; the caller should check this - condition too */ - if (it->offset >= parent->size) - return true; - it->cluster = exfat_next_cluster(ef, parent, it->cluster); - if (CLUSTER_INVALID(it->cluster)) - { - exfat_error("invalid cluster 0x%x while reading directory", - it->cluster); - return false; - } - if (exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb), - exfat_c2o(ef, it->cluster)) < 0) - { - exfat_error("failed to read the next directory cluster %#x", - it->cluster); - return false; - } - } - return true; + if (!(dir->attrib & EXFAT_ATTRIB_DIR)) + exfat_bug("attempted to write entries into a file"); + + size = exfat_generic_pwrite(ef, dir, entries, + sizeof(struct exfat_entry[n]), offset); + if (size == sizeof(struct exfat_entry[n])) + return 0; /* success */ + if (size < 0) + return -EIO; + exfat_error("wrote %zd bytes instead of %zu bytes", size, + sizeof(struct exfat_entry[n])); + return -EIO; } static struct exfat_node* allocate_node(void) @@@ -170,7 -132,8 +133,8 @@@ static void init_node_meta1(struct exfat_node* node, const struct exfat_entry_meta1* meta1) { - node->flags = le16_to_cpu(meta1->attrib); + node->attrib = le16_to_cpu(meta1->attrib); + node->continuations = meta1->continuations; node->mtime = exfat_exfat2unix(meta1->mdate, meta1->mtime, meta1->mtime_cs); /* there is no centiseconds field for atime */ @@@ -183,32 -146,81 +147,81 @@@ static void init_node_meta2(struct exfa node->size = le64_to_cpu(meta2->size); node->start_cluster = le32_to_cpu(meta2->start_cluster); node->fptr_cluster = node->start_cluster; - if (meta2->flags & EXFAT_FLAG_CONTIGUOUS) - node->flags |= EXFAT_ATTRIB_CONTIGUOUS; + node->is_contiguous = ((meta2->flags & EXFAT_FLAG_CONTIGUOUS) != 0); } - static const struct exfat_entry* get_entry_ptr(const struct exfat* ef, - const struct iterator* it) + static void init_node_name(struct exfat_node* node, + const struct exfat_entry* entries, int n) { - return (const struct exfat_entry*) - (it->chunk + it->offset % CLUSTER_SIZE(*ef->sb)); + int i; + + for (i = 0; i < n; i++) + memcpy(node->name + i * EXFAT_ENAME_MAX, + ((const struct exfat_entry_name*) &entries[i])->name, + EXFAT_ENAME_MAX * sizeof(le16_t)); } - static bool check_node(const struct exfat_node* node, uint16_t actual_checksum, - uint16_t reference_checksum, uint64_t valid_size) + static bool check_entries(const struct exfat_entry* entry, int n) { - char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + int previous = EXFAT_ENTRY_NONE; + int current; + int i; + + /* check transitions between entries types */ + for (i = 0; i < n + 1; previous = current, i++) + { + bool valid = false; + + current = (i < n) ? entry[i].type : EXFAT_ENTRY_NONE; + switch (previous) + { + case EXFAT_ENTRY_NONE: + valid = (current == EXFAT_ENTRY_FILE); + break; + case EXFAT_ENTRY_FILE: + valid = (current == EXFAT_ENTRY_FILE_INFO); + break; + case EXFAT_ENTRY_FILE_INFO: + valid = (current == EXFAT_ENTRY_FILE_NAME); + break; + case EXFAT_ENTRY_FILE_NAME: + valid = (current == EXFAT_ENTRY_FILE_NAME || + current == EXFAT_ENTRY_NONE || + current >= EXFAT_ENTRY_FILE_TAIL); + break; + case EXFAT_ENTRY_FILE_TAIL ... 0xff: + valid = (current >= EXFAT_ENTRY_FILE_TAIL || + current == EXFAT_ENTRY_NONE); + break; + } + + if (!valid) + { + exfat_error("unexpected entry type %#x after %#x at %d/%d", + current, previous, i, n); + return false; + } + } + return true; + } + + static bool check_node(const struct exfat_node* node, le16_t actual_checksum, + int cluster_size, const struct exfat_entry_meta1* meta1, + const struct exfat_entry_meta2* meta2) + { + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]; + bool ret = true; /* Validate checksum first. If it's invalid all other fields probably contain just garbage. */ - if (actual_checksum != reference_checksum) + if (le16_to_cpu(actual_checksum) != le16_to_cpu(meta1->checksum)) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_error("'%s' has invalid checksum (%#hx != %#hx)", buffer, - actual_checksum, reference_checksum); - return false; + le16_to_cpu(actual_checksum), le16_to_cpu(meta1->checksum)); + ret = false; } /* @@@ -217,15 -229,123 +230,123 @@@ cannot be greater than file size. See SetFileValidData() function description in MSDN. */ - if (valid_size > node->size) + if (le64_to_cpu(meta2->valid_size) > node->size) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_error("'%s' has valid size (%"PRIu64") greater than size " - "(%"PRIu64")", buffer, valid_size, node->size); - return false; + "(%"PRIu64")", buffer, le64_to_cpu(meta2->valid_size), + node->size); + ret = false; } - return true; + /* + Empty file must have zero start cluster. Non-empty file must start + with a valid cluster. Directories cannot be empty (i.e. must always + have a valid start cluster), but we will check this later while + reading that directory to give user a chance to read this directory. + */ + if (node->size == 0 && node->start_cluster != EXFAT_CLUSTER_FREE) + { + exfat_get_name(node, buffer); + exfat_error("'%s' is empty but start cluster is %#x", buffer, + node->start_cluster); + ret = false; + } + if (node->size > 0 && CLUSTER_INVALID(node->start_cluster)) + { + exfat_get_name(node, buffer); + exfat_error("'%s' points to invalid cluster %#x", buffer, + node->start_cluster); + ret = false; + } + + /* Empty file or directory must be marked as non-contiguous. */ + if (node->size == 0 && node->is_contiguous) + { + exfat_get_name(node, buffer); + exfat_error("'%s' is empty but marked as contiguous (%#hx)", buffer, + node->attrib); + ret = false; + } + + /* Directory size must be aligned on at cluster boundary. */ + if ((node->attrib & EXFAT_ATTRIB_DIR) && node->size % cluster_size != 0) + { + exfat_get_name(node, buffer); + exfat_error("'%s' directory size %"PRIu64" is not divisible by %d", buffer, + node->size, cluster_size); + ret = false; + } + + return ret; + } + + static int parse_file_entries(struct exfat* ef, struct exfat_node* parent, + struct exfat_node* node, const struct exfat_entry* entries, int n) + { + const struct exfat_entry_meta1* meta1; + const struct exfat_entry_meta2* meta2; + int mandatory_entries; + + if (!check_entries(entries, n)) + return -EIO; + + meta1 = (const struct exfat_entry_meta1*) &entries[0]; + if (meta1->continuations < 2) + { + exfat_error("too few continuations (%hhu)", meta1->continuations); + return -EIO; + } + meta2 = (const struct exfat_entry_meta2*) &entries[1]; + if (meta2->flags & ~(EXFAT_FLAG_ALWAYS1 | EXFAT_FLAG_CONTIGUOUS)) + { + exfat_error("unknown flags in meta2 (%#hhx)", meta2->flags); + return -EIO; + } + mandatory_entries = 2 + DIV_ROUND_UP(meta2->name_length, EXFAT_ENAME_MAX); + if (meta1->continuations < mandatory_entries - 1) + { + exfat_error("too few continuations (%hhu < %d)", + meta1->continuations, mandatory_entries - 1); + return -EIO; + } + + init_node_meta1(node, meta1); + init_node_meta2(node, meta2); + init_node_name(node, entries + 2, mandatory_entries - 2); + + if (!check_node(node, exfat_calc_checksum(entries, n), + CLUSTER_SIZE(*ef->sb), meta1, meta2)) + return -EIO; + + return 0; + } + + static int parse_file_entry(struct exfat* ef, struct exfat_node* parent, + struct exfat_node** node, off_t* offset, int n) + { + struct exfat_entry entries[n]; + int rc; + + rc = read_entries(ef, parent, entries, n, *offset); + if (rc != 0) + return rc; + + /* a new node has zero references */ + *node = allocate_node(); + if (*node == NULL) + return -ENOMEM; + (*node)->entry_offset = *offset; + + rc = parse_file_entries(ef, parent, *node, entries, n); + if (rc != 0) + { + free(*node); + return rc; + } + + *offset += sizeof(struct exfat_entry[n]); + return 0; } static void decompress_upcase(uint16_t* output, const le16_t* source, @@@ -249,150 -369,43 +370,43 @@@ } /* - * Reads one entry in directory at position pointed by iterator and fills - * node structure. + * Read one entry in a directory at offset position and build a new node + * structure. */ - static int readdir(struct exfat* ef, const struct exfat_node* parent, - struct exfat_node** node, struct iterator* it) + static int readdir(struct exfat* ef, struct exfat_node* parent, + struct exfat_node** node, off_t* offset) { - int rc = -EIO; - const struct exfat_entry* entry; + int rc; + struct exfat_entry entry; const struct exfat_entry_meta1* meta1; - const struct exfat_entry_meta2* meta2; - const struct exfat_entry_name* file_name; const struct exfat_entry_upcase* upcase; const struct exfat_entry_bitmap* bitmap; const struct exfat_entry_label* label; - uint8_t continuations = 0; - le16_t* namep = NULL; - uint16_t reference_checksum = 0; - uint16_t actual_checksum = 0; - uint64_t valid_size = 0; uint64_t upcase_size = 0; le16_t* upcase_comp = NULL; - *node = NULL; - for (;;) { - if (it->offset >= parent->size) - { - if (continuations != 0) - { - exfat_error("expected %hhu continuations", continuations); - goto error; - } - return -ENOENT; /* that's OK, means end of directory */ - } + rc = read_entries(ef, parent, &entry, 1, *offset); + if (rc != 0) + return rc; - entry = get_entry_ptr(ef, it); - switch (entry->type) + switch (entry.type) { case EXFAT_ENTRY_FILE: - if (continuations != 0) - { - exfat_error("expected %hhu continuations before new entry", - continuations); - goto error; - } - meta1 = (const struct exfat_entry_meta1*) entry; - continuations = meta1->continuations; - /* each file entry must have at least 2 continuations: - info and name */ - if (continuations < 2) - { - exfat_error("too few continuations (%hhu)", continuations); - goto error; - } - if (continuations > 1 + - DIV_ROUND_UP(EXFAT_NAME_MAX, EXFAT_ENAME_MAX)) - { - exfat_error("too many continuations (%hhu)", continuations); - goto error; - } - reference_checksum = le16_to_cpu(meta1->checksum); - actual_checksum = exfat_start_checksum(meta1); - *node = allocate_node(); - if (*node == NULL) - { - rc = -ENOMEM; - goto error; - } - /* new node has zero reference counter */ - (*node)->entry_cluster = it->cluster; - (*node)->entry_offset = it->offset; - init_node_meta1(*node, meta1); - namep = (*node)->name; - break; - - case EXFAT_ENTRY_FILE_INFO: - if (continuations < 2) - { - exfat_error("unexpected continuation (%hhu)", - continuations); - goto error; - } - meta2 = (const struct exfat_entry_meta2*) entry; - if (meta2->flags & ~(EXFAT_FLAG_ALWAYS1 | EXFAT_FLAG_CONTIGUOUS)) - { - exfat_error("unknown flags in meta2 (0x%hhx)", meta2->flags); - goto error; - } - init_node_meta2(*node, meta2); - actual_checksum = exfat_add_checksum(entry, actual_checksum); - valid_size = le64_to_cpu(meta2->valid_size); - /* empty files must be marked as non-contiguous */ - if ((*node)->size == 0 && (meta2->flags & EXFAT_FLAG_CONTIGUOUS)) - { - exfat_error("empty file marked as contiguous (0x%hhx)", - meta2->flags); - goto error; - } - /* directories must be aligned on at cluster boundary */ - if (((*node)->flags & EXFAT_ATTRIB_DIR) && - (*node)->size % CLUSTER_SIZE(*ef->sb) != 0) - { - exfat_error("directory has invalid size %"PRIu64" bytes", - (*node)->size); - goto error; - } - --continuations; - break; - - case EXFAT_ENTRY_FILE_NAME: - if (continuations == 0) - { - exfat_error("unexpected continuation"); - goto error; - } - file_name = (const struct exfat_entry_name*) entry; - actual_checksum = exfat_add_checksum(entry, actual_checksum); - - memcpy(namep, file_name->name, - MIN(EXFAT_ENAME_MAX, - ((*node)->name + EXFAT_NAME_MAX - namep)) * - sizeof(le16_t)); - namep += EXFAT_ENAME_MAX; - if (--continuations == 0) - { - if (!check_node(*node, actual_checksum, reference_checksum, - valid_size)) - goto error; - if (!fetch_next_entry(ef, parent, it)) - goto error; - return 0; /* entry completed */ - } - break; + meta1 = (const struct exfat_entry_meta1*) &entry; + return parse_file_entry(ef, parent, node, offset, + 1 + meta1->continuations); case EXFAT_ENTRY_UPCASE: if (ef->upcase != NULL) break; - upcase = (const struct exfat_entry_upcase*) entry; + upcase = (const struct exfat_entry_upcase*) &entry; if (CLUSTER_INVALID(le32_to_cpu(upcase->start_cluster))) { exfat_error("invalid cluster 0x%x in upcase table", le32_to_cpu(upcase->start_cluster)); - goto error; + return -EIO; } upcase_size = le64_to_cpu(upcase->size); if (upcase_size == 0 || @@@ -401,15 -414,14 +415,14 @@@ { exfat_error("bad upcase table size (%"PRIu64" bytes)", upcase_size); - goto error; + return -EIO; } upcase_comp = malloc(upcase_size); if (upcase_comp == NULL) { exfat_error("failed to allocate upcase table (%"PRIu64" bytes)", upcase_size); - rc = -ENOMEM; - goto error; + return -ENOMEM; } /* read compressed upcase table */ @@@ -421,7 -433,7 +434,7 @@@ "(%"PRIu64" bytes starting at cluster %#x)", upcase_size, le32_to_cpu(upcase->start_cluster)); - goto error; + return -EIO; } /* decompress upcase table */ @@@ -430,8 -442,7 +443,7 @@@ { free(upcase_comp); exfat_error("failed to allocate decompressed upcase table"); - rc = -ENOMEM; - goto error; + return -ENOMEM; } decompress_upcase(ef->upcase, upcase_comp, upcase_size / sizeof(uint16_t)); @@@ -439,13 -450,13 +451,13 @@@ break; case EXFAT_ENTRY_BITMAP: - bitmap = (const struct exfat_entry_bitmap*) entry; + bitmap = (const struct exfat_entry_bitmap*) &entry; ef->cmap.start_cluster = le32_to_cpu(bitmap->start_cluster); if (CLUSTER_INVALID(ef->cmap.start_cluster)) { exfat_error("invalid cluster 0x%x in clusters bitmap", ef->cmap.start_cluster); - goto error; + return -EIO; } ef->cmap.size = le32_to_cpu(ef->sb->cluster_count) - EXFAT_FIRST_DATA_CLUSTER; @@@ -455,7 -466,7 +467,7 @@@ " (expected at least %u)", le64_to_cpu(bitmap->size), DIV_ROUND_UP(ef->cmap.size, 8)); - goto error; + return -EIO; } /* FIXME bitmap can be rather big, up to 512 MB */ ef->cmap.chunk_size = ef->cmap.size; @@@ -464,8 -475,7 +476,7 @@@ { exfat_error("failed to allocate clusters bitmap chunk " "(%"PRIu64" bytes)", le64_to_cpu(bitmap->size)); - rc = -ENOMEM; - goto error; + return -ENOMEM; } if (exfat_pread(ef->dev, ef->cmap.chunk, @@@ -475,66 -485,45 +486,45 @@@ exfat_error("failed to read clusters bitmap " "(%"PRIu64" bytes starting at cluster %#x)", le64_to_cpu(bitmap->size), ef->cmap.start_cluster); - goto error; + return -EIO; } break; case EXFAT_ENTRY_LABEL: - label = (const struct exfat_entry_label*) entry; + label = (const struct exfat_entry_label*) &entry; if (label->length > EXFAT_ENAME_MAX) { exfat_error("too long label (%hhu chars)", label->length); - goto error; + return -EIO; } if (utf16_to_utf8(ef->label, label->name, - sizeof(ef->label) - 1, EXFAT_ENAME_MAX) != 0) - goto error; + sizeof(ef->label), EXFAT_ENAME_MAX) != 0) + return -EIO; break; default: - if (!(entry->type & EXFAT_ENTRY_VALID)) + if (!(entry.type & EXFAT_ENTRY_VALID)) break; /* deleted entry, ignore it */ - if (!(entry->type & EXFAT_ENTRY_OPTIONAL)) - { - exfat_error("unknown entry type %#hhx", entry->type); - goto error; - } - /* optional entry, warn and skip */ - exfat_warn("unknown entry type %#hhx", entry->type); - if (continuations == 0) - { - exfat_error("unexpected continuation"); - goto error; - } - --continuations; - break; - } - if (!fetch_next_entry(ef, parent, it)) - goto error; + exfat_error("unknown entry type %#hhx", entry.type); + return -EIO; + } + *offset += sizeof(entry); } /* we never reach here */ - - error: - free(*node); - *node = NULL; - return rc; } int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir) { - struct iterator it; + off_t offset = 0; int rc; struct exfat_node* node; struct exfat_node* current = NULL; - if (dir->flags & EXFAT_ATTRIB_CACHED) + if (dir->is_cached) return 0; /* already cached */ - rc = opendir(ef, dir, &it); - if (rc != 0) - return rc; - while ((rc = readdir(ef, dir, &node, &it)) == 0) + while ((rc = readdir(ef, dir, &node, &offset)) == 0) { node->parent = dir; if (current != NULL) @@@ -547,7 -536,6 +537,6 @@@ current = node; } - closedir(&it); if (rc != -ENOENT) { @@@ -561,7 -549,7 +550,7 @@@ return rc; } - dir->flags |= EXFAT_ATTRIB_CACHED; + dir->is_cached = true; return 0; } @@@ -591,7 -579,7 +580,7 @@@ static void tree_detach(struct exfat_no static void reset_cache(struct exfat* ef, struct exfat_node* node) { - char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]; while (node->child) { @@@ -600,16 -588,16 +589,16 @@@ tree_detach(p); free(p); } - node->flags &= ~EXFAT_ATTRIB_CACHED; + node->is_cached = false; if (node->references != 0) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_warn("non-zero reference counter (%d) for '%s'", node->references, buffer); } - if (node != ef->root && (node->flags & EXFAT_ATTRIB_DIRTY)) + if (node != ef->root && node->is_dirty) { - exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_get_name(node, buffer); exfat_bug("node '%s' is dirty", buffer); } while (node->references) @@@ -621,32 -609,14 +610,14 @@@ void exfat_reset_cache(struct exfat* ef reset_cache(ef, ef->root); } - static bool next_entry(struct exfat* ef, const struct exfat_node* parent, - cluster_t* cluster, off_t* offset) - { - *offset += sizeof(struct exfat_entry); - if (*offset % CLUSTER_SIZE(*ef->sb) == 0) - { - *cluster = exfat_next_cluster(ef, parent, *cluster); - if (CLUSTER_INVALID(*cluster)) - { - exfat_error("invalid cluster %#x while getting next entry", - *cluster); - return false; - } - } - return true; - } - int exfat_flush_node(struct exfat* ef, struct exfat_node* node) { - cluster_t cluster; - off_t offset; - off_t meta1_offset, meta2_offset; - struct exfat_entry_meta1 meta1; - struct exfat_entry_meta2 meta2; + struct exfat_entry entries[1 + node->continuations]; + struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0]; + struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1]; + int rc; - if (!(node->flags & EXFAT_ATTRIB_DIRTY)) + if (!node->is_dirty) return 0; /* no need to flush */ if (ef->ro) @@@ -655,92 -625,65 +626,65 @@@ if (node->parent == NULL) return 0; /* do not flush unlinked node */ - cluster = node->entry_cluster; - offset = node->entry_offset; - meta1_offset = co2o(ef, cluster, offset); - if (!next_entry(ef, node->parent, &cluster, &offset)) - return -EIO; - meta2_offset = co2o(ef, cluster, offset); - - if (exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0) - { - exfat_error("failed to read meta1 entry on flush"); + rc = read_entries(ef, node->parent, entries, 1 + node->continuations, + node->entry_offset); + if (rc != 0) + return rc; + if (!check_entries(entries, 1 + node->continuations)) return -EIO; - } - if (meta1.type != EXFAT_ENTRY_FILE) - exfat_bug("invalid type of meta1: 0x%hhx", meta1.type); - meta1.attrib = cpu_to_le16(node->flags); - exfat_unix2exfat(node->mtime, &meta1.mdate, &meta1.mtime, &meta1.mtime_cs); - exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL); - if (exfat_pread(ef->dev, &meta2, sizeof(meta2), meta2_offset) < 0) - { - exfat_error("failed to read meta2 entry on flush"); - return -EIO; - } - if (meta2.type != EXFAT_ENTRY_FILE_INFO) - exfat_bug("invalid type of meta2: 0x%hhx", meta2.type); - meta2.size = meta2.valid_size = cpu_to_le64(node->size); - meta2.start_cluster = cpu_to_le32(node->start_cluster); - meta2.flags = EXFAT_FLAG_ALWAYS1; + meta1->attrib = cpu_to_le16(node->attrib); + exfat_unix2exfat(node->mtime, &meta1->mdate, &meta1->mtime, + &meta1->mtime_cs); + exfat_unix2exfat(node->atime, &meta1->adate, &meta1->atime, NULL); + meta2->size = meta2->valid_size = cpu_to_le64(node->size); + meta2->start_cluster = cpu_to_le32(node->start_cluster); + meta2->flags = EXFAT_FLAG_ALWAYS1; /* empty files must not be marked as contiguous */ - if (node->size != 0 && IS_CONTIGUOUS(*node)) - meta2.flags |= EXFAT_FLAG_CONTIGUOUS; + if (node->size != 0 && node->is_contiguous) + meta2->flags |= EXFAT_FLAG_CONTIGUOUS; /* name hash remains unchanged, no need to recalculate it */ - meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name); - - if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0) - { - exfat_error("failed to write meta1 entry on flush"); - return -EIO; - } - if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2), meta2_offset) < 0) - { - exfat_error("failed to write meta2 entry on flush"); - return -EIO; - } + meta1->checksum = exfat_calc_checksum(entries, 1 + node->continuations); + rc = write_entries(ef, node->parent, entries, 1 + node->continuations, + node->entry_offset); + if (rc != 0) + return rc; - node->flags &= ~EXFAT_ATTRIB_DIRTY; + node->is_dirty = false; return exfat_flush(ef); } - static bool erase_entry(struct exfat* ef, struct exfat_node* node) + static int erase_entries(struct exfat* ef, struct exfat_node* dir, int n, + off_t offset) { - cluster_t cluster = node->entry_cluster; - off_t offset = node->entry_offset; - int name_entries = DIV_ROUND_UP(utf16_length(node->name), EXFAT_ENAME_MAX); - uint8_t entry_type; + struct exfat_entry entries[n]; + int rc; + int i; - entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID; - if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to erase meta1 entry"); - return false; - } + rc = read_entries(ef, dir, entries, n, offset); + if (rc != 0) + return rc; + for (i = 0; i < n; i++) + entries[i].type &= ~EXFAT_ENTRY_VALID; + return write_entries(ef, dir, entries, n, offset); + } - if (!next_entry(ef, node->parent, &cluster, &offset)) - return false; - entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID; - if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to erase meta2 entry"); - return false; - } + static int erase_node(struct exfat* ef, struct exfat_node* node) + { + int rc; - while (name_entries--) + exfat_get_node(node->parent); + rc = erase_entries(ef, node->parent, 1 + node->continuations, + node->entry_offset); + if (rc != 0) { - if (!next_entry(ef, node->parent, &cluster, &offset)) - return false; - entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID; - if (exfat_pwrite(ef->dev, &entry_type, 1, - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to erase name entry"); - return false; - } + exfat_put_node(ef, node->parent); + return rc; } - return true; + rc = exfat_flush_node(ef, node->parent); + exfat_put_node(ef, node->parent); + return rc; } static int shrink_directory(struct exfat* ef, struct exfat_node* dir, @@@ -751,9 -694,9 +695,9 @@@ uint64_t entries = 0; uint64_t new_size; - if (!(dir->flags & EXFAT_ATTRIB_DIR)) + if (!(dir->attrib & EXFAT_ATTRIB_DIR)) exfat_bug("attempted to shrink a file"); - if (!(dir->flags & EXFAT_ATTRIB_CACHED)) + if (!dir->is_cached) exfat_bug("attempted to shrink uncached directory"); for (last_node = node = dir->child; node; node = node->next) @@@ -795,21 -738,22 +739,22 @@@ static int delete(struct exfat* ef, str int rc; exfat_get_node(parent); - if (!erase_entry(ef, node)) + rc = erase_node(ef, node); + if (rc != 0) { exfat_put_node(ef, parent); - return -EIO; + return rc; } - exfat_update_mtime(parent); tree_detach(node); rc = shrink_directory(ef, parent, deleted_offset); - node->flags |= EXFAT_ATTRIB_UNLINKED; + node->is_unlinked = true; if (rc != 0) { exfat_flush_node(ef, parent); exfat_put_node(ef, parent); return rc; } + exfat_update_mtime(parent); rc = exfat_flush_node(ef, parent); exfat_put_node(ef, parent); return rc; @@@ -817,7 -761,7 +762,7 @@@ int exfat_unlink(struct exfat* ef, struct exfat_node* node) { - if (node->flags & EXFAT_ATTRIB_DIR) + if (node->attrib & EXFAT_ATTRIB_DIR) return -EISDIR; return delete(ef, node); } @@@ -826,7 -770,7 +771,7 @@@ int exfat_rmdir(struct exfat* ef, struc { int rc; - if (!(node->flags & EXFAT_ATTRIB_DIR)) + if (!(node->attrib & EXFAT_ATTRIB_DIR)) return -ENOTDIR; /* check that directory is empty */ rc = exfat_cache_directory(ef, node); @@@ -837,130 -781,143 +782,143 @@@ return delete(ef, node); } - static int grow_directory(struct exfat* ef, struct exfat_node* dir, - uint64_t asize, uint32_t difference) + static int check_slot(struct exfat* ef, struct exfat_node* dir, off_t offset, + int n) { - return exfat_truncate(ef, dir, - DIV_ROUND_UP(asize + difference, CLUSTER_SIZE(*ef->sb)) - * CLUSTER_SIZE(*ef->sb), true); + struct exfat_entry entries[n]; + int rc; + size_t i; + + /* Root directory contains entries, that don't have any nodes associated + with them (clusters bitmap, upper case table, label). We need to be + careful not to overwrite them. */ + if (dir != ef->root) + return 0; + + rc = read_entries(ef, dir, entries, n, offset); + if (rc != 0) + return rc; + for (i = 0; i < n; i++) + if (entries[i].type & EXFAT_ENTRY_VALID) + return -EINVAL; + return 0; } static int find_slot(struct exfat* ef, struct exfat_node* dir, - cluster_t* cluster, off_t* offset, int subentries) + off_t* offset, int n) { - struct iterator it; - int rc; - const struct exfat_entry* entry; + bitmap_t* dmap; + struct exfat_node* p; + size_t i; int contiguous = 0; - rc = opendir(ef, dir, &it); - if (rc != 0) - return rc; - for (;;) + if (!dir->is_cached) + exfat_bug("directory is not cached"); + + /* build a bitmap of valid entries in the directory */ + dmap = calloc(BMAP_SIZE(dir->size / sizeof(struct exfat_entry)), + sizeof(bitmap_t)); + if (dmap == NULL) + { + exfat_error("failed to allocate directory bitmap (%"PRIu64")", + dir->size / sizeof(struct exfat_entry)); + return -ENOMEM; + } + for (p = dir->child; p != NULL; p = p->next) + for (i = 0; i < 1 + p->continuations; i++) + BMAP_SET(dmap, p->entry_offset / sizeof(struct exfat_entry) + i); + + /* find a slot in the directory entries bitmap */ + for (i = 0; i < dir->size / sizeof(struct exfat_entry); i++) { - if (contiguous == 0) + if (BMAP_GET(dmap, i) == 0) { - *cluster = it.cluster; - *offset = it.offset; + if (contiguous++ == 0) + *offset = (off_t) i * sizeof(struct exfat_entry); + if (contiguous == n) + /* suitable slot is found, check that it's not occupied */ + switch (check_slot(ef, dir, *offset, n)) + { + case 0: + free(dmap); + return 0; + case -EIO: + free(dmap); + return -EIO; + case -EINVAL: + /* slot is occupied, continue searching */ + contiguous = 0; + break; + } } - entry = get_entry_ptr(ef, &it); - if (entry->type & EXFAT_ENTRY_VALID) - contiguous = 0; else - contiguous++; - if (contiguous == subentries) - break; /* suitable slot is found */ - if (it.offset + sizeof(struct exfat_entry) >= dir->size) - { - rc = grow_directory(ef, dir, dir->size, - (subentries - contiguous) * sizeof(struct exfat_entry)); - if (rc != 0) - { - closedir(&it); - return rc; - } - } - if (!fetch_next_entry(ef, dir, &it)) - { - closedir(&it); - return -EIO; - } + contiguous = 0; } - closedir(&it); - return 0; + free(dmap); + + /* no suitable slots found, extend the directory */ + if (contiguous == 0) + *offset = dir->size; + return exfat_truncate(ef, dir, + ROUND_UP(dir->size + sizeof(struct exfat_entry[n - contiguous]), + CLUSTER_SIZE(*ef->sb)), + true); } - static int write_entry(struct exfat* ef, struct exfat_node* dir, + static int commit_entry(struct exfat* ef, struct exfat_node* dir, const le16_t* name, cluster_t cluster, off_t offset, uint16_t attrib) { struct exfat_node* node; - struct exfat_entry_meta1 meta1; - struct exfat_entry_meta2 meta2; const size_t name_length = utf16_length(name); const int name_entries = DIV_ROUND_UP(name_length, EXFAT_ENAME_MAX); + struct exfat_entry entries[2 + name_entries]; + struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0]; + struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1]; int i; + int rc; - node = allocate_node(); - if (node == NULL) - return -ENOMEM; - node->entry_cluster = cluster; - node->entry_offset = offset; - memcpy(node->name, name, name_length * sizeof(le16_t)); + memset(entries, 0, sizeof(struct exfat_entry[2])); + + meta1->type = EXFAT_ENTRY_FILE; + meta1->continuations = 1 + name_entries; + meta1->attrib = cpu_to_le16(attrib); + exfat_unix2exfat(time(NULL), &meta1->crdate, &meta1->crtime, + &meta1->crtime_cs); + meta1->adate = meta1->mdate = meta1->crdate; + meta1->atime = meta1->mtime = meta1->crtime; + meta1->mtime_cs = meta1->crtime_cs; /* there is no atime_cs */ + + meta2->type = EXFAT_ENTRY_FILE_INFO; + meta2->flags = EXFAT_FLAG_ALWAYS1; + meta2->name_length = name_length; + meta2->name_hash = exfat_calc_name_hash(ef, name, name_length); + meta2->start_cluster = cpu_to_le32(EXFAT_CLUSTER_FREE); - memset(&meta1, 0, sizeof(meta1)); - meta1.type = EXFAT_ENTRY_FILE; - meta1.continuations = 1 + name_entries; - meta1.attrib = cpu_to_le16(attrib); - exfat_unix2exfat(time(NULL), &meta1.crdate, &meta1.crtime, - &meta1.crtime_cs); - meta1.adate = meta1.mdate = meta1.crdate; - meta1.atime = meta1.mtime = meta1.crtime; - meta1.mtime_cs = meta1.crtime_cs; /* there is no atime_cs */ - - memset(&meta2, 0, sizeof(meta2)); - meta2.type = EXFAT_ENTRY_FILE_INFO; - meta2.flags = EXFAT_FLAG_ALWAYS1; - meta2.name_length = name_length; - meta2.name_hash = exfat_calc_name_hash(ef, node->name); - meta2.start_cluster = cpu_to_le32(EXFAT_CLUSTER_FREE); - - meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name); - - if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1), - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to write meta1 entry"); - return -EIO; - } - if (!next_entry(ef, dir, &cluster, &offset)) - return -EIO; - if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2), - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to write meta2 entry"); - return -EIO; - } for (i = 0; i < name_entries; i++) { - struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0}; - memcpy(name_entry.name, node->name + i * EXFAT_ENAME_MAX, - MIN(EXFAT_ENAME_MAX, EXFAT_NAME_MAX - i * EXFAT_ENAME_MAX) * - sizeof(le16_t)); - if (!next_entry(ef, dir, &cluster, &offset)) - return -EIO; - if (exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry), - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to write name entry"); - return -EIO; - } + struct exfat_entry_name* name_entry; + + name_entry = (struct exfat_entry_name*) &entries[2 + i]; + name_entry->type = EXFAT_ENTRY_FILE_NAME; + name_entry->__unknown = 0; + memcpy(name_entry->name, name + i * EXFAT_ENAME_MAX, + EXFAT_ENAME_MAX * sizeof(le16_t)); } - init_node_meta1(node, &meta1); - init_node_meta2(node, &meta2); + meta1->checksum = exfat_calc_checksum(entries, 2 + name_entries); + rc = write_entries(ef, dir, entries, 2 + name_entries, offset); + if (rc != 0) + return rc; + + node = allocate_node(); + if (node == NULL) + return -ENOMEM; + node->entry_offset = offset; + memcpy(node->name, name, name_length * sizeof(le16_t)); + init_node_meta1(node, meta1); + init_node_meta2(node, meta2); tree_attach(dir, node); - exfat_update_mtime(dir); return 0; } @@@ -983,19 -940,20 +941,20 @@@ static int create(struct exfat* ef, con return -EEXIST; } - rc = find_slot(ef, dir, &cluster, &offset, + rc = find_slot(ef, dir, &offset, 2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX)); if (rc != 0) { exfat_put_node(ef, dir); return rc; } - rc = write_entry(ef, dir, name, cluster, offset, attrib); + rc = commit_entry(ef, dir, name, cluster, offset, attrib); if (rc != 0) { exfat_put_node(ef, dir); return rc; } + exfat_update_mtime(dir); rc = exfat_flush_node(ef, dir); exfat_put_node(ef, dir); return rc; @@@ -1040,69 -998,45 +999,45 @@@ static int rename_entry(struct exfat* e struct exfat_node* node, const le16_t* name, cluster_t new_cluster, off_t new_offset) { - struct exfat_entry_meta1 meta1; - struct exfat_entry_meta2 meta2; - cluster_t old_cluster = node->entry_cluster; - off_t old_offset = node->entry_offset; const size_t name_length = utf16_length(name); const int name_entries = DIV_ROUND_UP(name_length, EXFAT_ENAME_MAX); + struct exfat_entry entries[2 + name_entries]; + struct exfat_entry_meta1* meta1 = (struct exfat_entry_meta1*) &entries[0]; + struct exfat_entry_meta2* meta2 = (struct exfat_entry_meta2*) &entries[1]; + int rc; int i; - if (exfat_pread(ef->dev, &meta1, sizeof(meta1), - co2o(ef, old_cluster, old_offset)) < 0) - { - exfat_error("failed to read meta1 entry on rename"); - return -EIO; - } - if (!next_entry(ef, node->parent, &old_cluster, &old_offset)) - return -EIO; - if (exfat_pread(ef->dev, &meta2, sizeof(meta2), - co2o(ef, old_cluster, old_offset)) < 0) - { - exfat_error("failed to read meta2 entry on rename"); - return -EIO; - } - meta1.continuations = 1 + name_entries; - meta2.name_hash = exfat_calc_name_hash(ef, name); - meta2.name_length = name_length; - meta1.checksum = exfat_calc_checksum(&meta1, &meta2, name); + rc = read_entries(ef, node->parent, entries, 2, node->entry_offset); + if (rc != 0) + return rc; - if (!erase_entry(ef, node)) - return -EIO; + meta1->continuations = 1 + name_entries; + meta2->name_length = name_length; + meta2->name_hash = exfat_calc_name_hash(ef, name, name_length); - node->entry_cluster = new_cluster; - node->entry_offset = new_offset; + rc = erase_node(ef, node); + if (rc != 0) + return rc; - if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1), - co2o(ef, new_cluster, new_offset)) < 0) - { - exfat_error("failed to write meta1 entry on rename"); - return -EIO; - } - if (!next_entry(ef, dir, &new_cluster, &new_offset)) - return -EIO; - if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2), - co2o(ef, new_cluster, new_offset)) < 0) - { - exfat_error("failed to write meta2 entry on rename"); - return -EIO; - } + node->entry_offset = new_offset; + node->continuations = 1 + name_entries; for (i = 0; i < name_entries; i++) { - struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0}; - memcpy(name_entry.name, name + i * EXFAT_ENAME_MAX, + struct exfat_entry_name* name_entry; + + name_entry = (struct exfat_entry_name*) &entries[2 + i]; + name_entry->type = EXFAT_ENTRY_FILE_NAME; + name_entry->__unknown = 0; + memcpy(name_entry->name, name + i * EXFAT_ENAME_MAX, EXFAT_ENAME_MAX * sizeof(le16_t)); - if (!next_entry(ef, dir, &new_cluster, &new_offset)) - return -EIO; - if (exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry), - co2o(ef, new_cluster, new_offset)) < 0) - { - exfat_error("failed to write name entry on rename"); - return -EIO; - } } + meta1->checksum = exfat_calc_checksum(entries, 2 + name_entries); + rc = write_entries(ef, dir, entries, 2 + name_entries, new_offset); + if (rc != 0) + return rc; + memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t)); tree_detach(node); tree_attach(dir, node); @@@ -1131,7 -1065,7 +1066,7 @@@ int exfat_rename(struct exfat* ef, cons } /* check that target is not a subdirectory of the source */ - if (node->flags & EXFAT_ATTRIB_DIR) + if (node->attrib & EXFAT_ATTRIB_DIR) { struct exfat_node* p; @@@ -1151,16 -1085,16 +1086,16 @@@ /* remove target if it's not the same node as source */ if (existing != node) { - if (existing->flags & EXFAT_ATTRIB_DIR) + if (existing->attrib & EXFAT_ATTRIB_DIR) { - if (node->flags & EXFAT_ATTRIB_DIR) + if (node->attrib & EXFAT_ATTRIB_DIR) rc = exfat_rmdir(ef, existing); else rc = -ENOTDIR; } else { - if (!(node->flags & EXFAT_ATTRIB_DIR)) + if (!(node->attrib & EXFAT_ATTRIB_DIR)) rc = exfat_unlink(ef, existing); else rc = -EISDIR; @@@ -1187,7 -1121,7 +1122,7 @@@ exfat_put_node(ef, existing); } - rc = find_slot(ef, dir, &cluster, &offset, + rc = find_slot(ef, dir, &offset, 2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX)); if (rc != 0) { @@@ -1196,8 -1130,16 +1131,16 @@@ return rc; } rc = rename_entry(ef, dir, node, name, cluster, offset); + if (rc != 0) + { + exfat_put_node(ef, dir); + exfat_put_node(ef, node); + return rc; + } + rc = exfat_flush_node(ef, dir); exfat_put_node(ef, dir); exfat_put_node(ef, node); + /* node itself is not marked as dirty, no need to flush it */ return rc; } @@@ -1205,19 -1147,19 +1148,19 @@@ void exfat_utimes(struct exfat_node* no { node->atime = tv[0].tv_sec; node->mtime = tv[1].tv_sec; - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_dirty = true; } void exfat_update_atime(struct exfat_node* node) { node->atime = time(NULL); - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_dirty = true; } void exfat_update_mtime(struct exfat_node* node) { node->mtime = time(NULL); - node->flags |= EXFAT_ATTRIB_DIRTY; + node->is_dirty = true; } const char* exfat_get_label(struct exfat* ef) @@@ -1225,36 -1167,19 +1168,19 @@@ return ef->label; } - static int find_label(struct exfat* ef, cluster_t* cluster, off_t* offset) + static int find_label(struct exfat* ef, off_t* offset) { - struct iterator it; + struct exfat_entry entry; int rc; - rc = opendir(ef, ef->root, &it); - if (rc != 0) - return rc; - - for (;;) + for (*offset = 0; ; *offset += sizeof(entry)) { - if (it.offset >= ef->root->size) - { - closedir(&it); - return -ENOENT; - } + rc = read_entries(ef, ef->root, &entry, 1, *offset); + if (rc != 0) + return rc; - if (get_entry_ptr(ef, &it)->type == EXFAT_ENTRY_LABEL) - { - *cluster = it.cluster; - *offset = it.offset; - closedir(&it); + if (entry.type == EXFAT_ENTRY_LABEL) return 0; - } - - if (!fetch_next_entry(ef, ef->root, &it)) - { - closedir(&it); - return -EIO; - } } } @@@ -1262,18 -1187,17 +1188,17 @@@ int exfat_set_label(struct exfat* ef, c { le16_t label_utf16[EXFAT_ENAME_MAX + 1]; int rc; - cluster_t cluster; off_t offset; struct exfat_entry_label entry; memset(label_utf16, 0, sizeof(label_utf16)); - rc = utf8_to_utf16(label_utf16, label, EXFAT_ENAME_MAX, strlen(label)); + rc = utf8_to_utf16(label_utf16, label, EXFAT_ENAME_MAX + 1, strlen(label)); if (rc != 0) return rc; - rc = find_label(ef, &cluster, &offset); + rc = find_label(ef, &offset); if (rc == -ENOENT) - rc = find_slot(ef, ef->root, &cluster, &offset, 1); + rc = find_slot(ef, ef->root, &offset, 1); if (rc != 0) return rc; @@@ -1283,12 -1207,10 +1208,10 @@@ if (entry.length == 0) entry.type ^= EXFAT_ENTRY_VALID; - if (exfat_pwrite(ef->dev, &entry, sizeof(struct exfat_entry_label), - co2o(ef, cluster, offset)) < 0) - { - exfat_error("failed to write label entry"); - return -EIO; - } + rc = write_entries(ef, ef->root, (struct exfat_entry*) &entry, 1, offset); + if (rc != 0) + return rc; + strcpy(ef->label, label); return 0; } diff --combined libexfat/platform.h index da07672,b3505f4..2fe5341 --- a/libexfat/platform.h +++ b/libexfat/platform.h @@@ -4,7 -4,7 +4,7 @@@ same kernel can use different libc implementations. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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 @@@ -46,7 -46,7 +46,7 @@@ #define EXFAT_LITTLE_ENDIAN LITTLE_ENDIAN #define EXFAT_BIG_ENDIAN BIG_ENDIAN -#elif defined(__FreeBSD__) || defined(__DragonFlyBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) +#elif defined(__ANDROID__) || defined(__FreeBSD__) || defined(__DragonFlyBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) #include #define exfat_bswap16(x) bswap16(x) diff --combined libexfat/utf.h index 4170858,d8968db..f902e65 --- a/libexfat/utf.h +++ b/libexfat/utf.h @@@ -3,7 -3,7 +3,7 @@@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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 @@@ -101,14 -101,14 +101,14 @@@ static const le16_t* utf16_to_wchar(con } } -int utf16_to_utf8(char* output, const le16_t* input, size_t outsize, +static inline int utf16_to_utf8(char* output, const le16_t* input, size_t outsize, size_t insize) { const le16_t* inp = input; char* outp = output; wchar_t wc; - while (inp - input < insize && le16_to_cpu(*inp)) + while (inp - input < insize) { inp = utf16_to_wchar(inp, &wc, insize - (inp - input)); if (inp == NULL) @@@ -122,6 -122,13 +122,13 @@@ exfat_error("name is too long"); return -ENAMETOOLONG; } + if (wc == 0) + return 0; + } + if (outp - output >= outsize) + { + exfat_error("name is too long"); + return -ENAMETOOLONG; } *outp = '\0'; return 0; @@@ -195,14 -202,14 +202,14 @@@ static le16_t* wchar_to_utf16(le16_t* o return output + 2; } -int utf8_to_utf16(le16_t* output, const char* input, size_t outsize, + static inline int utf8_to_utf16(le16_t* output, const char* input, size_t outsize, size_t insize) { const char* inp = input; le16_t* outp = output; wchar_t wc; - while (inp - input < insize && *inp) + while (inp - input < insize) { inp = utf8_to_wchar(inp, &wc, insize - (inp - input)); if (inp == NULL) @@@ -216,12 -223,19 +223,19 @@@ exfat_error("name is too long"); return -ENAMETOOLONG; } + if (wc == 0) + break; + } + if (outp - output >= outsize) + { + exfat_error("name is too long"); + return -ENAMETOOLONG; } *outp = cpu_to_le16(0); return 0; } -size_t utf16_length(const le16_t* str) +static inline size_t utf16_length(const le16_t* str) { size_t i = 0; diff --combined libexfat/utils.c index fe6fd7c,c080d4c..939e4ba --- a/libexfat/utils.c +++ b/libexfat/utils.c @@@ -3,7 -3,7 +3,7 @@@ exFAT file system implementation library. Free exFAT implementation. - Copyright (C) 2010-2016 Andrew Nayenko + Copyright (C) 2010-2017 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,7 -21,6 +21,7 @@@ */ #include "exfat.h" +#include "utf.h" #include #include #include @@@ -30,7 -29,7 +30,7 @@@ void exfat_stat(const struct exfat* ef struct stat* stbuf) { memset(stbuf, 0, sizeof(struct stat)); - if (node->flags & EXFAT_ATTRIB_DIR) + if (node->attrib & EXFAT_ATTRIB_DIR) stbuf->st_mode = S_IFDIR | (0777 & ~ef->dmask); else stbuf->st_mode = S_IFREG | (0777 & ~ef->fmask); @@@ -38,8 -37,7 +38,7 @@@ stbuf->st_uid = ef->uid; stbuf->st_gid = ef->gid; stbuf->st_size = node->size; - stbuf->st_blocks = DIV_ROUND_UP(node->size, CLUSTER_SIZE(*ef->sb)) * - CLUSTER_SIZE(*ef->sb) / 512; + stbuf->st_blocks = ROUND_UP(node->size, CLUSTER_SIZE(*ef->sb)) / 512; stbuf->st_mtime = node->mtime; stbuf->st_atime = node->atime; /* set ctime to mtime to ensure we don't break programs that rely on ctime @@@ -47,12 -45,28 +46,28 @@@ stbuf->st_ctime = node->mtime; } - void exfat_get_name(const struct exfat_node* node, char* buffer, size_t n) + void exfat_get_name(const struct exfat_node* node, + char buffer[EXFAT_UTF8_NAME_BUFFER_MAX]) { - if (utf16_to_utf8(buffer, node->name, n, EXFAT_NAME_MAX) != 0) + if (utf16_to_utf8(buffer, node->name, EXFAT_UTF8_NAME_BUFFER_MAX, + EXFAT_NAME_MAX) != 0) exfat_bug("failed to convert name to UTF-8"); } + static uint16_t add_checksum_byte(uint16_t sum, uint8_t byte) + { + return ((sum << 15) | (sum >> 1)) + byte; + } + + static uint16_t add_checksum_bytes(uint16_t sum, const void* buffer, size_t n) + { + int i; + + for (i = 0; i < n; i++) + sum = add_checksum_byte(sum, ((const uint8_t*) buffer)[i]); + return sum; + } + uint16_t exfat_start_checksum(const struct exfat_entry_meta1* entry) { uint16_t sum = 0; @@@ -60,36 -74,23 +75,23 @@@ for (i = 0; i < sizeof(struct exfat_entry); i++) if (i != 2 && i != 3) /* skip checksum field itself */ - sum = ((sum << 15) | (sum >> 1)) + ((const uint8_t*) entry)[i]; + sum = add_checksum_byte(sum, ((const uint8_t*) entry)[i]); return sum; } uint16_t exfat_add_checksum(const void* entry, uint16_t sum) { - int i; - - for (i = 0; i < sizeof(struct exfat_entry); i++) - sum = ((sum << 15) | (sum >> 1)) + ((const uint8_t*) entry)[i]; - return sum; + return add_checksum_bytes(sum, entry, sizeof(struct exfat_entry)); } - le16_t exfat_calc_checksum(const struct exfat_entry_meta1* meta1, - const struct exfat_entry_meta2* meta2, const le16_t* name) + le16_t exfat_calc_checksum(const struct exfat_entry* entries, int n) { uint16_t checksum; - const int name_entries = DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX); int i; - checksum = exfat_start_checksum(meta1); - checksum = exfat_add_checksum(meta2, checksum); - for (i = 0; i < name_entries; i++) - { - struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0}; - memcpy(name_entry.name, name + i * EXFAT_ENAME_MAX, - MIN(EXFAT_ENAME_MAX, EXFAT_NAME_MAX - i * EXFAT_ENAME_MAX) * - sizeof(le16_t)); - checksum = exfat_add_checksum(&name_entry, checksum); - } + checksum = exfat_start_checksum((const struct exfat_entry_meta1*) entries); + for (i = 1; i < n; i++) + checksum = exfat_add_checksum(entries + i, checksum); return cpu_to_le16(checksum); } @@@ -114,10 -115,10 +116,10 @@@ uint32_t exfat_vbr_add_checksum(const v return sum; } - le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name) + le16_t exfat_calc_name_hash(const struct exfat* ef, const le16_t* name, + size_t length) { size_t i; - size_t length = utf16_length(name); uint16_t hash = 0; for (i = 0; i < length; i++) diff --combined mkfs/main.c index 57a4df5,02ac9c7..c6efa8f --- a/mkfs/main.c +++ b/mkfs/main.c @@@ -3,7 -3,7 +3,7 @@@ Creates exFAT file system. Free exFAT implementation. - Copyright (C) 2011-2016 Andrew Nayenko + Copyright (C) 2011-2017 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 @@@ -26,7 -26,6 +26,7 @@@ #include "cbm.h" #include "uct.h" #include "rootdir.h" +#include #include #include #include @@@ -137,7 -136,7 +137,7 @@@ static int setup_volume_label(le16_t la memset(label, 0, (EXFAT_ENAME_MAX + 1) * sizeof(le16_t)); if (s == NULL) return 0; - return utf8_to_utf16(label, s, EXFAT_ENAME_MAX, strlen(s)); + return utf8_to_utf16(label, s, EXFAT_ENAME_MAX + 1, strlen(s)); } static uint32_t setup_volume_serial(uint32_t user_defined) @@@ -229,7 -228,7 +229,7 @@@ int main(int argc, char* argv[] } break; case 'V': - puts("Copyright (C) 2011-2016 Andrew Nayenko"); + puts("Copyright (C) 2011-2017 Andrew Nayenko"); return 0; default: usage(argv[0]); diff --combined mkfs/rootdir.c index e0d2b4a,a8cc834..e98ed7c --- a/mkfs/rootdir.c +++ b/mkfs/rootdir.c @@@ -3,7 -3,7 +3,7 @@@ Root directory creation code. Free exFAT implementation. - Copyright (C) 2011-2016 Andrew Nayenko + Copyright (C) 2011-2017 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,7 -24,6 +24,7 @@@ #include "uct.h" #include "cbm.h" #include "uctc.h" +#include #include static off_t rootdir_alignment(void)