/*
- * node.c
- * exFAT file system implementation library.
- *
- * Created by Andrew Nayenko on 09.10.09.
- * This software is distributed under the GNU General Public License
- * version 3 or any later.
- */
+ node.c (09.10.09)
+ exFAT file system implementation library.
+
+ Copyright (C) 2009, 2010 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ 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 <http://www.gnu.org/licenses/>.
+*/
#include "exfat.h"
#include <errno.h>
}
}
+/**
+ * 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)
{
}
static void init_node_meta1(struct exfat_node* node,
- const struct exfat_file* meta1)
+ 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,
- const struct exfat_file_info* meta2)
+ const struct exfat_entry_meta2* meta2)
{
node->size = le64_to_cpu(meta2->size);
node->start_cluster = le32_to_cpu(meta2->start_cluster);
struct exfat_node** node, struct iterator* it)
{
const struct exfat_entry* entry;
- const struct exfat_file* file;
- const struct exfat_file_info* file_info;
- const struct exfat_file_name* file_name;
- const struct exfat_upcase* upcase;
- const struct exfat_bitmap* bitmap;
- const struct exfat_label* label;
+ 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;
continuations);
goto error;
}
- file = (const struct exfat_file*) entry;
- continuations = file->continuations;
+ 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);
return -EIO;
}
- reference_checksum = le16_to_cpu(file->checksum);
- actual_checksum = exfat_start_checksum(file);
+ reference_checksum = le16_to_cpu(meta1->checksum);
+ actual_checksum = exfat_start_checksum(meta1);
*node = allocate_node();
if (*node == NULL)
return -ENOMEM;
/* new node has zero reference counter */
(*node)->entry_cluster = it->cluster;
- (*node)->entry_offset = it->offset % CLUSTER_SIZE(*ef->sb);
- init_node_meta1(*node, file);
+ (*node)->entry_offset = it->offset;
+ init_node_meta1(*node, meta1);
namep = (*node)->name;
break;
continuations);
goto error;
}
- file_info = (const struct exfat_file_info*) entry;
- init_node_meta2(*node, file_info);
+ meta2 = (const struct exfat_entry_meta2*) entry;
+ 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(file_info->real_size) != (*node)->size)
+ if (le64_to_cpu(meta2->real_size) != (*node)->size)
{
exfat_error("real size does not equal to size "
"(%"PRIu64" != %"PRIu64")",
- le64_to_cpu(file_info->real_size), (*node)->size);
+ le64_to_cpu(meta2->real_size), (*node)->size);
goto error;
}
/* directories must be aligned on at cluster boundary */
exfat_error("unexpected continuation");
goto error;
}
- file_name = (const struct exfat_file_name*) entry;
+ 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));
case EXFAT_ENTRY_UPCASE:
if (ef->upcase != NULL)
break;
- upcase = (const struct exfat_upcase*) entry;
+ upcase = (const struct exfat_entry_upcase*) entry;
if (CLUSTER_INVALID(le32_to_cpu(upcase->start_cluster)))
{
exfat_error("invalid cluster in upcase table");
break;
case EXFAT_ENTRY_BITMAP:
- bitmap = (const struct exfat_bitmap*) entry;
+ bitmap = (const struct exfat_entry_bitmap*) entry;
if (CLUSTER_INVALID(le32_to_cpu(bitmap->start_cluster)))
{
exfat_error("invalid cluster in clusters bitmap");
}
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) < (ef->cmap.size + 7) / 8)
{
- exfat_error("invalid bitmap size: %"PRIu64" (expected %u)",
+ exfat_error("invalid clusters bitmap size: %"PRIu64
+ " (expected at least %u)",
le64_to_cpu(bitmap->size), (ef->cmap.size + 7) / 8);
return -EIO;
}
ef->cmap.chunk = malloc(le64_to_cpu(bitmap->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;
}
break;
case EXFAT_ENTRY_LABEL:
- label = (const struct exfat_label*) entry;
+ label = (const struct exfat_entry_label*) entry;
if (label->length > EXFAT_ENAME_MAX)
{
exfat_error("too long label (%hhu chars)", label->length);
return -EIO;
}
+ if (utf16_to_utf8(ef->label, label->name,
+ sizeof(ef->label), EXFAT_ENAME_MAX) != 0)
+ return -EIO;
break;
default:
void 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;
- }
- else
- *offset += sizeof(struct exfat_entry);
-
}
void exfat_flush_node(struct exfat* ef, struct exfat_node* node)
cluster_t cluster;
off_t offset;
off_t meta1_offset, meta2_offset;
- struct exfat_file meta1;
- struct exfat_file_info meta2;
+ struct exfat_entry_meta1 meta1;
+ struct exfat_entry_meta2 meta2;
if (ef->ro)
exfat_bug("unable to flush node to read-only FS");
cluster = node->entry_cluster;
offset = node->entry_offset;
- meta1_offset = exfat_c2o(ef, cluster) + offset;
+ meta1_offset = co2o(ef, cluster, offset);
next_entry(ef, node->parent, &cluster, &offset);
- meta2_offset = exfat_c2o(ef, cluster) + offset;
+ meta2_offset = co2o(ef, cluster, offset);
exfat_read_raw(&meta1, sizeof(meta1), meta1_offset, ef->fd);
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 (meta2.type != EXFAT_ENTRY_FILE_INFO)
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);
+ exfat_write_raw(&entry_type, 1, co2o(ef, cluster, offset), ef->fd);
next_entry(ef, node->parent, &cluster, &offset);
entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;
- exfat_write_raw(&entry_type, 1, exfat_c2o(ef, cluster) + offset, ef->fd);
+ exfat_write_raw(&entry_type, 1, co2o(ef, cluster, offset), ef->fd);
while (name_entries--)
{
next_entry(ef, node->parent, &cluster, &offset);
entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID;
- exfat_write_raw(&entry_type, 1, exfat_c2o(ef, cluster) + offset,
- ef->fd);
+ exfat_write_raw(&entry_type, 1, co2o(ef, cluster, offset), ef->fd);
}
}
dir->child = node;
}
-static void delete(struct exfat* ef, struct exfat_node* node)
+static int shrink_directory(struct exfat* ef, struct exfat_node* dir,
+ off_t deleted_offset)
+{
+ const struct exfat_node* node;
+ const struct exfat_node* last_node;
+ uint64_t entries = 1; /* a directory always has at leat 1 entry (EOD) */
+ uint64_t new_size;
+ struct exfat_entry eod;
+ off_t eod_offset;
+ int rc;
+
+ 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)
+ {
+ 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;
+ }
+
+ 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 == dir->size)
+ return 0;
+ rc = exfat_truncate(ef, dir, new_size);
+ if (rc != 0)
+ return rc;
+
+ /* put EOD entry at the end of the last cluster */
+ memset(&eod, 0, sizeof(eod));
+ eod_offset = new_size - sizeof(struct exfat_entry);
+ if (last_node)
+ exfat_write_raw(&eod, sizeof(eod),
+ co2o(ef, last_node->entry_cluster, eod_offset), ef->fd);
+ else
+ exfat_write_raw(&eod, sizeof(eod),
+ co2o(ef, dir->start_cluster, eod_offset), ef->fd);
+ return 0;
+}
+
+static int delete(struct exfat* ef, struct exfat_node* node)
{
+ struct exfat_node* parent = node->parent;
+ off_t deleted_offset = node->entry_offset;
+ int rc;
+
+ exfat_get_node(parent);
erase_entry(ef, node);
- exfat_update_mtime(node->parent);
+ 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)
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,
* CLUSTER_SIZE(*ef->sb));
}
-static void write_eod(struct exfat* ef, struct exfat_node* dir,
- cluster_t cluster, off_t offset, int seek)
-{
- struct exfat_entry eod;
-
- while (seek--)
- next_entry(ef, dir, &cluster, &offset);
- memset(&eod, 0, sizeof(struct exfat_entry));
- exfat_write_raw(&eod, sizeof(struct exfat_entry),
- exfat_c2o(ef, cluster) + offset, ef->fd);
-}
-
static int find_slot(struct exfat* ef, struct exfat_node* dir,
cluster_t* cluster, off_t* offset, int subentries)
{
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));
closedir(&it);
return rc;
}
- write_eod(ef, dir, *cluster, *offset, subentries - contiguous);
break;
}
if (entry->type & EXFAT_ENTRY_VALID)
const le16_t* name, cluster_t cluster, off_t offset, uint16_t attrib)
{
struct exfat_node* node;
- struct exfat_file meta1;
- struct exfat_file_info meta2;
+ 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);
int i;
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;
meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
- exfat_write_raw(&meta1, sizeof(meta1), exfat_c2o(ef, cluster) + offset,
- ef->fd);
+ exfat_write_raw(&meta1, sizeof(meta1), co2o(ef, cluster, offset), ef->fd);
next_entry(ef, dir, &cluster, &offset);
- exfat_write_raw(&meta2, sizeof(meta2), exfat_c2o(ef, cluster) + offset,
- ef->fd);
+ exfat_write_raw(&meta2, sizeof(meta2), co2o(ef, cluster, offset), ef->fd);
for (i = 0; i < name_entries; i++)
{
- struct exfat_file_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0};
+ 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);
+ co2o(ef, cluster, offset), ef->fd);
}
init_node_meta1(node, &meta1);
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;
- /* FIXME filter name characters */
-
- 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));
return 0;
}
+static void 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)
+{
+ 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);
+ int i;
+
+ exfat_read_raw(&meta1, sizeof(meta1), co2o(ef, old_cluster, old_offset),
+ ef->fd);
+ next_entry(ef, node->parent, &old_cluster, &old_offset);
+ exfat_read_raw(&meta2, sizeof(meta2), co2o(ef, old_cluster, old_offset),
+ ef->fd);
+ 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);
+
+ node->entry_cluster = new_cluster;
+ node->entry_offset = new_offset;
+
+ exfat_write_raw(&meta1, sizeof(meta1), co2o(ef, new_cluster, new_offset),
+ ef->fd);
+ next_entry(ef, dir, &new_cluster, &new_offset);
+ exfat_write_raw(&meta2, sizeof(meta2), co2o(ef, new_cluster, new_offset),
+ ef->fd);
+
+ 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),
+ co2o(ef, new_cluster, new_offset), ef->fd);
+ }
+
+ memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t));
+ tree_detach(node);
+ tree_attach(dir, node);
+}
+
+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;
+ le16_t name[EXFAT_NAME_MAX + 1];
+ int rc;
+
+ rc = exfat_lookup(ef, &node, old_path);
+ if (rc != 0)
+ return rc;
+
+ rc = exfat_split(ef, &dir, &existing, name, new_path);
+ if (rc != 0)
+ {
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ if (existing != NULL)
+ {
+ 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;
+ }
+ }
+
+ rc = find_slot(ef, dir, &cluster, &offset,
+ 2 + DIV_ROUND_UP(utf16_length(name), EXFAT_ENAME_MAX));
+ if (rc != 0)
+ {
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ rename_entry(ef, dir, node, name, cluster, offset);
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return 0;
+}
+
void exfat_utimes(struct exfat_node* node, const struct timespec tv[2])
{
node->atime = tv[0].tv_sec;
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;
+ const struct exfat_entry* entry;
+
+ rc = opendir(ef, ef->root, &it);
+ if (rc != 0)
+ return rc;
+
+ for (;;)
+ {
+ entry = (const struct exfat_entry*)
+ (it.chunk + it.offset % CLUSTER_SIZE(*ef->sb));
+
+ if (entry->type == EXFAT_ENTRY_EOD)
+ {
+ closedir(&it);
+ return -ENOENT;
+ }
+ if (entry->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;
+
+ exfat_write_raw(&entry, sizeof(struct exfat_entry_label),
+ co2o(ef, cluster, offset), ef->fd);
+ return 0;
+}
OSDN Git Service
