static int nodeck(struct exfat* ef, struct exfat_node* node)
{
const cluster_t cluster_size = CLUSTER_SIZE(*ef->sb);
cluster_t clusters = (node->size + cluster_size - 1) / cluster_size;
cluster_t c = node->start_cluster;
int rc = 0;
while (clusters--)
{
if (CLUSTER_INVALID(c))
{
char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
exfat_get_name(node, name, sizeof(name) - 1);
exfat_error("file '%s' has invalid cluster 0x%x", name, c);
rc = 1;
break;
}
if (BMAP_GET(ef->cmap.chunk, c - EXFAT_FIRST_DATA_CLUSTER) == 0)
{
char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
exfat_get_name(node, name, sizeof(name) - 1);
exfat_error("cluster 0x%x of file '%s' is not allocated", c, name);
rc = 1;
}
c = exfat_next_cluster(ef, node, c);
}
return rc;
}
static void reset_cache(struct exfat* ef, struct exfat_node* node)
{
char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
while (node->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)
{
exfat_get_name(node, buffer, sizeof(buffer) - 1);
exfat_warn("non-zero reference counter (%d) for '%s'",
node->references, buffer);
}
if (node != ef->root && (node->flags & EXFAT_ATTRIB_DIRTY))
{
exfat_get_name(node, buffer, sizeof(buffer) - 1);
exfat_bug("node '%s' is dirty", buffer);
}
while (node->references)
exfat_put_node(ef, node);
}
static bool check_node(const struct exfat_node* node, uint16_t actual_checksum,
uint16_t reference_checksum, uint64_t valid_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;
}
/*
exFAT does not support sparse files but allows files with uninitialized
clusters. For such files valid_size means initialized data size and
cannot be greater than file size. See SetFileValidData() function
description in MSDN.
*/
if (valid_size > node->size)
{
exfat_get_name(node, buffer, sizeof(buffer) - 1);
exfat_error("'%s' has valid size (%"PRIu64") greater than size "
"(%"PRIu64")", buffer, valid_size, node->size);
return false;
}
return true;
}
static void dirck(struct exfat* ef, const char* path)
{
struct exfat_node* parent;
struct exfat_node* node;
struct exfat_iterator it;
int rc;
size_t path_length;
char* entry_path;
if (exfat_lookup(ef, &parent, path) != 0)
exfat_bug("directory '%s' is not found", path);
if (!(parent->flags & EXFAT_ATTRIB_DIR))
exfat_bug("'%s' is not a directory (0x%x)", path, parent->flags);
if (nodeck(ef, parent) != 0)
{
exfat_put_node(ef, parent);
return;
}
path_length = strlen(path);
entry_path = malloc(path_length + 1 + UTF8_BYTES(EXFAT_NAME_MAX) + 1);
if (entry_path == NULL)
{
exfat_put_node(ef, parent);
exfat_error("out of memory");
return;
}
strcpy(entry_path, path);
strcat(entry_path, "/");
rc = exfat_opendir(ef, parent, &it);
if (rc != 0)
{
free(entry_path);
exfat_put_node(ef, parent);
return;
}
while ((node = exfat_readdir(ef, &it)))
{
exfat_get_name(node, entry_path + path_length + 1,
UTF8_BYTES(EXFAT_NAME_MAX));
exfat_debug("%s: %s, %"PRIu64" bytes, cluster %u", entry_path,
IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented",
node->size, node->start_cluster);
if (node->flags & EXFAT_ATTRIB_DIR)
{
directories_count++;
dirck(ef, entry_path);
}
else
{
files_count++;
nodeck(ef, node);
}
exfat_put_node(ef, node);
}
exfat_closedir(ef, &it);
exfat_put_node(ef, parent);
free(entry_path);
}
void exfat_put_node(struct exfat* ef, struct exfat_node* node)
{
if (--node->references < 0)
{
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)
{
/* 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, true);
free(node);
}
/* FIXME handle I/O error */
if (exfat_flush(ef) != 0)
exfat_bug("flush failed");
}
}
void exfat_put_node(struct exfat* ef, struct exfat_node* node)
{
char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
--node->references;
if (node->references < 0)
{
exfat_get_name(node, buffer, sizeof(buffer) - 1);
exfat_bug("reference counter of '%s' is below zero", buffer);
}
else if (node->references == 0 && node != ef->root)
{
if (node->flags & EXFAT_ATTRIB_DIRTY)
{
exfat_get_name(node, buffer, sizeof(buffer) - 1);
exfat_warn("dirty node '%s' with zero references", buffer);
}
}
}
static int fuse_exfat_readdir(const char* path, void* buffer,
fuse_fill_dir_t filler, off_t offset, struct fuse_file_info* fi)
{
struct exfat_node* parent;
struct exfat_node* node;
struct exfat_iterator it;
int rc;
char name[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
exfat_debug("[%s] %s", __func__, path);
rc = exfat_lookup(&ef, &parent, path);
if (rc != 0)
return rc;
if (!(parent->flags & EXFAT_ATTRIB_DIR))
{
exfat_put_node(&ef, parent);
exfat_error("'%s' is not a directory (0x%x)", path, parent->flags);
return -ENOTDIR;
}
filler(buffer, ".", NULL, 0);
filler(buffer, "..", NULL, 0);
rc = exfat_opendir(&ef, parent, &it);
if (rc != 0)
{
exfat_put_node(&ef, parent);
exfat_error("failed to open directory '%s'", path);
return rc;
}
while ((node = exfat_readdir(&ef, &it)))
{
exfat_get_name(node, name, sizeof(name) - 1);
exfat_debug("[%s] %s: %s, %"PRId64" bytes, cluster 0x%x", __func__,
name, IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented",
node->size, node->start_cluster);
filler(buffer, name, NULL, 0);
exfat_put_node(&ef, node);
}
exfat_closedir(&ef, &it);
exfat_put_node(&ef, parent);
return 0;
}
static void reset_cache(struct exfat* ef, struct exfat_node* node)
{
while (node->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);
exfat_warn("non-zero reference counter (%d) for `%s'",
node->references, buffer);
}
while (node->references)
exfat_put_node(ef, node);
}
static void reset_cache(struct exfat* ef, struct exfat_node* node)
{
struct exfat_node* child;
struct exfat_node* next;
for (child = node->child; child; child = next)
{
reset_cache(ef, child);
next = child->next;
free(child);
}
if (node->references != 0)
{
char buffer[EXFAT_NAME_MAX + 1];
exfat_get_name(node, buffer, EXFAT_NAME_MAX);
exfat_warn("non-zero reference counter (%d) for `%s'",
node->references, buffer);
}
while (node->references--)
exfat_put_node(ef, node);
node->child = NULL;
node->flags &= ~EXFAT_ATTRIB_CACHED;
}
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);
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);
if (node->flags & EXFAT_ATTRIB_UNLINKED)
{
/* free all clusters and node structure itself */
exfat_truncate(ef, node, 0);
free(node);
}
if (ef->cmap.dirty)
exfat_flush_cmap(ef);
}
}
/*
* Reads one entry in directory at position pointed by iterator and fills
* node structure.
*/
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;
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 real_size = 0;
*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 */
}
entry = get_entry_ptr(ef, it);
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);
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("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)
{
/*
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.
There is an exception though: pagefile.sys (its real_size
is always 0).
*/
if (real_size != (*node)->size)
{
char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
exfat_get_name(*node, buffer, sizeof(buffer) - 1);
exfat_error("`%s' real size does not equal to size "
"(%"PRIu64" != %"PRIu64")", buffer,
real_size, (*node)->size);
goto error;
}
if (actual_checksum != reference_checksum)
{
char buffer[UTF8_BYTES(EXFAT_NAME_MAX) + 1];
exfat_get_name(*node, buffer, sizeof(buffer) - 1);
exfat_error("`%s' has invalid checksum (0x%hx != 0x%hx)",
buffer, actual_checksum, reference_checksum);
goto error;
}
if (fetch_next_entry(ef, parent, it) != 0)
goto error;
return 0; /* entry completed */
}
break;
case EXFAT_ENTRY_UPCASE:
if (ef->upcase != NULL)
break;
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;
}
if (le64_to_cpu(upcase->size) == 0 ||
le64_to_cpu(upcase->size) > 0xffff * sizeof(uint16_t) ||
le64_to_cpu(upcase->size) % sizeof(uint16_t) != 0)
{
exfat_error("bad upcase table size (%"PRIu64" bytes)",
le64_to_cpu(upcase->size));
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));
rc = -ENOMEM;
goto error;
}
ef->upcase_chars = le64_to_cpu(upcase->size) / sizeof(le16_t);
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;
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;
}
ef->cmap.size = le32_to_cpu(ef->sb->cluster_count) -
EXFAT_FIRST_DATA_CLUSTER;
if (le64_to_cpu(bitmap->size) < DIV_ROUND_UP(ef->cmap.size, 8))
{
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;
}
/* FIXME bitmap can be rather big, up to 512 MB */
ef->cmap.chunk_size = ef->cmap.size;
ef->cmap.chunk = malloc(BMAP_SIZE(ef->cmap.chunk_size));
if (ef->cmap.chunk == NULL)
{
exfat_error("failed to allocate clusters bitmap chunk "
"(%"PRIu64" bytes)", le64_to_cpu(bitmap->size));
rc = -ENOMEM;
goto error;
}
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:
label = (const struct exfat_entry_label*) entry;
if (label->length > EXFAT_ENAME_MAX)
{
exfat_error("too long label (%hhu chars)", label->length);
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%hhx", entry->type);
goto error;
}
break;
}
if (fetch_next_entry(ef, parent, it) != 0)
goto error;
}
/* we never reach here */
error:
free(*node);
*node = NULL;
return rc;
}
