Imported Upstream version 1.0.0

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

diff --git a/libexfat/cluster.c b/libexfat/cluster.c
index 0418932ec802f66590fcf29139a2d075aa64e335..980e1cd5358b4fb8f6efdf5ff01f5cfae5aee2e6 100644 (file)
--- a/libexfat/cluster.c
+++ b/libexfat/cluster.c
@@ -2,7 +2,7 @@
        cluster.c (03.09.09)
        exFAT file system implementation library.
 
-       Copyright (C) 2010-2012  Andrew Nayenko
+       Copyright (C) 2010-2013  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
@@ -99,47 +99,31 @@ cluster_t exfat_advance_cluster(const struct exfat* ef,
        {
                node->fptr_cluster = exfat_next_cluster(ef, node, node->fptr_cluster);
                if (CLUSTER_INVALID(node->fptr_cluster))
-                       break;
+                       break; /* the caller should handle this and print appropriate 
+                                 error message */
        }
        node->fptr_index = count;
        return node->fptr_cluster;
 }
 
-static cluster_t find_bit_and_set(uint8_t* bitmap, cluster_t start,
-               cluster_t end)
+static cluster_t find_bit_and_set(uint8_t* bitmap, size_t start, size_t end)
 {
-       const cluster_t mid_start = (start + 7) / 8 * 8;
-       const cluster_t mid_end = end / 8 * 8;
-       cluster_t c;
-       cluster_t byte;
-
-       for (c = start; c < mid_start; c++)
-               if (BMAP_GET(bitmap, c) == 0)
-               {
-                       BMAP_SET(bitmap, c);
-                       return c + EXFAT_FIRST_DATA_CLUSTER;
-               }
-
-       for (byte = mid_start / 8; byte < mid_end / 8; byte++)
-               if (bitmap[byte] != 0xff)
-               {
-                       cluster_t bit;
-
-                       for (bit = 0; bit < 8; bit++)
-                               if (!(bitmap[byte] & (1u << bit)))
-                               {
-                                       bitmap[byte] |= (1u << bit);
-                                       return byte * 8 + bit + EXFAT_FIRST_DATA_CLUSTER;
-                               }
-               }
-
-       for (c = mid_end; c < end; c++)
-               if (BMAP_GET(bitmap, c) == 0)
-               {
-                       BMAP_SET(bitmap, c);
-                       return c + EXFAT_FIRST_DATA_CLUSTER;
-               }
+       const size_t start_index = start / 8;
+       const size_t end_index = DIV_ROUND_UP(end, 8);
+       size_t i;
+       size_t c;
 
+       for (i = start_index; i < end_index; i++)
+       {
+               if (bitmap[i] == 0xff)
+                       continue;
+               for (c = MAX(i * 8, start); c < MIN((i + 1) * 8, end); c++)
+                       if (BMAP_GET(bitmap, c) == 0)
+                       {
+                               BMAP_SET(bitmap, c);
+                               return c + EXFAT_FIRST_DATA_CLUSTER;
+                       }
+       }
        return EXFAT_CLUSTER_END;
 }
 
@@ -147,7 +131,7 @@ void exfat_flush_cmap(struct exfat* ef)
 {
        exfat_pwrite(ef->dev, ef->cmap.chunk, (ef->cmap.chunk_size + 7) / 8,
                        exfat_c2o(ef, ef->cmap.start_cluster));
-       ef->cmap.dirty = 0;
+       ef->cmap.dirty = false;
 }
 
 static void set_next_cluster(const struct exfat* ef, int contiguous,
@@ -181,20 +165,20 @@ static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)
                return EXFAT_CLUSTER_END;
        }
 
-       ef->cmap.dirty = 1;
+       ef->cmap.dirty = true;
        return cluster;
 }
 
 static void free_cluster(struct exfat* ef, cluster_t cluster)
 {
        if (CLUSTER_INVALID(cluster))
-               exfat_bug("attempting to free invalid cluster");
-       if (cluster < EXFAT_FIRST_DATA_CLUSTER ||
-               cluster - EXFAT_FIRST_DATA_CLUSTER >= ef->cmap.size)
-               exfat_bug("bad cluster 0x%x (0x%x)", cluster, ef->cmap.size);
+               exfat_bug("freeing invalid cluster 0x%x", cluster);
+       if (cluster - EXFAT_FIRST_DATA_CLUSTER >= ef->cmap.size)
+               exfat_bug("freeing non-existing cluster 0x%x (0x%x)", cluster,
+                               ef->cmap.size);
 
        BMAP_CLR(ef->cmap.chunk, cluster - EXFAT_FIRST_DATA_CLUSTER);
-       ef->cmap.dirty = 1;
+       ef->cmap.dirty = true;
 }
 
 static void make_noncontiguous(const struct exfat* ef, cluster_t first,
@@ -225,7 +209,7 @@ static int grow_file(struct exfat* ef, struct exfat_node* node,
                previous = exfat_advance_cluster(ef, node, current - 1);
                if (CLUSTER_INVALID(previous))
                {
-                       exfat_error("invalid cluster in file");
+                       exfat_error("invalid cluster 0x%x while growing", previous);
                        return -EIO;
                }
        }
@@ -290,7 +274,7 @@ static int shrink_file(struct exfat* ef, struct exfat_node* node,
                                current - difference - 1);
                if (CLUSTER_INVALID(last))
                {
-                       exfat_error("invalid cluster in file");
+                       exfat_error("invalid cluster 0x%x while shrinking", last);
                        return -EIO;
                }
                previous = exfat_next_cluster(ef, node, last);
@@ -309,7 +293,8 @@ static int shrink_file(struct exfat* ef, struct exfat_node* node,
        {
                if (CLUSTER_INVALID(previous))
                {
-                       exfat_error("invalid cluster in file");
+                       exfat_error("invalid cluster 0x%x while freeing after shrink",
+                                       previous);
                        return -EIO;
                }
                next = exfat_next_cluster(ef, node, previous);
@@ -340,7 +325,7 @@ static int erase_range(struct exfat* ef, struct exfat_node* node,
                        begin / CLUSTER_SIZE(*ef->sb));
        if (CLUSTER_INVALID(cluster))
        {
-               exfat_error("invalid cluster in file");
+               exfat_error("invalid cluster 0x%x while erasing", cluster);
                return -EIO;
        }
        /* erase from the beginning to the closest cluster boundary */
@@ -352,7 +337,7 @@ static int erase_range(struct exfat* ef, struct exfat_node* node,
                cluster = exfat_next_cluster(ef, node, cluster);
                /* the cluster cannot be invalid because we have just allocated it */
                if (CLUSTER_INVALID(cluster))
-                       exfat_bug("invalid cluster in file");
+                       exfat_bug("invalid cluster 0x%x after allocation", cluster);
                erase_raw(ef, CLUSTER_SIZE(*ef->sb), exfat_c2o(ef, cluster));
                cluster_boundary += CLUSTER_SIZE(*ef->sb);
        }