releasing package exfat-utils version 1.3.0-2

[sven/exfat-utils.git] / libexfat / cluster.c

diff --git a/libexfat/cluster.c b/libexfat/cluster.c
index 980e1cd5358b4fb8f6efdf5ff01f5cfae5aee2e6..15cd9aa339da22d8616be9d333c53021cf1ea219 100644 (file)
--- a/libexfat/cluster.c
+++ b/libexfat/cluster.c
@@ -2,11 +2,12 @@
        cluster.c (03.09.09)
        exFAT file system implementation library.
 
        cluster.c (03.09.09)
        exFAT file system implementation library.
 

-       Copyright (C) 2010-2013  Andrew Nayenko
+       Free exFAT implementation.
+       Copyright (C) 2010-2018  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,13 +15,15 @@
        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 <errno.h>
 #include <string.h>
 */
 
 #include "exfat.h"
 #include <errno.h>
 #include <string.h>

+#include <inttypes.h>

 
 /*
  * Sector to absolute offset.
 
 /*
  * Sector to absolute offset.


@@ -64,7 +67,7 @@ static cluster_t s2c(const struct exfat* ef, off_t sector)
 static uint32_t bytes2clusters(const struct exfat* ef, uint64_t bytes)
 {
        uint64_t cluster_size = CLUSTER_SIZE(*ef->sb);
 static uint32_t bytes2clusters(const struct exfat* ef, uint64_t bytes)
 {
        uint64_t cluster_size = CLUSTER_SIZE(*ef->sb);

-       return (bytes + cluster_size - 1) / cluster_size;
+       return DIV_ROUND_UP(bytes, cluster_size);

 }
 
 cluster_t exfat_next_cluster(const struct exfat* ef,
 }
 
 cluster_t exfat_next_cluster(const struct exfat* ef,


@@ -76,11 +79,13 @@ cluster_t exfat_next_cluster(const struct exfat* ef,
        if (cluster < EXFAT_FIRST_DATA_CLUSTER)
                exfat_bug("bad cluster 0x%x", cluster);
 
        if (cluster < EXFAT_FIRST_DATA_CLUSTER)
                exfat_bug("bad cluster 0x%x", cluster);
 

-       if (IS_CONTIGUOUS(*node))
+       if (node->is_contiguous)

                return cluster + 1;
        fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
                + cluster * sizeof(cluster_t);
                return cluster + 1;
        fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
                + cluster * sizeof(cluster_t);

-       exfat_pread(ef->dev, &next, sizeof(next), fat_offset);
+       if (exfat_pread(ef->dev, &next, sizeof(next), fat_offset) < 0)
+               return EXFAT_CLUSTER_BAD; /* the caller should handle this and print
+                                            appropriate error message */

        return le32_to_cpu(next);
 }
 
        return le32_to_cpu(next);
 }
 


@@ -98,7 +103,7 @@ cluster_t exfat_advance_cluster(const struct exfat* ef,
        for (i = node->fptr_index; i < count; i++)
        {
                node->fptr_cluster = exfat_next_cluster(ef, node, node->fptr_cluster);
        for (i = node->fptr_index; i < count; i++)
        {
                node->fptr_cluster = exfat_next_cluster(ef, node, node->fptr_cluster);

-               if (CLUSTER_INVALID(node->fptr_cluster))
+               if (CLUSTER_INVALID(*ef->sb, node->fptr_cluster))

                        break; /* the caller should handle this and print appropriate 
                                  error message */
        }
                        break; /* the caller should handle this and print appropriate 
                                  error message */
        }


@@ -106,18 +111,22 @@ cluster_t exfat_advance_cluster(const struct exfat* ef,
        return node->fptr_cluster;
 }
 
        return node->fptr_cluster;
 }
 

-static cluster_t find_bit_and_set(uint8_t* bitmap, size_t start, size_t end)
+static cluster_t find_bit_and_set(bitmap_t* bitmap, size_t start, size_t end)

 {
 {

-       const size_t start_index = start / 8;
-       const size_t end_index = DIV_ROUND_UP(end, 8);
+       const size_t start_index = start / sizeof(bitmap_t) / 8;
+       const size_t end_index = DIV_ROUND_UP(end, sizeof(bitmap_t) * 8);

        size_t i;
        size_t i;

+       size_t start_bitindex;
+       size_t end_bitindex;

        size_t c;
 
        for (i = start_index; i < end_index; i++)
        {
        size_t c;
 
        for (i = start_index; i < end_index; i++)
        {

-               if (bitmap[i] == 0xff)
+               if (bitmap[i] == ~((bitmap_t) 0))

                        continue;
                        continue;

-               for (c = MAX(i * 8, start); c < MIN((i + 1) * 8, end); c++)
+               start_bitindex = MAX(i * sizeof(bitmap_t) * 8, start);
+               end_bitindex = MIN((i + 1) * sizeof(bitmap_t) * 8, end);
+               for (c = start_bitindex; c < end_bitindex; c++)

                        if (BMAP_GET(bitmap, c) == 0)
                        {
                                BMAP_SET(bitmap, c);
                        if (BMAP_GET(bitmap, c) == 0)
                        {
                                BMAP_SET(bitmap, c);


@@ -127,25 +136,59 @@ static cluster_t find_bit_and_set(uint8_t* bitmap, size_t start, size_t end)
        return EXFAT_CLUSTER_END;
 }
 
        return EXFAT_CLUSTER_END;
 }
 

-void exfat_flush_cmap(struct exfat* ef)
+static int flush_nodes(struct exfat* ef, struct exfat_node* node)

 {
 {

-       exfat_pwrite(ef->dev, ef->cmap.chunk, (ef->cmap.chunk_size + 7) / 8,
-                       exfat_c2o(ef, ef->cmap.start_cluster));
-       ef->cmap.dirty = false;
+       struct exfat_node* p;
+
+       for (p = node->child; p != NULL; p = p->next)
+       {
+               int rc = flush_nodes(ef, p);
+               if (rc != 0)
+                       return rc;
+       }
+       return exfat_flush_node(ef, node);
+}
+
+int exfat_flush_nodes(struct exfat* ef)
+{
+       return flush_nodes(ef, ef->root);
+}
+
+int exfat_flush(struct exfat* ef)
+{
+       if (ef->cmap.dirty)
+       {
+               if (exfat_pwrite(ef->dev, ef->cmap.chunk,
+                               BMAP_SIZE(ef->cmap.chunk_size),
+                               exfat_c2o(ef, ef->cmap.start_cluster)) < 0)
+               {
+                       exfat_error("failed to write clusters bitmap");
+                       return -EIO;
+               }
+               ef->cmap.dirty = false;
+       }
+
+       return 0;

 }
 
 }
 

-static void set_next_cluster(const struct exfat* ef, int contiguous,
+static bool set_next_cluster(const struct exfat* ef, bool contiguous,

                cluster_t current, cluster_t next)
 {
        off_t fat_offset;
        le32_t next_le32;
 
        if (contiguous)
                cluster_t current, cluster_t next)
 {
        off_t fat_offset;
        le32_t next_le32;
 
        if (contiguous)

-               return;
+               return true;

        fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
                + current * sizeof(cluster_t);
        next_le32 = cpu_to_le32(next);
        fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
                + current * sizeof(cluster_t);
        next_le32 = cpu_to_le32(next);

-       exfat_pwrite(ef->dev, &next_le32, sizeof(next_le32), fat_offset);
+       if (exfat_pwrite(ef->dev, &next_le32, sizeof(next_le32), fat_offset) < 0)
+       {
+               exfat_error("failed to write the next cluster %#x after %#x", next,
+                               current);
+               return false;
+       }
+       return true;

 }
 
 static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)
 }
 
 static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)


@@ -171,23 +214,23 @@ static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)
 
 static void free_cluster(struct exfat* ef, cluster_t cluster)
 {
 
 static void free_cluster(struct exfat* ef, cluster_t cluster)
 {

-       if (CLUSTER_INVALID(cluster))
-               exfat_bug("freeing invalid cluster 0x%x", cluster);

        if (cluster - EXFAT_FIRST_DATA_CLUSTER >= ef->cmap.size)
        if (cluster - EXFAT_FIRST_DATA_CLUSTER >= ef->cmap.size)

-               exfat_bug("freeing non-existing cluster 0x%x (0x%x)", cluster,
+               exfat_bug("caller must check cluster validity (%#x, %#x)", cluster,

                                ef->cmap.size);
 
        BMAP_CLR(ef->cmap.chunk, cluster - EXFAT_FIRST_DATA_CLUSTER);
        ef->cmap.dirty = true;
 }
 
                                ef->cmap.size);
 
        BMAP_CLR(ef->cmap.chunk, cluster - EXFAT_FIRST_DATA_CLUSTER);
        ef->cmap.dirty = true;
 }
 

-static void make_noncontiguous(const struct exfat* ef, cluster_t first,
+static bool make_noncontiguous(const struct exfat* ef, cluster_t first,

                cluster_t last)
 {
        cluster_t c;
 
        for (c = first; c < last; c++)
                cluster_t last)
 {
        cluster_t c;
 
        for (c = first; c < last; c++)

-               set_next_cluster(ef, 0, c, c + 1);
+               if (!set_next_cluster(ef, false, c, c + 1))
+                       return false;
+       return true;

 }
 
 static int shrink_file(struct exfat* ef, struct exfat_node* node,
 }
 
 static int shrink_file(struct exfat* ef, struct exfat_node* node,


@@ -207,7 +250,7 @@ static int grow_file(struct exfat* ef, struct exfat_node* node,
        {
                /* get the last cluster of the file */
                previous = exfat_advance_cluster(ef, node, current - 1);
        {
                /* get the last cluster of the file */
                previous = exfat_advance_cluster(ef, node, current - 1);

-               if (CLUSTER_INVALID(previous))
+               if (CLUSTER_INVALID(*ef->sb, previous))

                {
                        exfat_error("invalid cluster 0x%x while growing", previous);
                        return -EIO;
                {
                        exfat_error("invalid cluster 0x%x while growing", previous);
                        return -EIO;


@@ -220,37 +263,41 @@ static int grow_file(struct exfat* ef, struct exfat_node* node,
                /* file does not have clusters (i.e. is empty), allocate
                   the first one for it */
                previous = allocate_cluster(ef, 0);
                /* file does not have clusters (i.e. is empty), allocate
                   the first one for it */
                previous = allocate_cluster(ef, 0);

-               if (CLUSTER_INVALID(previous))
+               if (CLUSTER_INVALID(*ef->sb, previous))

                        return -ENOSPC;
                node->fptr_cluster = node->start_cluster = previous;
                allocated = 1;
                /* file consists of only one cluster, so it's contiguous */
                        return -ENOSPC;
                node->fptr_cluster = node->start_cluster = previous;
                allocated = 1;
                /* file consists of only one cluster, so it's contiguous */

-               node->flags |= EXFAT_ATTRIB_CONTIGUOUS;
+               node->is_contiguous = true;

        }
 
        while (allocated < difference)
        {
                next = allocate_cluster(ef, previous + 1);
        }
 
        while (allocated < difference)
        {
                next = allocate_cluster(ef, previous + 1);

-               if (CLUSTER_INVALID(next))
+               if (CLUSTER_INVALID(*ef->sb, next))

                {
                        if (allocated != 0)
                                shrink_file(ef, node, current + allocated, allocated);
                        return -ENOSPC;
                }
                {
                        if (allocated != 0)
                                shrink_file(ef, node, current + allocated, allocated);
                        return -ENOSPC;
                }

-               if (next != previous - 1 && IS_CONTIGUOUS(*node))
+               if (next != previous - 1 && node->is_contiguous)

                {
                        /* it's a pity, but we are not able to keep the file contiguous
                           anymore */
                {
                        /* it's a pity, but we are not able to keep the file contiguous
                           anymore */

-                       make_noncontiguous(ef, node->start_cluster, previous);
-                       node->flags &= ~EXFAT_ATTRIB_CONTIGUOUS;
-                       node->flags |= EXFAT_ATTRIB_DIRTY;
+                       if (!make_noncontiguous(ef, node->start_cluster, previous))
+                               return -EIO;
+                       node->is_contiguous = false;
+                       node->is_dirty = true;

                }
                }

-               set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, next);
+               if (!set_next_cluster(ef, node->is_contiguous, previous, next))
+                       return -EIO;

                previous = next;
                allocated++;
        }
 
                previous = next;
                allocated++;
        }
 

-       set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, EXFAT_CLUSTER_END);
+       if (!set_next_cluster(ef, node->is_contiguous, previous,
+                       EXFAT_CLUSTER_END))
+               return -EIO;

        return 0;
 }
 
        return 0;
 }
 


@@ -272,18 +319,21 @@ static int shrink_file(struct exfat* ef, struct exfat_node* node,
        {
                cluster_t last = exfat_advance_cluster(ef, node,
                                current - difference - 1);
        {
                cluster_t last = exfat_advance_cluster(ef, node,
                                current - difference - 1);

-               if (CLUSTER_INVALID(last))
+               if (CLUSTER_INVALID(*ef->sb, last))

                {
                        exfat_error("invalid cluster 0x%x while shrinking", last);
                        return -EIO;
                }
                previous = exfat_next_cluster(ef, node, last);
                {
                        exfat_error("invalid cluster 0x%x while shrinking", last);
                        return -EIO;
                }
                previous = exfat_next_cluster(ef, node, last);

-               set_next_cluster(ef, IS_CONTIGUOUS(*node), last, EXFAT_CLUSTER_END);
+               if (!set_next_cluster(ef, node->is_contiguous, last,
+                               EXFAT_CLUSTER_END))
+                       return -EIO;

        }
        else
        {
                previous = node->start_cluster;
                node->start_cluster = EXFAT_CLUSTER_FREE;
        }
        else
        {
                previous = node->start_cluster;
                node->start_cluster = EXFAT_CLUSTER_FREE;

+               node->is_dirty = true;

        }
        node->fptr_index = 0;
        node->fptr_cluster = node->start_cluster;
        }
        node->fptr_index = 0;
        node->fptr_cluster = node->start_cluster;


@@ -291,24 +341,31 @@ static int shrink_file(struct exfat* ef, struct exfat_node* node,
        /* free remaining clusters */
        while (difference--)
        {
        /* free remaining clusters */
        while (difference--)
        {

-               if (CLUSTER_INVALID(previous))
+               if (CLUSTER_INVALID(*ef->sb, previous))

                {
                        exfat_error("invalid cluster 0x%x while freeing after shrink",
                                        previous);
                        return -EIO;
                }
                {
                        exfat_error("invalid cluster 0x%x while freeing after shrink",
                                        previous);
                        return -EIO;
                }

+

                next = exfat_next_cluster(ef, node, previous);
                next = exfat_next_cluster(ef, node, previous);

-               set_next_cluster(ef, IS_CONTIGUOUS(*node), previous,
-                               EXFAT_CLUSTER_FREE);
+               if (!set_next_cluster(ef, node->is_contiguous, previous,
+                               EXFAT_CLUSTER_FREE))
+                       return -EIO;

                free_cluster(ef, previous);
                previous = next;
        }
        return 0;
 }
 
                free_cluster(ef, previous);
                previous = next;
        }
        return 0;
 }
 

-static void erase_raw(struct exfat* ef, size_t size, off_t offset)
+static bool erase_raw(struct exfat* ef, size_t size, off_t offset)

 {
 {

-       exfat_pwrite(ef->dev, ef->zero_cluster, size, offset);
+       if (exfat_pwrite(ef->dev, ef->zero_cluster, size, offset) < 0)
+       {
+               exfat_error("failed to erase %zu bytes at %"PRId64, size, offset);
+               return false;
+       }
+       return true;

 }
 
 static int erase_range(struct exfat* ef, struct exfat_node* node,
 }
 
 static int erase_range(struct exfat* ef, struct exfat_node* node,


@@ -323,28 +380,31 @@ static int erase_range(struct exfat* ef, struct exfat_node* node,
        cluster_boundary = (begin | (CLUSTER_SIZE(*ef->sb) - 1)) + 1;
        cluster = exfat_advance_cluster(ef, node,
                        begin / CLUSTER_SIZE(*ef->sb));
        cluster_boundary = (begin | (CLUSTER_SIZE(*ef->sb) - 1)) + 1;
        cluster = exfat_advance_cluster(ef, node,
                        begin / CLUSTER_SIZE(*ef->sb));

-       if (CLUSTER_INVALID(cluster))
+       if (CLUSTER_INVALID(*ef->sb, cluster))

        {
                exfat_error("invalid cluster 0x%x while erasing", cluster);
                return -EIO;
        }
        /* erase from the beginning to the closest cluster boundary */
        {
                exfat_error("invalid cluster 0x%x while erasing", cluster);
                return -EIO;
        }
        /* erase from the beginning to the closest cluster boundary */

-       erase_raw(ef, MIN(cluster_boundary, end) - begin,
-                       exfat_c2o(ef, cluster) + begin % CLUSTER_SIZE(*ef->sb));
+       if (!erase_raw(ef, MIN(cluster_boundary, end) - begin,
+                       exfat_c2o(ef, cluster) + begin % CLUSTER_SIZE(*ef->sb)))
+               return -EIO;

        /* erase whole clusters */
        while (cluster_boundary < end)
        {
                cluster = exfat_next_cluster(ef, node, cluster);
                /* the cluster cannot be invalid because we have just allocated it */
        /* erase whole clusters */
        while (cluster_boundary < end)
        {
                cluster = exfat_next_cluster(ef, node, cluster);
                /* the cluster cannot be invalid because we have just allocated it */

-               if (CLUSTER_INVALID(cluster))
+               if (CLUSTER_INVALID(*ef->sb, cluster))

                        exfat_bug("invalid cluster 0x%x after allocation", cluster);
                        exfat_bug("invalid cluster 0x%x after allocation", cluster);

-               erase_raw(ef, CLUSTER_SIZE(*ef->sb), exfat_c2o(ef, cluster));
+               if (!erase_raw(ef, CLUSTER_SIZE(*ef->sb), exfat_c2o(ef, cluster)))
+                       return -EIO;

                cluster_boundary += CLUSTER_SIZE(*ef->sb);
        }
        return 0;
 }
 
                cluster_boundary += CLUSTER_SIZE(*ef->sb);
        }
        return 0;
 }
 

-int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size)
+int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size,
+               bool erase)

 {
        uint32_t c1 = bytes2clusters(ef, node->size);
        uint32_t c2 = bytes2clusters(ef, size);
 {
        uint32_t c1 = bytes2clusters(ef, node->size);
        uint32_t c2 = bytes2clusters(ef, size);


@@ -364,13 +424,16 @@ int exfat_truncate(struct exfat* ef, struct exfat_node* node, uint64_t size)
        if (rc != 0)
                return rc;
 
        if (rc != 0)
                return rc;
 

-       rc = erase_range(ef, node, node->size, size);
-       if (rc != 0)
-               return rc;
+       if (erase)
+       {
+               rc = erase_range(ef, node, node->size, size);
+               if (rc != 0)
+                       return rc;
+       }

 
        exfat_update_mtime(node);
        node->size = size;
 
        exfat_update_mtime(node);
        node->size = size;

-       node->flags |= EXFAT_ATTRIB_DIRTY;
+       node->is_dirty = true;

        return 0;
 }
 
        return 0;
 }