Relicensed the code from GPLv3+ to GPLv2+.

[android-x86/external-exfat.git] / libexfat / node.c

diff --git a/libexfat/node.c b/libexfat/node.c
index e0d09a5..0c6800d 100644 (file)
--- a/libexfat/node.c
+++ b/libexfat/node.c
@@ -2,11 +2,12 @@
        node.c (09.10.09)
        exFAT file system implementation library.
 
        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
        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,
        (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.
 
        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/>.
+       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"
 */
 
 #include "exfat.h"


@@ -44,8 +46,8 @@ void exfat_put_node(struct exfat* ef, struct exfat_node* node)
 {
        if (--node->references < 0)
        {
 {
        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);
        }
 
                exfat_bug("reference counter of `%s' is below zero", buffer);
        }
 


@@ -56,7 +58,7 @@ void exfat_put_node(struct exfat* ef, struct exfat_node* node)
                if (node->flags & EXFAT_ATTRIB_UNLINKED)
                {
                        /* free all clusters and node structure itself */
                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)
                        free(node);
                }
                if (ef->cmap.dirty)


@@ -86,8 +88,8 @@ static int opendir(struct exfat* ef, const struct exfat_node* dir,
                exfat_error("out of memory");
                return -ENOMEM;
        }
                exfat_error("out of memory");
                return -ENOMEM;
        }

-       exfat_read_raw(it->chunk, CLUSTER_SIZE(*ef->sb),
-                       exfat_c2o(ef, it->cluster), ef->fd);
+       exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
+                       exfat_c2o(ef, it->cluster));

        return 0;
 }
 
        return 0;
 }
 


@@ -115,11 +117,12 @@ static int fetch_next_entry(struct exfat* ef, const struct exfat_node* parent,
                it->cluster = exfat_next_cluster(ef, parent, it->cluster);
                if (CLUSTER_INVALID(it->cluster))
                {
                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;
                }
                        return 1;
                }

-               exfat_read_raw(it->chunk, CLUSTER_SIZE(*ef->sb),
-                               exfat_c2o(ef, it->cluster), ef->fd);
+               exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
+                               exfat_c2o(ef, it->cluster));

        }
        return 0;
 }
        }
        return 0;
 }


@@ -182,6 +185,7 @@ 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;
        le16_t* namep = NULL;
        uint16_t reference_checksum = 0;
        uint16_t actual_checksum = 0;

+       uint64_t real_size = 0;

 
        *node = NULL;
 
 
        *node = NULL;
 


@@ -246,18 +250,7 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                        }
                        init_node_meta2(*node, meta2);
                        actual_checksum = exfat_add_checksum(entry, actual_checksum);
                        }
                        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)
-                       {
-                               exfat_error("real size does not equal to size "
-                                               "(%"PRIu64" != %"PRIu64")",
-                                               le64_to_cpu(meta2->real_size), (*node)->size);
-                               goto error;
-                       }
+                       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))
                        {
                        /* empty files must be marked as non-contiguous */
                        if ((*node)->size == 0 && (meta2->flags & EXFAT_FLAG_CONTIGUOUS))
                        {


@@ -269,11 +262,8 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                        if (((*node)->flags & EXFAT_ATTRIB_DIR) &&
                                (*node)->size % CLUSTER_SIZE(*ef->sb) != 0)
                        {
                        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;
                                goto error;
                        }
                        --continuations;


@@ -292,10 +282,34 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                        namep += EXFAT_ENAME_MAX;
                        if (--continuations == 0)
                        {
                        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)
                                {
                                if (actual_checksum != reference_checksum)
                                {

-                                       exfat_error("invalid checksum (0x%hx != 0x%hx)",
-                                                       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;
                                }
                                if (fetch_next_entry(ef, parent, it) != 0)


@@ -310,7 +324,8 @@ 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)))
                        {
                        upcase = (const struct exfat_entry_upcase*) entry;
                        if (CLUSTER_INVALID(le32_to_cpu(upcase->start_cluster)))
                        {

-                               exfat_error("invalid cluster in upcase table");
+                               exfat_error("invalid cluster 0x%x in upcase table",
+                                               le32_to_cpu(upcase->start_cluster));

                                goto error;
                        }
                        if (le64_to_cpu(upcase->size) == 0 ||
                                goto error;
                        }
                        if (le64_to_cpu(upcase->size) == 0 ||


@@ -331,15 +346,17 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                        }
                        ef->upcase_chars = le64_to_cpu(upcase->size) / sizeof(le16_t);
 
                        }
                        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);
+                       exfat_pread(ef->dev, ef->upcase, le64_to_cpu(upcase->size),
+                                       exfat_c2o(ef, le32_to_cpu(upcase->start_cluster)));

                        break;
 
                case EXFAT_ENTRY_BITMAP:
                        bitmap = (const struct exfat_entry_bitmap*) entry;
                        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");
+                               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) -
                                goto error;
                        }
                        ef->cmap.size = le32_to_cpu(ef->sb->cluster_count) -


@@ -351,7 +368,6 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                                                le64_to_cpu(bitmap->size), (ef->cmap.size + 7) / 8);
                                goto error;
                        }
                                                le64_to_cpu(bitmap->size), (ef->cmap.size + 7) / 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));
                        /* 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));


@@ -363,8 +379,8 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                                goto error;
                        }
 
                                goto error;
                        }
 

-                       exfat_read_raw(ef->cmap.chunk, le64_to_cpu(bitmap->size),
-                                       exfat_c2o(ef, ef->cmap.start_cluster), ef->fd);
+                       exfat_pread(ef->dev, ef->cmap.chunk, le64_to_cpu(bitmap->size),
+                                       exfat_c2o(ef, ef->cmap.start_cluster));

                        break;
 
                case EXFAT_ENTRY_LABEL:
                        break;
 
                case EXFAT_ENTRY_LABEL:


@@ -375,7 +391,7 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                                goto error;
                        }
                        if (utf16_to_utf8(ef->label, label->name,
                                goto error;
                        }
                        if (utf16_to_utf8(ef->label, label->name,

-                                               sizeof(ef->label), EXFAT_ENAME_MAX) != 0)
+                                               sizeof(ef->label) - 1, EXFAT_ENAME_MAX) != 0)

                                goto error;
                        break;
 
                                goto error;
                        break;
 


@@ -443,28 +459,49 @@ int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir)
        return 0;
 }
 
        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)
        {
        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);
        }
                exfat_warn("non-zero reference counter (%d) for `%s'",
                                node->references, buffer);
        }

-       while (node->references--)
+       while (node->references)

                exfat_put_node(ef, node);
                exfat_put_node(ef, node);

-       node->child = NULL;
-       node->flags &= ~EXFAT_ATTRIB_CACHED;

 }
 
 void exfat_reset_cache(struct exfat* ef)
 }
 
 void exfat_reset_cache(struct exfat* ef)


@@ -472,7 +509,7 @@ void exfat_reset_cache(struct exfat* ef)
        reset_cache(ef, ef->root);
 }
 
        reset_cache(ef, ef->root);
 }
 

-void next_entry(struct exfat* ef, const struct exfat_node* parent,
+static void next_entry(struct exfat* ef, const struct exfat_node* parent,

                cluster_t* cluster, off_t* offset)
 {
        *offset += sizeof(struct exfat_entry);
                cluster_t* cluster, off_t* offset)
 {
        *offset += sizeof(struct exfat_entry);


@@ -501,14 +538,14 @@ void exfat_flush_node(struct exfat* ef, struct exfat_node* node)
        next_entry(ef, node->parent, &cluster, &offset);
        meta2_offset = co2o(ef, cluster, offset);
 
        next_entry(ef, node->parent, &cluster, &offset);
        meta2_offset = co2o(ef, cluster, offset);
 

-       exfat_read_raw(&meta1, sizeof(meta1), meta1_offset, ef->fd);
+       exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset);

        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, &meta1.mtime_cs);
        exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL);
 
        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, &meta1.mtime_cs);
        exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL);
 

-       exfat_read_raw(&meta2, sizeof(meta2), meta2_offset, ef->fd);
+       exfat_pread(ef->dev, &meta2, sizeof(meta2), meta2_offset);

        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);
        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);


@@ -521,8 +558,8 @@ void exfat_flush_node(struct exfat* ef, struct exfat_node* node)
 
        meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
 
 
        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);
+       exfat_pwrite(ef->dev, &meta1, sizeof(meta1), meta1_offset);
+       exfat_pwrite(ef->dev, &meta2, sizeof(meta2), meta2_offset);

 
        node->flags &= ~EXFAT_ATTRIB_DIRTY;
 }
 
        node->flags &= ~EXFAT_ATTRIB_DIRTY;
 }


@@ -535,42 +572,18 @@ static void erase_entry(struct exfat* ef, struct exfat_node* node)
        uint8_t entry_type;
 
        entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID;
        uint8_t entry_type;
 
        entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID;

-       exfat_write_raw(&entry_type, 1, co2o(ef, cluster, offset), ef->fd);
+       exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));

 
        next_entry(ef, node->parent, &cluster, &offset);
        entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;
 
        next_entry(ef, node->parent, &cluster, &offset);
        entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;

-       exfat_write_raw(&entry_type, 1, co2o(ef, cluster, offset), ef->fd);
+       exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));

 
        while (name_entries--)
        {
                next_entry(ef, node->parent, &cluster, &offset);
                entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID;
 
        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, co2o(ef, cluster, offset), ef->fd);
-       }
-}
-
-static void tree_detach(struct exfat_node* node)
-{
-       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;
-}
-
-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;
+               exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));

        }
        }

-       dir->child = node;

 }
 
 static int shrink_directory(struct exfat* ef, struct exfat_node* dir,
 }
 
 static int shrink_directory(struct exfat* ef, struct exfat_node* dir,


@@ -616,7 +629,7 @@ static int shrink_directory(struct exfat* ef, struct exfat_node* dir,
                new_size = CLUSTER_SIZE(*ef->sb);
        if (new_size == dir->size)
                return 0;
                new_size = CLUSTER_SIZE(*ef->sb);
        if (new_size == dir->size)
                return 0;

-       rc = exfat_truncate(ef, dir, new_size);
+       rc = exfat_truncate(ef, dir, new_size, true);

        if (rc != 0)
                return rc;
        return 0;
        if (rc != 0)
                return rc;
        return 0;


@@ -662,7 +675,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))
 {
        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,
 }
 
 static int find_slot(struct exfat* ef, struct exfat_node* dir,


@@ -746,17 +759,17 @@ static int write_entry(struct exfat* ef, struct exfat_node* dir,
 
        meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
 
 
        meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
 

-       exfat_write_raw(&meta1, sizeof(meta1), co2o(ef, cluster, offset), ef->fd);
+       exfat_pwrite(ef->dev, &meta1, sizeof(meta1), co2o(ef, cluster, offset));

        next_entry(ef, dir, &cluster, &offset);
        next_entry(ef, dir, &cluster, &offset);

-       exfat_write_raw(&meta2, sizeof(meta2), co2o(ef, cluster, offset), ef->fd);
+       exfat_pwrite(ef->dev, &meta2, sizeof(meta2), co2o(ef, cluster, offset));

        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);
        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),
-                               co2o(ef, cluster, offset), ef->fd);
+               exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
+                               co2o(ef, cluster, offset));

        }
 
        init_node_meta1(node, &meta1);
        }
 
        init_node_meta1(node, &meta1);


@@ -815,7 +828,7 @@ int exfat_mkdir(struct exfat* ef, const char* path)
        if (rc != 0)
                return 0;
        /* directories always have at least one cluster */
        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);
        if (rc != 0)
        {
                delete(ef, node);


@@ -838,11 +851,11 @@ 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;
 
        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);
+       exfat_pread(ef->dev, &meta1, sizeof(meta1),
+                       co2o(ef, old_cluster, old_offset));

        next_entry(ef, node->parent, &old_cluster, &old_offset);
        next_entry(ef, node->parent, &old_cluster, &old_offset);

-       exfat_read_raw(&meta2, sizeof(meta2), co2o(ef, old_cluster, old_offset),
-                       ef->fd);
+       exfat_pread(ef->dev, &meta2, sizeof(meta2),
+                       co2o(ef, old_cluster, old_offset));

        meta1.continuations = 1 + name_entries;
        meta2.name_hash = exfat_calc_name_hash(ef, name);
        meta2.name_length = name_length;
        meta1.continuations = 1 + name_entries;
        meta2.name_hash = exfat_calc_name_hash(ef, name);
        meta2.name_length = name_length;


@@ -853,11 +866,11 @@ static void rename_entry(struct exfat* ef, struct exfat_node* dir,
        node->entry_cluster = new_cluster;
        node->entry_offset = new_offset;
 
        node->entry_cluster = new_cluster;
        node->entry_offset = new_offset;
 

-       exfat_write_raw(&meta1, sizeof(meta1), co2o(ef, new_cluster, new_offset),
-                       ef->fd);
+       exfat_pwrite(ef->dev, &meta1, sizeof(meta1),
+                       co2o(ef, new_cluster, new_offset));

        next_entry(ef, dir, &new_cluster, &new_offset);
        next_entry(ef, dir, &new_cluster, &new_offset);

-       exfat_write_raw(&meta2, sizeof(meta2), co2o(ef, new_cluster, new_offset),
-                       ef->fd);
+       exfat_pwrite(ef->dev, &meta2, sizeof(meta2),
+                       co2o(ef, new_cluster, new_offset));

 
        for (i = 0; i < name_entries; i++)
        {
 
        for (i = 0; i < name_entries; i++)
        {


@@ -865,8 +878,8 @@ static void rename_entry(struct exfat* ef, struct exfat_node* dir,
                memcpy(name_entry.name, name + i * EXFAT_ENAME_MAX,
                                EXFAT_ENAME_MAX * sizeof(le16_t));
                next_entry(ef, dir, &new_cluster, &new_offset);
                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);
+               exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
+                               co2o(ef, new_cluster, new_offset));

        }
 
        memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t));
        }
 
        memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t));


@@ -894,29 +907,52 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path)
                exfat_put_node(ef, node);
                return rc;
        }
                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)
        {
        if (existing != NULL)
        {

-               if (existing->flags & EXFAT_ATTRIB_DIR)
+               /* remove target if it's not the same node as source */
+               if (existing != node)

                {
                {

-                       if (node->flags & EXFAT_ATTRIB_DIR)
-                               rc = exfat_rmdir(ef, existing);
+                       if (existing->flags & EXFAT_ATTRIB_DIR)
+                       {
+                               if (node->flags & EXFAT_ATTRIB_DIR)
+                                       rc = exfat_rmdir(ef, existing);
+                               else
+                                       rc = -ENOTDIR;
+                       }

                        else
                        else

-                               rc = -ENOTDIR;
+                       {
+                               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
                }
                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;
-               }
+                       exfat_put_node(ef, existing);

        }
 
        rc = find_slot(ef, dir, &cluster, &offset,
        }
 
        rc = find_slot(ef, dir, &cluster, &offset,


@@ -1015,7 +1051,8 @@ int exfat_set_label(struct exfat* ef, const char* label)
        if (entry.length == 0)
                entry.type ^= EXFAT_ENTRY_VALID;
 
        if (entry.length == 0)
                entry.type ^= EXFAT_ENTRY_VALID;
 

-       exfat_write_raw(&entry, sizeof(struct exfat_entry_label),
-                       co2o(ef, cluster, offset), ef->fd);
+       exfat_pwrite(ef->dev, &entry, sizeof(struct exfat_entry_label),
+                       co2o(ef, cluster, offset));
+       strcpy(ef->label, label);

        return 0;
 }
        return 0;
 }