+ return delete(ef, node);
+}
+
+static int grow_directory(struct exfat* ef, struct exfat_node* dir,
+ uint64_t asize, uint32_t difference)
+{
+ return exfat_truncate(ef, dir,
+ DIV_ROUND_UP(asize + difference, CLUSTER_SIZE(*ef->sb))
+ * CLUSTER_SIZE(*ef->sb), true);
+}
+
+static int find_slot(struct exfat* ef, struct exfat_node* dir,
+ cluster_t* cluster, off_t* offset, int subentries)
+{
+ struct iterator it;
+ int rc;
+ const struct exfat_entry* entry;
+ int contiguous = 0;
+
+ rc = opendir(ef, dir, &it);
+ if (rc != 0)
+ return rc;
+ for (;;)
+ {
+ if (contiguous == 0)
+ {
+ *cluster = it.cluster;
+ *offset = it.offset;
+ }
+ 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;
+ }
+ }
+ closedir(&it);
+ return 0;
+}
+
+static int write_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);
+ int i;
+
+ 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(&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;
+ }
+ }
+
+ init_node_meta1(node, &meta1);
+ init_node_meta2(node, &meta2);
+
+ tree_attach(dir, node);
+ exfat_update_mtime(dir);
+ return 0;
+}
+
+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, &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));
+ if (rc != 0)
+ {
+ exfat_put_node(ef, dir);
+ return rc;
+ }
+ rc = write_entry(ef, dir, name, cluster, offset, attrib);
+ if (rc != 0)
+ {
+ exfat_put_node(ef, dir);
+ return rc;
+ }
+ rc = exfat_flush_node(ef, dir);
+ exfat_put_node(ef, dir);
+ return rc;
+}
+
+int exfat_mknod(struct exfat* ef, const char* path)
+{
+ return create(ef, path, EXFAT_ATTRIB_ARCH);
+}
+
+int exfat_mkdir(struct exfat* ef, const char* path)
+{
+ int rc;
+ struct exfat_node* node;
+
+ rc = create(ef, path, EXFAT_ATTRIB_DIR);
+ if (rc != 0)
+ return rc;
+ rc = exfat_lookup(ef, &node, path);
+ if (rc != 0)
+ return 0;
+ /* directories always have at least one cluster */
+ rc = exfat_truncate(ef, node, CLUSTER_SIZE(*ef->sb), true);
+ if (rc != 0)
+ {
+ delete(ef, node);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ rc = exfat_flush_node(ef, node);
+ if (rc != 0)
+ {
+ delete(ef, node);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ exfat_put_node(ef, node);
+ return 0;
+}
+
+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)
+{
+ 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;
+
+ 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);
+
+ if (!erase_entry(ef, node))
+ return -EIO;
+
+ node->entry_cluster = new_cluster;
+ node->entry_offset = new_offset;
+
+ 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));
+ 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, (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;
+ 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;
+ }
+
+ /* 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)
+ {
+ /* free clusters even if something went wrong; overwise they
+ will be just lost */
+ exfat_cleanup_node(ef, existing);
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ rc = exfat_cleanup_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)
+ {
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return rc;
+ }
+ rc = rename_entry(ef, dir, node, name, cluster, offset);
+ exfat_put_node(ef, dir);
+ exfat_put_node(ef, node);
+ return rc;
+}
+
+void exfat_utimes(struct exfat_node* node, const struct timespec tv[2])
+{
+ node->atime = tv[0].tv_sec;
+ node->mtime = tv[1].tv_sec;
+ node->flags |= EXFAT_ATTRIB_DIRTY;
+}
+
+void exfat_update_atime(struct exfat_node* node)
+{
+ node->atime = time(NULL);
+ node->flags |= EXFAT_ATTRIB_DIRTY;
+}
+
+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))
+ {
+ 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);