cluster.c (03.09.09)
exFAT file system implementation library.
- Copyright (C) 2009, 2010 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
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);
}
{
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;
}
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);
- ef->cmap.dirty = 0;
+ exfat_pwrite(ef->dev, ef->cmap.chunk, (ef->cmap.chunk_size + 7) / 8,
+ exfat_c2o(ef, ef->cmap.start_cluster));
+ ef->cmap.dirty = false;
}
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)
return EXFAT_CLUSTER_END;
}
- ef->cmap.dirty = 1;
- /* FIXME update percentage of used space */
+ 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;
- /* FIXME update percentage of used space */
+ ef->cmap.dirty = true;
}
static void make_noncontiguous(const struct exfat* ef, cluster_t first,
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;
}
}
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);
{
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);
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");
+ exfat_error("invalid cluster 0x%x while erasing", cluster);
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 0x%x after allocation", cluster);
+ erase_raw(ef, CLUSTER_SIZE(*ef->sb), exfat_c2o(ef, cluster));
+ cluster_boundary += CLUSTER_SIZE(*ef->sb);
}
return 0;
}