Handle I/O errors.

git-svn-id: http://exfat.googlecode.com/svn/trunk@373 60bc1c72-a15a-11de-b98f-4500b42dc123

diff --git a/libexfat/cluster.c b/libexfat/cluster.c
index e84e581..cc59da7 100644 (file)
--- a/libexfat/cluster.c
+++ b/libexfat/cluster.c
@@ -23,6 +23,7 @@
 #include "exfat.h"
 #include <errno.h>
 #include <string.h>
+#include <inttypes.h>
 
 /*
  * Sector to absolute offset.
@@ -82,7 +83,9 @@ 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_pread(ef->dev, &next, sizeof(next), fat_offset);
+       /* 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 le32_to_cpu(next);
 }
 
@@ -137,8 +140,11 @@ void exfat_flush(struct exfat* ef)
 {
        if (ef->cmap.dirty)
        {
-               exfat_pwrite(ef->dev, ef->cmap.chunk, BMAP_SIZE(ef->cmap.chunk_size),
-                               exfat_c2o(ef, ef->cmap.start_cluster));
+               /* 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");
                ef->cmap.dirty = false;
        }
 }
@@ -154,7 +160,9 @@ static void set_next_cluster(const struct exfat* ef, bool contiguous,
        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);
+       /* 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");
 }
 
 static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)
@@ -317,7 +325,9 @@ 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_pwrite(ef->dev, ef->zero_cluster, size, offset);
+       /* FIXME handle I/O error */
+       if (exfat_pwrite(ef->dev, ef->zero_cluster, size, offset) < 0)
+               exfat_bug("failed to erase %zu bytes at %"PRId64, size, offset);
 }
 
 static int erase_range(struct exfat* ef, struct exfat_node* node,

diff --git a/libexfat/io.c b/libexfat/io.c
index 71e1dbc..c9fde95 100644 (file)
--- a/libexfat/io.c
+++ b/libexfat/io.c
@@ -331,7 +331,12 @@ ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
                        return -1;
                }
                lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
-               exfat_pread(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
+               if (exfat_pread(ef->dev, bufp, lsize,
+                                       exfat_c2o(ef, cluster) + loffset) < 0)
+               {
+                       exfat_error("failed to read cluster %#x", cluster);
+                       return -1;
+               }
                bufp += lsize;
                loffset = 0;
                remainder -= lsize;
@@ -375,7 +380,12 @@ ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
                        return -1;
                }
                lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
-               exfat_pwrite(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
+               if (exfat_pwrite(ef->dev, bufp, lsize,
+                               exfat_c2o(ef, cluster) + loffset) < 0)
+               {
+                       exfat_error("failed to write cluster %#x", cluster);
+                       return -1;
+               }
                bufp += lsize;
                loffset = 0;
                remainder -= lsize;

diff --git a/libexfat/mount.c b/libexfat/mount.c
index addb263..f671686 100644 (file)
--- a/libexfat/mount.c
+++ b/libexfat/mount.c
@@ -97,15 +97,27 @@ static int verify_vbr_checksum(struct exfat_dev* dev, void* sector,
        uint32_t vbr_checksum;
        int i;
 
-       exfat_pread(dev, sector, sector_size, 0);
+       if (exfat_pread(dev, sector, sector_size, 0) < 0)
+       {
+               exfat_error("failed to read boot sector");
+               return 1;
+       }
        vbr_checksum = exfat_vbr_start_checksum(sector, sector_size);
        for (i = 1; i < 11; i++)
        {
-               exfat_pread(dev, sector, sector_size, i * sector_size);
+               if (exfat_pread(dev, sector, sector_size, i * sector_size) < 0)
+               {
+                       exfat_error("failed to read VBR sector");
+                       return 1;
+               }
                vbr_checksum = exfat_vbr_add_checksum(sector, sector_size,
                                vbr_checksum);
        }
-       exfat_pread(dev, sector, sector_size, i * sector_size);
+       if (exfat_pread(dev, sector, sector_size, i * sector_size) < 0)
+       {
+               exfat_error("failed to read VBR checksum sector");
+               return 1;
+       }
        for (i = 0; i < sector_size / sizeof(vbr_checksum); i++)
                if (le32_to_cpu(((const le32_t*) sector)[i]) != vbr_checksum)
                {
@@ -118,7 +130,11 @@ static int verify_vbr_checksum(struct exfat_dev* dev, void* sector,
 
 static int commit_super_block(const struct exfat* ef)
 {
-       exfat_pwrite(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0);
+       if (exfat_pwrite(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0) < 0)
+       {
+               exfat_error("failed to write super block");
+               return 1;
+       }
        return exfat_fsync(ef->dev);
 }
 
@@ -171,7 +187,11 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        }
        memset(ef->sb, 0, sizeof(struct exfat_super_block));
 
-       exfat_pread(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0);
+       if (exfat_pread(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0) < 0)
+       {
+               exfat_error("failed to read boot sector");
+               return -EIO;
+       }
        if (memcmp(ef->sb->oem_name, "EXFAT   ", 8) != 0)
        {
                exfat_close(ef->dev);

diff --git a/libexfat/node.c b/libexfat/node.c
index e83ec9e..a00149f 100644 (file)
--- a/libexfat/node.c
+++ b/libexfat/node.c
@@ -86,8 +86,12 @@ static int opendir(struct exfat* ef, const struct exfat_node* dir,
                exfat_error("out of memory");
                return -ENOMEM;
        }
-       exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
-                       exfat_c2o(ef, it->cluster));
+       if (exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
+                       exfat_c2o(ef, it->cluster)) < 0)
+       {
+               exfat_error("failed to read directory cluster %#x", it->cluster);
+               return -EIO;
+       }
        return 0;
 }
 
@@ -119,8 +123,13 @@ static int fetch_next_entry(struct exfat* ef, const struct exfat_node* parent,
                                        it->cluster);
                        return 1;
                }
-               exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
-                               exfat_c2o(ef, it->cluster));
+               if (exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
+                               exfat_c2o(ef, it->cluster)) < 0)
+               {
+                       exfat_error("failed to read the next directory cluster %#x",
+                                       it->cluster);
+                       return 1;
+               }
        }
        return 0;
 }
@@ -353,8 +362,15 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                        }
                        ef->upcase_chars = le64_to_cpu(upcase->size) / sizeof(le16_t);
 
-                       exfat_pread(ef->dev, ef->upcase, le64_to_cpu(upcase->size),
-                                       exfat_c2o(ef, le32_to_cpu(upcase->start_cluster)));
+                       if (exfat_pread(ef->dev, ef->upcase, le64_to_cpu(upcase->size),
+                                       exfat_c2o(ef, le32_to_cpu(upcase->start_cluster))) < 0)
+                       {
+                               exfat_error("failed to read upper case table "
+                                               "(%"PRIu64" bytes starting at cluster %#x)",
+                                               le64_to_cpu(upcase->size),
+                                               le32_to_cpu(upcase->start_cluster));
+                               goto error;
+                       }
                        break;
 
                case EXFAT_ENTRY_BITMAP:
@@ -387,9 +403,15 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                                goto error;
                        }
 
-                       exfat_pread(ef->dev, ef->cmap.chunk,
+                       if (exfat_pread(ef->dev, ef->cmap.chunk,
                                        BMAP_SIZE(ef->cmap.chunk_size),
-                                       exfat_c2o(ef, ef->cmap.start_cluster));
+                                       exfat_c2o(ef, ef->cmap.start_cluster)) < 0)
+                       {
+                               exfat_error("failed to read clusters bitmap "
+                                               "(%"PRIu64" bytes starting at cluster %#x)",
+                                               le64_to_cpu(bitmap->size), ef->cmap.start_cluster);
+                               goto error;
+                       }
                        break;
 
                case EXFAT_ENTRY_LABEL:
@@ -550,14 +572,18 @@ void exfat_flush_node(struct exfat* ef, struct exfat_node* node)
        next_entry(ef, node->parent, &cluster, &offset);
        meta2_offset = co2o(ef, cluster, offset);
 
-       exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset);
+       /* FIXME handle I/O error */
+       if (exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0)
+               exfat_bug("failed to read meta1 entry on flush");
        if (meta1.type != EXFAT_ENTRY_FILE)
                exfat_bug("invalid type of meta1: 0x%hhx", meta1.type);
        meta1.attrib = cpu_to_le16(node->flags);
        exfat_unix2exfat(node->mtime, &meta1.mdate, &meta1.mtime, &meta1.mtime_cs);
        exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL);
 
-       exfat_pread(ef->dev, &meta2, sizeof(meta2), meta2_offset);
+       /* FIXME handle I/O error */
+       if (exfat_pread(ef->dev, &meta2, sizeof(meta2), meta2_offset) < 0)
+               exfat_bug("failed to read meta2 entry on flush");
        if (meta2.type != EXFAT_ENTRY_FILE_INFO)
                exfat_bug("invalid type of meta2: 0x%hhx", meta2.type);
        meta2.size = meta2.real_size = cpu_to_le64(node->size);
@@ -570,8 +596,12 @@ void exfat_flush_node(struct exfat* ef, struct exfat_node* node)
 
        meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
 
-       exfat_pwrite(ef->dev, &meta1, sizeof(meta1), meta1_offset);
-       exfat_pwrite(ef->dev, &meta2, sizeof(meta2), meta2_offset);
+       /* FIXME handle I/O error */
+       if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1), meta1_offset) < 0)
+               exfat_bug("failed to write meta1 entry on flush");
+       /* FIXME handle I/O error */
+       if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2), meta2_offset) < 0)
+               exfat_bug("failed to write meta2 entry on flush");
 
        node->flags &= ~EXFAT_ATTRIB_DIRTY;
 }
@@ -584,17 +614,24 @@ static void erase_entry(struct exfat* ef, struct exfat_node* node)
        uint8_t entry_type;
 
        entry_type = EXFAT_ENTRY_FILE & ~EXFAT_ENTRY_VALID;
-       exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
+       /* FIXME handle I/O error */
+       if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0)
+               exfat_bug("failed to erase meta1 entry");
 
        next_entry(ef, node->parent, &cluster, &offset);
        entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;
-       exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
+       /* FIXME handle I/O error */
+       if (exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset)) < 0)
+               exfat_bug("failed to erase meta2 entry");
 
        while (name_entries--)
        {
                next_entry(ef, node->parent, &cluster, &offset);
                entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID;
-               exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
+               /* FIXME handle I/O error */
+               if (exfat_pwrite(ef->dev, &entry_type, 1,
+                               co2o(ef, cluster, offset)) < 0)
+                       exfat_bug("failed to erase name entry");
        }
 }
 
@@ -771,9 +808,19 @@ static int write_entry(struct exfat* ef, struct exfat_node* dir,
 
        meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
 
-       exfat_pwrite(ef->dev, &meta1, sizeof(meta1), co2o(ef, cluster, offset));
+       if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1),
+                       co2o(ef, cluster, offset)) < 0)
+       {
+               exfat_error("failed to write meta1 entry");
+               return -EIO;
+       }
        next_entry(ef, dir, &cluster, &offset);
-       exfat_pwrite(ef->dev, &meta2, sizeof(meta2), co2o(ef, cluster, offset));
+       if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2),
+                       co2o(ef, cluster, offset)) < 0)
+       {
+               exfat_error("failed to write meta2 entry");
+               return -EIO;
+       }
        for (i = 0; i < name_entries; i++)
        {
                struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0};
@@ -781,8 +828,12 @@ static int write_entry(struct exfat* ef, struct exfat_node* dir,
                                MIN(EXFAT_ENAME_MAX, EXFAT_NAME_MAX - i * EXFAT_ENAME_MAX) *
                                sizeof(le16_t));
                next_entry(ef, dir, &cluster, &offset);
-               exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
-                               co2o(ef, cluster, offset));
+               if (exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
+                               co2o(ef, cluster, offset)) < 0)
+               {
+                       exfat_error("failed to write name entry");
+                       return -EIO;
+               }
        }
 
        init_node_meta1(node, &meta1);
@@ -864,11 +915,15 @@ static void rename_entry(struct exfat* ef, struct exfat_node* dir,
        const int name_entries = DIV_ROUND_UP(name_length, EXFAT_ENAME_MAX);
        int i;
 
-       exfat_pread(ef->dev, &meta1, sizeof(meta1),
-                       co2o(ef, old_cluster, old_offset));
+       /* FIXME handle I/O error */
+       if (exfat_pread(ef->dev, &meta1, sizeof(meta1),
+                       co2o(ef, old_cluster, old_offset)) < 0)
+               exfat_bug("failed to read meta1 entry on rename");
        next_entry(ef, node->parent, &old_cluster, &old_offset);
-       exfat_pread(ef->dev, &meta2, sizeof(meta2),
-                       co2o(ef, old_cluster, old_offset));
+       /* FIXME handle I/O error */
+       if (exfat_pread(ef->dev, &meta2, sizeof(meta2),
+                       co2o(ef, old_cluster, old_offset)) < 0)
+               exfat_bug("failed to read meta2 entry on rename");
        meta1.continuations = 1 + name_entries;
        meta2.name_hash = exfat_calc_name_hash(ef, name);
        meta2.name_length = name_length;
@@ -879,11 +934,15 @@ static void rename_entry(struct exfat* ef, struct exfat_node* dir,
        node->entry_cluster = new_cluster;
        node->entry_offset = new_offset;
 
-       exfat_pwrite(ef->dev, &meta1, sizeof(meta1),
-                       co2o(ef, new_cluster, new_offset));
+       /* FIXME handle I/O error */
+       if (exfat_pwrite(ef->dev, &meta1, sizeof(meta1),
+                       co2o(ef, new_cluster, new_offset)) < 0)
+               exfat_bug("failed to write meta1 entry on rename");
        next_entry(ef, dir, &new_cluster, &new_offset);
-       exfat_pwrite(ef->dev, &meta2, sizeof(meta2),
-                       co2o(ef, new_cluster, new_offset));
+       /* FIXME handle I/O error */
+       if (exfat_pwrite(ef->dev, &meta2, sizeof(meta2),
+                       co2o(ef, new_cluster, new_offset)) < 0)
+               exfat_bug("failed to write meta2 entry on rename");
 
        for (i = 0; i < name_entries; i++)
        {
@@ -891,8 +950,10 @@ static void rename_entry(struct exfat* ef, struct exfat_node* dir,
                memcpy(name_entry.name, name + i * EXFAT_ENAME_MAX,
                                EXFAT_ENAME_MAX * sizeof(le16_t));
                next_entry(ef, dir, &new_cluster, &new_offset);
-               exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
-                               co2o(ef, new_cluster, new_offset));
+               /* FIXME handle I/O error */
+               if (exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
+                               co2o(ef, new_cluster, new_offset)) < 0)
+                       exfat_bug("failed to write name entry on rename");
        }
 
        memcpy(node->name, name, (EXFAT_NAME_MAX + 1) * sizeof(le16_t));
@@ -1064,8 +1125,12 @@ int exfat_set_label(struct exfat* ef, const char* label)
        if (entry.length == 0)
                entry.type ^= EXFAT_ENTRY_VALID;
 
-       exfat_pwrite(ef->dev, &entry, sizeof(struct exfat_entry_label),
-                       co2o(ef, cluster, offset));
+       if (exfat_pwrite(ef->dev, &entry, sizeof(struct exfat_entry_label),
+                       co2o(ef, cluster, offset)) < 0)
+       {
+               exfat_error("failed to write label entry");
+               return -EIO;
+       }
        strcpy(ef->label, label);
        return 0;
 }