}
}
+/**
+ * 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)
{
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,
return -ENOMEM;
/* 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;
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 = 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,
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));
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_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0};
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);
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);
+ 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),
- exfat_c2o(ef, old_cluster) + old_offset, ef->fd);
+ 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;
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);
+ 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),
- exfat_c2o(ef, new_cluster) + new_offset, ef->fd);
+ exfat_write_raw(&meta2, sizeof(meta2), co2o(ef, new_cluster, new_offset),
+ ef->fd);
for (i = 0; i < name_entries; i++)
{
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);
+ co2o(ef, new_cluster, new_offset), ef->fd);
}
memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t));
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
