Remove config.log, in the clean target (via override dh_auto_clean).
[sven/exfat-utils.git] / libexfat / cluster.c
index 8bea507bf411569363fe4e796950ecab8eb185b1..1257c7ae45c3789ce500aeaebe115a9640ede72c 100644 (file)
@@ -80,7 +80,7 @@ cluster_t exfat_next_cluster(const struct exfat* ef,
                return cluster + 1;
        fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
                + cluster * sizeof(cluster_t);
-       exfat_read_raw(&next, sizeof(next), fat_offset, ef->fd);
+       exfat_pread(ef->dev, &next, sizeof(next), fat_offset);
        return le32_to_cpu(next);
 }
 
@@ -145,8 +145,8 @@ static cluster_t find_bit_and_set(uint8_t* bitmap, cluster_t start,
 
 void exfat_flush_cmap(struct exfat* ef)
 {
-       exfat_write_raw(ef->cmap.chunk, (ef->cmap.chunk_size + 7) / 8,
-                       exfat_c2o(ef, ef->cmap.start_cluster), ef->fd);
+       exfat_pwrite(ef->dev, ef->cmap.chunk, (ef->cmap.chunk_size + 7) / 8,
+                       exfat_c2o(ef, ef->cmap.start_cluster));
        ef->cmap.dirty = 0;
 }
 
@@ -161,7 +161,7 @@ static void set_next_cluster(const struct exfat* ef, int contiguous,
        fat_offset = s2o(ef, le32_to_cpu(ef->sb->fat_sector_start))
                + current * sizeof(cluster_t);
        next_le32 = cpu_to_le32(next);
-       exfat_write_raw(&next_le32, sizeof(next_le32), fat_offset, ef->fd);
+       exfat_pwrite(ef->dev, &next_le32, sizeof(next_le32), fat_offset);
 }
 
 static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)
@@ -182,7 +182,6 @@ static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)
        }
 
        ef->cmap.dirty = 1;
-       /* FIXME update percentage of used space */
        return cluster;
 }
 
@@ -196,7 +195,6 @@ static void free_cluster(struct exfat* ef, cluster_t cluster)
 
        BMAP_CLR(ef->cmap.chunk, cluster - EXFAT_FIRST_DATA_CLUSTER);
        ef->cmap.dirty = 1;
-       /* FIXME update percentage of used space */
 }
 
 static void make_noncontiguous(const struct exfat* ef, cluster_t first,
@@ -325,37 +323,38 @@ static int shrink_file(struct exfat* ef, struct exfat_node* node,
 
 static void erase_raw(struct exfat* ef, size_t size, off_t offset)
 {
-       exfat_write_raw(ef->zero_sector, size, offset, ef->fd);
+       exfat_pwrite(ef->dev, ef->zero_cluster, size, offset);
 }
 
 static int erase_range(struct exfat* ef, struct exfat_node* node,
                uint64_t begin, uint64_t end)
 {
-       uint64_t sector_boundary;
+       uint64_t cluster_boundary;
        cluster_t cluster;
 
        if (begin >= end)
                return 0;
 
-       sector_boundary = (node->size | (SECTOR_SIZE(*ef->sb) - 1)) + 1;
+       cluster_boundary = (begin | (CLUSTER_SIZE(*ef->sb) - 1)) + 1;
        cluster = exfat_advance_cluster(ef, node,
-                       node->size / CLUSTER_SIZE(*ef->sb));
+                       begin / CLUSTER_SIZE(*ef->sb));
        if (CLUSTER_INVALID(cluster))
        {
                exfat_error("invalid cluster in file");
                return -EIO;
        }
-       /* erase from the beginning to the closest sector boundary */
-       erase_raw(ef, MIN(sector_boundary, end) - node->size,
-                       exfat_c2o(ef, cluster) + node->size % CLUSTER_SIZE(*ef->sb));
-       /* erase whole sectors */
-       while (sector_boundary < end)
+       /* 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));
+       /* erase whole clusters */
+       while (cluster_boundary < end)
        {
-               if (sector_boundary % CLUSTER_SIZE(*ef->sb) == 0)
-                       cluster = exfat_next_cluster(ef, node, cluster);
-               erase_raw(ef, SECTOR_SIZE(*ef->sb),
-                       exfat_c2o(ef, cluster) + sector_boundary % CLUSTER_SIZE(*ef->sb));
-               sector_boundary += SECTOR_SIZE(*ef->sb);
+               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");
+               erase_raw(ef, CLUSTER_SIZE(*ef->sb), exfat_c2o(ef, cluster));
+               cluster_boundary += CLUSTER_SIZE(*ef->sb);
        }
        return 0;
 }