exFAT file system implementation library.
Free exFAT implementation.
- Copyright (C) 2010-2013 Andrew Nayenko
+ Copyright (C) 2010-2015 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);
- /* FIXME handle I/O error */
if (exfat_pread(ef->dev, &next, sizeof(next), fat_offset) < 0)
- exfat_bug("failed to read the next cluster after %#x", cluster);
+ return EXFAT_CLUSTER_BAD; /* the caller should handle this and print
+ appropriate error message */
return le32_to_cpu(next);
}
return EXFAT_CLUSTER_END;
}
-void exfat_flush(struct exfat* ef)
+static int flush_nodes(struct exfat* ef, struct exfat_node* node)
{
+ 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(struct exfat* ef)
+{
+ int rc = flush_nodes(ef, ef->root);
+
if (ef->cmap.dirty)
{
- /* FIXME handle I/O error */
if (exfat_pwrite(ef->dev, ef->cmap.chunk,
BMAP_SIZE(ef->cmap.chunk_size),
exfat_c2o(ef, ef->cmap.start_cluster)) < 0)
- exfat_bug("failed to write clusters bitmap");
+ {
+ exfat_error("failed to write clusters bitmap");
+ return -EIO;
+ }
ef->cmap.dirty = false;
}
+
+ return rc;
}
-static void set_next_cluster(const struct exfat* ef, bool 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)
- 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);
- /* FIXME handle I/O error */
if (exfat_pwrite(ef->dev, &next_le32, sizeof(next_le32), fat_offset) < 0)
- exfat_bug("failed to write the next cluster");
+ {
+ 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)
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++)
- set_next_cluster(ef, false, 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,
{
/* it's a pity, but we are not able to keep the file contiguous
anymore */
- make_noncontiguous(ef, node->start_cluster, previous);
+ if (!make_noncontiguous(ef, node->start_cluster, previous))
+ return -EIO;
node->flags &= ~EXFAT_ATTRIB_CONTIGUOUS;
node->flags |= EXFAT_ATTRIB_DIRTY;
}
- set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, next);
+ if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, next))
+ return -EIO;
previous = next;
allocated++;
}
- set_next_cluster(ef, IS_CONTIGUOUS(*node), previous, EXFAT_CLUSTER_END);
+ if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous,
+ EXFAT_CLUSTER_END))
+ return -EIO;
return 0;
}
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, IS_CONTIGUOUS(*node), last,
+ EXFAT_CLUSTER_END))
+ return -EIO;
}
else
{
previous = node->start_cluster;
node->start_cluster = EXFAT_CLUSTER_FREE;
+ node->flags |= EXFAT_ATTRIB_DIRTY;
}
node->fptr_index = 0;
node->fptr_cluster = node->start_cluster;
return -EIO;
}
next = exfat_next_cluster(ef, node, previous);
- set_next_cluster(ef, IS_CONTIGUOUS(*node), previous,
- EXFAT_CLUSTER_FREE);
+ if (!set_next_cluster(ef, IS_CONTIGUOUS(*node), previous,
+ EXFAT_CLUSTER_FREE))
+ return -EIO;
free_cluster(ef, previous);
previous = next;
}