X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=libexfat%2Fnode.c;h=6cb0eb034e560787619c25828250840faa2e22b2;hb=3110ebdb6eddd99ecca0c2947984b8bbbc0c4ff8;hp=c9cee45216735588b4b46d328a3ed44fbfa048e6;hpb=27a397c212332a7d59cb4dc8c8e395269cb8189e;p=android-x86%2Fexternal-exfat.git diff --git a/libexfat/node.c b/libexfat/node.c index c9cee45..6cb0eb0 100644 --- a/libexfat/node.c +++ b/libexfat/node.c @@ -2,11 +2,12 @@ node.c (09.10.09) exFAT file system implementation library. - Copyright (C) 2009, 2010 Andrew Nayenko + Free exFAT implementation. + Copyright (C) 2010-2013 Andrew Nayenko - This program is free software: you can redistribute it and/or modify + 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 3 of the License, or + 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, @@ -14,8 +15,9 @@ 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, see . + 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. */ #include "exfat.h" @@ -44,26 +46,36 @@ void exfat_put_node(struct exfat* ef, struct exfat_node* node) { if (--node->references < 0) { - char buffer[EXFAT_NAME_MAX + 1]; - exfat_get_name(node, buffer, EXFAT_NAME_MAX); + char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + exfat_get_name(node, buffer, sizeof(buffer) - 1); exfat_bug("reference counter of `%s' is below zero", buffer); } if (node->references == 0) { - if (node->flags & EXFAT_ATTRIB_DIRTY) - exfat_flush_node(ef, node); + /* FIXME handle I/O error */ + if (exfat_flush_node(ef, node) != 0) + exfat_bug("node flush failed"); if (node->flags & EXFAT_ATTRIB_UNLINKED) { /* free all clusters and node structure itself */ - exfat_truncate(ef, node, 0); + exfat_truncate(ef, node, 0, true); free(node); } - if (ef->cmap.dirty) - exfat_flush_cmap(ef); + /* FIXME handle I/O error */ + if (exfat_flush(ef) != 0) + exfat_bug("flush failed"); } } +/** + * Cluster + offset from the beginning of the directory to absolute offset. + */ +static off_t co2o(struct exfat* ef, cluster_t cluster, 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) { @@ -78,8 +90,12 @@ static int opendir(struct exfat* ef, const struct exfat_node* dir, exfat_error("out of memory"); return -ENOMEM; } - exfat_read_raw(it->chunk, CLUSTER_SIZE(*ef->sb), - exfat_c2o(ef, it->cluster), ef->fd); + 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); + return -EIO; + } return 0; } @@ -100,14 +116,24 @@ static int fetch_next_entry(struct exfat* ef, const struct exfat_node* parent, /* 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 0; it->cluster = exfat_next_cluster(ef, parent, it->cluster); if (CLUSTER_INVALID(it->cluster)) { - exfat_error("invalid cluster while reading directory"); + exfat_error("invalid cluster 0x%x while reading directory", + it->cluster); + return 1; + } + 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 1; } - exfat_read_raw(it->chunk, CLUSTER_SIZE(*ef->sb), - exfat_c2o(ef, it->cluster), ef->fd); } return 0; } @@ -128,8 +154,10 @@ static void init_node_meta1(struct exfat_node* node, const struct exfat_entry_meta1* meta1) { node->flags = le16_to_cpu(meta1->attrib); - node->mtime = exfat_exfat2unix(meta1->mdate, meta1->mtime); - node->atime = exfat_exfat2unix(meta1->adate, meta1->atime); + node->mtime = exfat_exfat2unix(meta1->mdate, meta1->mtime, + meta1->mtime_cs); + /* there is no centiseconds field for atime */ + node->atime = exfat_exfat2unix(meta1->adate, meta1->atime, 0); } static void init_node_meta2(struct exfat_node* node, @@ -138,10 +166,49 @@ static void init_node_meta2(struct exfat_node* node, node->size = le64_to_cpu(meta2->size); node->start_cluster = le32_to_cpu(meta2->start_cluster); node->fptr_cluster = node->start_cluster; - if (meta2->flag == EXFAT_FLAG_CONTIGUOUS) + if (meta2->flags & EXFAT_FLAG_CONTIGUOUS) node->flags |= EXFAT_ATTRIB_CONTIGUOUS; } +static const struct exfat_entry* get_entry_ptr(const struct exfat* ef, + const struct iterator* it) +{ + return (const struct exfat_entry*) + (it->chunk + it->offset % CLUSTER_SIZE(*ef->sb)); +} + +static bool check_node(const struct exfat_node* node, uint16_t actual_checksum, + uint16_t reference_checksum, uint64_t real_size) +{ + char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + + /* + Validate checksum first. If it's invalid all other fields probably + contain just garbage. + */ + if (actual_checksum != reference_checksum) + { + exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_error("`%s' has invalid checksum (%#hx != %#hx)", buffer, + actual_checksum, reference_checksum); + return false; + } + + /* + It's unclear what is real_size field needed for. It usually equals to + the size but may contain any value less than size (including 0). + */ + if (real_size > node->size) + { + exfat_get_name(node, buffer, sizeof(buffer) - 1); + exfat_error("`%s' has real size (%"PRIu64") greater than size " + "(%"PRIu64")", buffer, real_size, node->size); + return false; + } + + return true; +} + /* * Reads one entry in directory at position pointed by iterator and fills * node structure. @@ -149,6 +216,7 @@ static void init_node_meta2(struct exfat_node* node, static int readdir(struct exfat* ef, const struct exfat_node* parent, struct exfat_node** node, struct iterator* it) { + int rc = -EIO; const struct exfat_entry* entry; const struct exfat_entry_meta1* meta1; const struct exfat_entry_meta2* meta2; @@ -160,27 +228,25 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, le16_t* namep = NULL; uint16_t reference_checksum = 0; uint16_t actual_checksum = 0; + uint64_t real_size = 0; *node = NULL; for (;;) { - /* every directory (even empty one) occupies at least one cluster and - must contain EOD entry */ - entry = (const struct exfat_entry*) - (it->chunk + it->offset % CLUSTER_SIZE(*ef->sb)); - - switch (entry->type) + if (it->offset >= parent->size) { - case EXFAT_ENTRY_EOD: if (continuations != 0) { - exfat_error("expected %hhu continuations before EOD", - continuations); + exfat_error("expected %hhu continuations", continuations); goto error; } return -ENOENT; /* that's OK, means end of directory */ + } + entry = get_entry_ptr(ef, it); + switch (entry->type) + { case EXFAT_ENTRY_FILE: if (continuations != 0) { @@ -195,16 +261,25 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, if (continuations < 2) { exfat_error("too few continuations (%hhu)", continuations); - return -EIO; + 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) - return -ENOMEM; + { + rc = -ENOMEM; + goto error; + } /* new node has zero reference counter */ (*node)->entry_cluster = it->cluster; - (*node)->entry_offset = it->offset % CLUSTER_SIZE(*ef->sb); + (*node)->entry_offset = it->offset; init_node_meta1(*node, meta1); namep = (*node)->name; break; @@ -217,29 +292,27 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, 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); - /* There are two fields that contain file size. Maybe they plan - to add compression support in the future and one of those - fields is visible (uncompressed) size and the other is real - (compressed) size. Anyway, currently it looks like exFAT does - not support compression and both fields must be equal. */ - if (le64_to_cpu(meta2->real_size) != (*node)->size) + real_size = le64_to_cpu(meta2->real_size); + /* empty files must be marked as non-contiguous */ + if ((*node)->size == 0 && (meta2->flags & EXFAT_FLAG_CONTIGUOUS)) { - exfat_error("real size does not equal to size " - "(%"PRIu64" != %"PRIu64")", - le64_to_cpu(meta2->real_size), (*node)->size); + 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) { - char buffer[EXFAT_NAME_MAX + 1]; - - exfat_get_name(*node, buffer, EXFAT_NAME_MAX); - exfat_error("directory `%s' has invalid size %"PRIu64" bytes", - buffer, (*node)->size); + exfat_error("directory has invalid size %"PRIu64" bytes", + (*node)->size); goto error; } --continuations; @@ -254,16 +327,16 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, file_name = (const struct exfat_entry_name*) entry; actual_checksum = exfat_add_checksum(entry, actual_checksum); - memcpy(namep, file_name->name, EXFAT_ENAME_MAX * sizeof(le16_t)); + 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 (actual_checksum != reference_checksum) - { - exfat_error("invalid checksum (0x%hx != 0x%hx)", - actual_checksum, reference_checksum); - return -EIO; - } + if (!check_node(*node, actual_checksum, reference_checksum, + real_size)) + goto error; if (fetch_next_entry(ef, parent, it) != 0) goto error; return 0; /* entry completed */ @@ -276,8 +349,9 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, upcase = (const struct exfat_entry_upcase*) entry; if (CLUSTER_INVALID(le32_to_cpu(upcase->start_cluster))) { - exfat_error("invalid cluster in upcase table"); - return -EIO; + exfat_error("invalid cluster 0x%x in upcase table", + le32_to_cpu(upcase->start_cluster)); + goto error; } if (le64_to_cpu(upcase->size) == 0 || le64_to_cpu(upcase->size) > 0xffff * sizeof(uint16_t) || @@ -285,49 +359,68 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, { exfat_error("bad upcase table size (%"PRIu64" bytes)", le64_to_cpu(upcase->size)); - return -EIO; + goto error; } ef->upcase = malloc(le64_to_cpu(upcase->size)); if (ef->upcase == NULL) { exfat_error("failed to allocate upcase table (%"PRIu64" bytes)", le64_to_cpu(upcase->size)); - return -ENOMEM; + rc = -ENOMEM; + goto error; } ef->upcase_chars = le64_to_cpu(upcase->size) / sizeof(le16_t); - exfat_read_raw(ef->upcase, le64_to_cpu(upcase->size), - exfat_c2o(ef, le32_to_cpu(upcase->start_cluster)), ef->fd); + if (exfat_pread(ef->dev, ef->upcase, le64_to_cpu(upcase->size), + exfat_c2o(ef, le32_to_cpu(upcase->start_cluster))) < 0) + { + exfat_error("failed to read upper case table " + "(%"PRIu64" bytes starting at cluster %#x)", + le64_to_cpu(upcase->size), + le32_to_cpu(upcase->start_cluster)); + goto error; + } break; case EXFAT_ENTRY_BITMAP: bitmap = (const struct exfat_entry_bitmap*) entry; - if (CLUSTER_INVALID(le32_to_cpu(bitmap->start_cluster))) + ef->cmap.start_cluster = le32_to_cpu(bitmap->start_cluster); + if (CLUSTER_INVALID(ef->cmap.start_cluster)) { - exfat_error("invalid cluster in clusters bitmap"); - return -EIO; + exfat_error("invalid cluster 0x%x in clusters bitmap", + ef->cmap.start_cluster); + goto error; } ef->cmap.size = le32_to_cpu(ef->sb->cluster_count) - EXFAT_FIRST_DATA_CLUSTER; - if (le64_to_cpu(bitmap->size) != (ef->cmap.size + 7) / 8) + if (le64_to_cpu(bitmap->size) < DIV_ROUND_UP(ef->cmap.size, 8)) { - exfat_error("invalid bitmap size: %"PRIu64" (expected %u)", - le64_to_cpu(bitmap->size), (ef->cmap.size + 7) / 8); - return -EIO; + exfat_error("invalid clusters bitmap size: %"PRIu64 + " (expected at least %u)", + le64_to_cpu(bitmap->size), + DIV_ROUND_UP(ef->cmap.size, 8)); + goto error; } - ef->cmap.start_cluster = le32_to_cpu(bitmap->start_cluster); /* FIXME bitmap can be rather big, up to 512 MB */ ef->cmap.chunk_size = ef->cmap.size; - ef->cmap.chunk = malloc(le64_to_cpu(bitmap->size)); + ef->cmap.chunk = malloc(BMAP_SIZE(ef->cmap.chunk_size)); if (ef->cmap.chunk == NULL) { - exfat_error("failed to allocate clusters map chunk " + exfat_error("failed to allocate clusters bitmap chunk " "(%"PRIu64" bytes)", le64_to_cpu(bitmap->size)); - return -ENOMEM; + rc = -ENOMEM; + goto error; } - exfat_read_raw(ef->cmap.chunk, le64_to_cpu(bitmap->size), - exfat_c2o(ef, ef->cmap.start_cluster), ef->fd); + if (exfat_pread(ef->dev, ef->cmap.chunk, + BMAP_SIZE(ef->cmap.chunk_size), + exfat_c2o(ef, ef->cmap.start_cluster)) < 0) + { + exfat_error("failed to read clusters bitmap " + "(%"PRIu64" bytes starting at cluster %#x)", + le64_to_cpu(bitmap->size), ef->cmap.start_cluster); + goto error; + } break; case EXFAT_ENTRY_LABEL: @@ -335,14 +428,17 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, if (label->length > EXFAT_ENAME_MAX) { exfat_error("too long label (%hhu chars)", label->length); - return -EIO; + goto error; } + if (utf16_to_utf8(ef->label, label->name, + sizeof(ef->label) - 1, EXFAT_ENAME_MAX) != 0) + goto error; break; default: if (entry->type & EXFAT_ENTRY_VALID) { - exfat_error("unknown entry type 0x%hhu", entry->type); + exfat_error("unknown entry type 0x%hhx", entry->type); goto error; } break; @@ -356,7 +452,7 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent, error: free(*node); *node = NULL; - return -EIO; + return rc; } int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir) @@ -403,28 +499,49 @@ int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir) return 0; } -static void reset_cache(struct exfat* ef, struct exfat_node* node) +static void tree_attach(struct exfat_node* dir, struct exfat_node* node) +{ + node->parent = dir; + if (dir->child) + { + dir->child->prev = node; + node->next = dir->child; + } + dir->child = node; +} + +static void tree_detach(struct exfat_node* node) { - struct exfat_node* child; - struct exfat_node* next; + if (node->prev) + node->prev->next = node->next; + else /* this is the first node in the list */ + node->parent->child = node->next; + if (node->next) + node->next->prev = node->prev; + node->parent = NULL; + node->prev = NULL; + node->next = NULL; +} - for (child = node->child; child; child = next) +static void reset_cache(struct exfat* ef, struct exfat_node* node) +{ + while (node->child) { - reset_cache(ef, child); - next = child->next; - free(child); + struct exfat_node* p = node->child; + reset_cache(ef, p); + tree_detach(p); + free(p); } + node->flags &= ~EXFAT_ATTRIB_CACHED; if (node->references != 0) { - char buffer[EXFAT_NAME_MAX + 1]; - exfat_get_name(node, buffer, EXFAT_NAME_MAX); + char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1]; + exfat_get_name(node, buffer, sizeof(buffer) - 1); exfat_warn("non-zero reference counter (%d) for `%s'", node->references, buffer); } - while (node->references--) + while (node->references) exfat_put_node(ef, node); - node->child = NULL; - node->flags &= ~EXFAT_ATTRIB_CACHED; } void exfat_reset_cache(struct exfat* ef) @@ -432,21 +549,24 @@ void exfat_reset_cache(struct exfat* ef) reset_cache(ef, ef->root); } -void next_entry(struct exfat* ef, const struct exfat_node* parent, +static bool next_entry(struct exfat* ef, const struct exfat_node* parent, cluster_t* cluster, off_t* offset) { - if (*offset + sizeof(struct exfat_entry) == CLUSTER_SIZE(*ef->sb)) + *offset += sizeof(struct exfat_entry); + if (*offset % CLUSTER_SIZE(*ef->sb) == 0) { - /* next cluster cannot be invalid */ *cluster = exfat_next_cluster(ef, parent, *cluster); - *offset = 0; + if (CLUSTER_INVALID(*cluster)) + { + exfat_error("invalid cluster %#x while getting next entry", + *cluster); + return false; + } } - else - *offset += sizeof(struct exfat_entry); - + return true; } -void exfat_flush_node(struct exfat* ef, struct exfat_node* node) +int exfat_flush_node(struct exfat* ef, struct exfat_node* node) { cluster_t cluster; off_t offset; @@ -454,46 +574,66 @@ void exfat_flush_node(struct exfat* ef, struct exfat_node* node) struct exfat_entry_meta1 meta1; struct exfat_entry_meta2 meta2; + if (!(node->flags & EXFAT_ATTRIB_DIRTY)) + return 0; /* no need to flush */ + if (ef->ro) exfat_bug("unable to flush node to read-only FS"); if (node->parent == NULL) - return; /* do not flush unlinked node */ + return 0; /* do not flush unlinked node */ cluster = node->entry_cluster; offset = node->entry_offset; - meta1_offset = exfat_c2o(ef, cluster) + offset; - next_entry(ef, node->parent, &cluster, &offset); - meta2_offset = exfat_c2o(ef, cluster) + offset; + meta1_offset = co2o(ef, cluster, offset); + if (!next_entry(ef, node->parent, &cluster, &offset)) + return -EIO; + meta2_offset = co2o(ef, cluster, offset); - exfat_read_raw(&meta1, sizeof(meta1), meta1_offset, ef->fd); + if (exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0) + { + exfat_error("failed to read meta1 entry on flush"); + 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); - exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime); + exfat_unix2exfat(node->mtime, &meta1.mdate, &meta1.mtime, &meta1.mtime_cs); + exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL); - exfat_read_raw(&meta2, sizeof(meta2), meta2_offset, ef->fd); + 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.real_size = cpu_to_le64(node->size); meta2.start_cluster = cpu_to_le32(node->start_cluster); - /* empty files must be marked as fragmented */ + meta2.flags = EXFAT_FLAG_ALWAYS1; + /* empty files must not be marked as contiguous */ if (node->size != 0 && IS_CONTIGUOUS(*node)) - meta2.flag = EXFAT_FLAG_CONTIGUOUS; - else - meta2.flag = EXFAT_FLAG_FRAGMENTED; + meta2.flags |= EXFAT_FLAG_CONTIGUOUS; /* name hash remains unchanged, no need to recalculate it */ meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name); - exfat_write_raw(&meta1, sizeof(meta1), meta1_offset, ef->fd); - exfat_write_raw(&meta2, sizeof(meta2), meta2_offset, ef->fd); + 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; + } node->flags &= ~EXFAT_ATTRIB_DIRTY; + return 0; } -static void erase_entry(struct exfat* ef, struct exfat_node* node) +static bool erase_entry(struct exfat* ef, struct exfat_node* node) { cluster_t cluster = node->entry_cluster; off_t offset = node->entry_offset; @@ -501,60 +641,107 @@ static void erase_entry(struct exfat* ef, struct exfat_node* node) uint8_t entry_type; entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID; - exfat_write_raw(&entry_type, 1, exfat_c2o(ef, cluster) + offset, ef->fd); + if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0) + { + exfat_error("failed to erase meta1 entry"); + return false; + } - next_entry(ef, node->parent, &cluster, &offset); + if (!next_entry(ef, node->parent, &cluster, &offset)) + return false; entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID; - exfat_write_raw(&entry_type, 1, exfat_c2o(ef, cluster) + offset, ef->fd); + if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0) + { + exfat_error("failed to erase meta2 entry"); + return false; + } while (name_entries--) { - next_entry(ef, node->parent, &cluster, &offset); + if (!next_entry(ef, node->parent, &cluster, &offset)) + return false; entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID; - exfat_write_raw(&entry_type, 1, exfat_c2o(ef, cluster) + offset, - ef->fd); + if (exfat_pwrite(ef->dev, &entry_type, 1, + co2o(ef, cluster, offset)) < 0) + { + exfat_error("failed to erase name entry"); + return false; + } } + return true; } -static void tree_detach(struct exfat_node* node) +static int shrink_directory(struct exfat* ef, struct exfat_node* dir, + off_t deleted_offset) { - if (node->prev) - node->prev->next = node->next; - else /* this is the first node in the list */ - node->parent->child = node->next; - if (node->next) - node->next->prev = node->prev; - node->parent = NULL; - node->prev = NULL; - node->next = NULL; -} + const struct exfat_node* node; + const struct exfat_node* last_node; + uint64_t entries = 0; + uint64_t new_size; -static void tree_attach(struct exfat_node* dir, struct exfat_node* node) -{ - node->parent = dir; - if (dir->child) + if (!(dir->flags & EXFAT_ATTRIB_DIR)) + exfat_bug("attempted to shrink a file"); + if (!(dir->flags & EXFAT_ATTRIB_CACHED)) + exfat_bug("attempted to shrink uncached directory"); + + for (last_node = node = dir->child; node; node = node->next) { - dir->child->prev = node; - node->next = dir->child; + if (deleted_offset < node->entry_offset) + { + /* there are other entries after the removed one, no way to shrink + this directory */ + return 0; + } + if (last_node->entry_offset < node->entry_offset) + last_node = node; } - dir->child = node; + + if (last_node) + { + /* offset of the last entry */ + entries += last_node->entry_offset / sizeof(struct exfat_entry); + /* two subentries with meta info */ + entries += 2; + /* subentries with file name */ + entries += DIV_ROUND_UP(utf16_length(last_node->name), + EXFAT_ENAME_MAX); + } + + new_size = DIV_ROUND_UP(entries * sizeof(struct exfat_entry), + CLUSTER_SIZE(*ef->sb)) * CLUSTER_SIZE(*ef->sb); + if (new_size == 0) /* directory always has at least 1 cluster */ + new_size = CLUSTER_SIZE(*ef->sb); + if (new_size == dir->size) + return 0; + return exfat_truncate(ef, dir, new_size, true); } -static void delete(struct exfat* ef, struct exfat_node* node) +static int delete(struct exfat* ef, struct exfat_node* node) { - erase_entry(ef, node); - exfat_update_mtime(node->parent); + struct exfat_node* parent = node->parent; + off_t deleted_offset = node->entry_offset; + int rc; + + exfat_get_node(parent); + if (!erase_entry(ef, node)) + { + exfat_put_node(ef, parent); + return -EIO; + } + exfat_update_mtime(parent); tree_detach(node); + rc = shrink_directory(ef, parent, deleted_offset); + exfat_put_node(ef, parent); /* file clusters will be freed when node reference counter becomes 0 */ node->flags |= EXFAT_ATTRIB_UNLINKED; + return rc; } int exfat_unlink(struct exfat* ef, struct exfat_node* node) { if (node->flags & EXFAT_ATTRIB_DIR) return -EISDIR; - delete(ef, node); - return 0; + return delete(ef, node); } int exfat_rmdir(struct exfat* ef, struct exfat_node* node) @@ -565,8 +752,7 @@ int exfat_rmdir(struct exfat* ef, struct exfat_node* node) exfat_cache_directory(ef, node); if (node->child) return -ENOTEMPTY; - delete(ef, node); - return 0; + return delete(ef, node); } static int grow_directory(struct exfat* ef, struct exfat_node* dir, @@ -574,7 +760,7 @@ static int grow_directory(struct exfat* ef, struct exfat_node* dir, { return exfat_truncate(ef, dir, DIV_ROUND_UP(asize + difference, CLUSTER_SIZE(*ef->sb)) - * CLUSTER_SIZE(*ef->sb)); + * CLUSTER_SIZE(*ef->sb), true); } static int find_slot(struct exfat* ef, struct exfat_node* dir, @@ -593,28 +779,25 @@ static int find_slot(struct exfat* ef, struct exfat_node* dir, if (contiguous == 0) { *cluster = it.cluster; - *offset = it.offset % CLUSTER_SIZE(*ef->sb); + *offset = it.offset; } - entry = (const struct exfat_entry*) - (it.chunk + it.offset % CLUSTER_SIZE(*ef->sb)); - if (entry->type == EXFAT_ENTRY_EOD) + 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, - it.offset + sizeof(struct exfat_entry), /* actual size */ + rc = grow_directory(ef, dir, dir->size, (subentries - contiguous) * sizeof(struct exfat_entry)); if (rc != 0) { closedir(&it); return rc; } - break; } - if (entry->type & EXFAT_ENTRY_VALID) - contiguous = 0; - else - contiguous++; - if (contiguous == subentries) - break; /* suitable slot it found */ if (fetch_next_entry(ef, dir, &it) != 0) { closedir(&it); @@ -646,34 +829,49 @@ static int write_entry(struct exfat* ef, struct exfat_node* dir, meta1.type = EXFAT_ENTRY_FILE; meta1.continuations = 1 + name_entries; meta1.attrib = cpu_to_le16(attrib); - exfat_unix2exfat(time(NULL), &meta1.crdate, &meta1.crtime); + exfat_unix2exfat(time(NULL), &meta1.crdate, &meta1.crtime, + &meta1.crtime_cs); meta1.adate = meta1.mdate = meta1.crdate; meta1.atime = meta1.mtime = meta1.crtime; - /* crtime_cs and mtime_cs contain addition to the time in centiseconds; - just ignore those fields because we operate with 2 sec resolution */ + meta1.mtime_cs = meta1.crtime_cs; /* there is no atime_cs */ memset(&meta2, 0, sizeof(meta2)); meta2.type = EXFAT_ENTRY_FILE_INFO; - meta2.flag = EXFAT_FLAG_FRAGMENTED; + 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); - exfat_write_raw(&meta1, sizeof(meta1), exfat_c2o(ef, cluster) + offset, - ef->fd); - next_entry(ef, dir, &cluster, &offset); - exfat_write_raw(&meta2, sizeof(meta2), exfat_c2o(ef, cluster) + offset, - ef->fd); + 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, - EXFAT_ENAME_MAX * sizeof(le16_t)); - next_entry(ef, dir, &cluster, &offset); - exfat_write_raw(&name_entry, sizeof(name_entry), - exfat_c2o(ef, cluster) + offset, ef->fd); + 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; + } } init_node_meta1(node, &meta1); @@ -687,14 +885,21 @@ static int write_entry(struct exfat* ef, struct exfat_node* dir, static int create(struct exfat* ef, const char* path, uint16_t attrib) { struct exfat_node* dir; + struct exfat_node* existing; cluster_t cluster = EXFAT_CLUSTER_BAD; off_t offset = -1; le16_t name[EXFAT_NAME_MAX + 1]; int rc; - rc = exfat_split(ef, &dir, name, path); + rc = exfat_split(ef, &dir, &existing, name, path); if (rc != 0) return rc; + if (existing != NULL) + { + exfat_put_node(ef, existing); + exfat_put_node(ef, dir); + return -EEXIST; + } rc = find_slot(ef, dir, &cluster, &offset, 2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX)); @@ -725,7 +930,7 @@ int exfat_mkdir(struct exfat* ef, const char* path) if (rc != 0) return 0; /* directories always have at least one cluster */ - rc = exfat_truncate(ef, node, CLUSTER_SIZE(*ef->sb)); + rc = exfat_truncate(ef, node, CLUSTER_SIZE(*ef->sb), true); if (rc != 0) { delete(ef, node); @@ -736,7 +941,7 @@ int exfat_mkdir(struct exfat* ef, const char* path) return 0; } -static void rename_entry(struct exfat* ef, struct exfat_node* dir, +static int rename_entry(struct exfat* ef, struct exfat_node* dir, struct exfat_node* node, const le16_t* name, cluster_t new_cluster, off_t new_offset) { @@ -748,45 +953,71 @@ static void rename_entry(struct exfat* ef, struct exfat_node* dir, const int name_entries = DIV_ROUND_UP(name_length, EXFAT_ENAME_MAX); int i; - exfat_read_raw(&meta1, sizeof(meta1), - exfat_c2o(ef, old_cluster) + old_offset, ef->fd); - next_entry(ef, node->parent, &old_cluster, &old_offset); - exfat_read_raw(&meta2, sizeof(meta2), - exfat_c2o(ef, old_cluster) + old_offset, ef->fd); + 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); - erase_entry(ef, node); + if (!erase_entry(ef, node)) + return -EIO; node->entry_cluster = new_cluster; node->entry_offset = new_offset; - exfat_write_raw(&meta1, sizeof(meta1), - exfat_c2o(ef, new_cluster) + new_offset, ef->fd); - next_entry(ef, dir, &new_cluster, &new_offset); - exfat_write_raw(&meta2, sizeof(meta2), - exfat_c2o(ef, new_cluster) + new_offset, ef->fd); + 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; + } 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, EXFAT_ENAME_MAX * sizeof(le16_t)); - next_entry(ef, dir, &new_cluster, &new_offset); - exfat_write_raw(&name_entry, sizeof(name_entry), - exfat_c2o(ef, new_cluster) + new_offset, ef->fd); + 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; + } } - memcpy(node->name, name, (name_length + 1) * sizeof(le16_t)); + memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t)); tree_detach(node); tree_attach(dir, node); + return 0; } int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path) { struct exfat_node* node; + struct exfat_node* existing; struct exfat_node* dir; cluster_t cluster = EXFAT_CLUSTER_BAD; off_t offset = -1; @@ -797,14 +1028,60 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path) if (rc != 0) return rc; - memset(name, 0, (EXFAT_NAME_MAX + 1) * sizeof(le16_t)); - rc = exfat_split(ef, &dir, name, new_path); + rc = exfat_split(ef, &dir, &existing, name, new_path); if (rc != 0) { exfat_put_node(ef, node); return rc; } + /* check that target is not a subdirectory of the source */ + if (node->flags & EXFAT_ATTRIB_DIR) + { + struct exfat_node* p; + + for (p = dir; p; p = p->parent) + if (node == p) + { + if (existing != NULL) + exfat_put_node(ef, existing); + exfat_put_node(ef, dir); + exfat_put_node(ef, node); + return -EINVAL; + } + } + + if (existing != NULL) + { + /* remove target if it's not the same node as source */ + if (existing != node) + { + if (existing->flags & EXFAT_ATTRIB_DIR) + { + if (node->flags & EXFAT_ATTRIB_DIR) + rc = exfat_rmdir(ef, existing); + else + rc = -ENOTDIR; + } + else + { + if (!(node->flags & EXFAT_ATTRIB_DIR)) + rc = exfat_unlink(ef, existing); + else + rc = -EISDIR; + } + exfat_put_node(ef, existing); + if (rc != 0) + { + exfat_put_node(ef, dir); + exfat_put_node(ef, node); + return rc; + } + } + else + exfat_put_node(ef, existing); + } + rc = find_slot(ef, dir, &cluster, &offset, 2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX)); if (rc != 0) @@ -813,7 +1090,7 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path) exfat_put_node(ef, node); return rc; } - rename_entry(ef, dir, node, name, cluster, offset); + rc = rename_entry(ef, dir, node, name, cluster, offset); exfat_put_node(ef, dir); exfat_put_node(ef, node); return 0; @@ -837,3 +1114,76 @@ void exfat_update_mtime(struct exfat_node* node) node->mtime = time(NULL); node->flags |= EXFAT_ATTRIB_DIRTY; } + +const char* exfat_get_label(struct exfat* ef) +{ + return ef->label; +} + +static int find_label(struct exfat* ef, cluster_t* cluster, off_t* offset) +{ + struct iterator it; + int rc; + + rc = opendir(ef, ef->root, &it); + if (rc != 0) + return rc; + + for (;;) + { + if (it.offset >= ef->root->size) + { + closedir(&it); + return -ENOENT; + } + + if (get_entry_ptr(ef, &it)->type == EXFAT_ENTRY_LABEL) + { + *cluster = it.cluster; + *offset = it.offset; + closedir(&it); + return 0; + } + + if (fetch_next_entry(ef, ef->root, &it) != 0) + { + closedir(&it); + return -EIO; + } + } +} + +int exfat_set_label(struct exfat* ef, const char* label) +{ + 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)); + if (rc != 0) + return rc; + + rc = find_label(ef, &cluster, &offset); + if (rc == -ENOENT) + rc = find_slot(ef, ef->root, &cluster, &offset, 1); + if (rc != 0) + return rc; + + entry.type = EXFAT_ENTRY_LABEL; + entry.length = utf16_length(label_utf16); + memcpy(entry.name, label_utf16, sizeof(entry.name)); + 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; + } + strcpy(ef->label, label); + return 0; +}