Represent device as an extensible structure instead of a plain Unix descriptor.

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

diff --git a/dump/main.c b/dump/main.c
index c44d23c..cd424d9 100644 (file)
--- a/dump/main.c
+++ b/dump/main.c
@@ -73,22 +73,22 @@ static void print_other_info(const struct exfat_super_block* sb)
 
 static int dump_sb(const char* spec)
 {
-       int fd;
+       struct exfat_dev* dev;
        struct exfat_super_block sb;
 
-       fd = exfat_open(spec, 1);
-       if (fd < 0)
+       dev = exfat_open(spec, 1);
+       if (dev == NULL)
                return 1;
 
-       if (exfat_read(fd, &sb, sizeof(struct exfat_super_block)) < 0)
+       if (exfat_read(dev, &sb, sizeof(struct exfat_super_block)) < 0)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                exfat_error("failed to read from `%s'", spec);
                return 1;
        }
        if (memcmp(sb.oem_name, "EXFAT   ", sizeof(sb.oem_name)) != 0)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                exfat_error("exFAT file system is not found on `%s'", spec);
                return 1;
        }
@@ -98,7 +98,7 @@ static int dump_sb(const char* spec)
        print_cluster_info(&sb);
        print_other_info(&sb);
 
-       exfat_close(fd);
+       exfat_close(dev);
        return 0;
 }
 

diff --git a/libexfat/cluster.c b/libexfat/cluster.c
index 1073301..1257c7a 100644 (file)
--- a/libexfat/cluster.c
+++ b/libexfat/cluster.c
@@ -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_pread(ef->fd, &next, sizeof(next), fat_offset);
+       exfat_pread(ef->dev, &next, sizeof(next), fat_offset);
        return le32_to_cpu(next);
 }
 
@@ -145,7 +145,7 @@ static cluster_t find_bit_and_set(uint8_t* bitmap, cluster_t start,
 
 void exfat_flush_cmap(struct exfat* ef)
 {
-       exfat_pwrite(ef->fd, ef->cmap.chunk, (ef->cmap.chunk_size + 7) / 8,
+       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_pwrite(ef->fd, &next_le32, sizeof(next_le32), fat_offset);
+       exfat_pwrite(ef->dev, &next_le32, sizeof(next_le32), fat_offset);
 }
 
 static cluster_t allocate_cluster(struct exfat* ef, cluster_t hint)
@@ -323,7 +323,7 @@ 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->fd, ef->zero_cluster, size, offset);
+       exfat_pwrite(ef->dev, ef->zero_cluster, size, offset);
 }
 
 static int erase_range(struct exfat* ef, struct exfat_node* node,

diff --git a/libexfat/exfat.h b/libexfat/exfat.h
index 63fb8ce..bca0d24 100644 (file)
--- a/libexfat/exfat.h
+++ b/libexfat/exfat.h
@@ -69,10 +69,12 @@ struct exfat_node
        le16_t name[EXFAT_NAME_MAX + 1];
 };
 
+struct exfat_dev;
+
 struct exfat
 {
+       struct exfat_dev* dev;
        struct exfat_super_block* sb;
-       int fd;
        le16_t* upcase;
        size_t upcase_chars;
        struct exfat_node* root;
@@ -120,14 +122,16 @@ void exfat_warn(const char* format, ...)
 void exfat_debug(const char* format, ...)
        __attribute__((format(printf, 1, 2)));
 
-int exfat_open(const char* spec, int ro);
-int exfat_close(int fd);
-int exfat_fsync(int fd);
-off_t exfat_seek(int fd, off_t offset, int whence);
-ssize_t exfat_read(int fd, void* buffer, size_t size);
-ssize_t exfat_write(int fd, const void* buffer, size_t size);
-void exfat_pread(int fd, void* buffer, size_t size, off_t offset);
-void exfat_pwrite(int fd, const void* buffer, size_t size, off_t offset);
+struct exfat_dev* exfat_open(const char* spec, int ro);
+int exfat_close(struct exfat_dev* dev);
+int exfat_fsync(struct exfat_dev* dev);
+off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence);
+ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size);
+ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size);
+void exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
+               off_t offset);
+void exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
+               off_t offset);
 ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
                void* buffer, size_t size, off_t offset);
 ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,

diff --git a/libexfat/io.c b/libexfat/io.c
index 2f548b6..c43df62 100644 (file)
--- a/libexfat/io.c
+++ b/libexfat/io.c
@@ -31,47 +31,64 @@
        #error You should define _FILE_OFFSET_BITS=64
 #endif
 
-int exfat_open(const char* spec, int ro)
+struct exfat_dev
 {
        int fd;
+};
+
+struct exfat_dev* exfat_open(const char* spec, int ro)
+{
+       struct exfat_dev* dev;
        struct stat stbuf;
 
-       fd = open(spec, ro ? O_RDONLY : O_RDWR);
-       if (fd < 0)
+       dev = malloc(sizeof(struct exfat_dev));
+       if (dev == NULL)
+       {
+               exfat_error("failed to allocate memory for device structure");
+               return NULL;
+       }
+
+       dev->fd = open(spec, ro ? O_RDONLY : O_RDWR);
+       if (dev->fd < 0)
        {
+               free(dev);
                exfat_error("failed to open `%s' in read-%s mode", spec,
                                ro ? "only" : "write");
-               return -1;
+               return NULL;
        }
-       if (fstat(fd, &stbuf) != 0)
+       if (fstat(dev->fd, &stbuf) != 0)
        {
-               exfat_close(fd);
+               close(dev->fd);
+               free(dev);
                exfat_error("failed to fstat `%s'", spec);
-               return -1;
+               return NULL;
        }
        if (!S_ISBLK(stbuf.st_mode) && !S_ISREG(stbuf.st_mode))
        {
-               exfat_close(fd);
+               close(dev->fd);
+               free(dev);
                exfat_error("`%s' is neither a block device, nor a regular file",
                                spec);
-               return -1;
+               return NULL;
        }
-       return fd;
+       return dev;
 }
 
-int exfat_close(int fd)
+int exfat_close(struct exfat_dev* dev)
 {
-       if (close(fd) != 0)
+       if (close(dev->fd) != 0)
        {
+               free(dev);
                exfat_error("close failed");
                return 1;
        }
+       free(dev);
        return 0;
 }
 
-int exfat_fsync(int fd)
+int exfat_fsync(struct exfat_dev* dev)
 {
-       if (fsync(fd) != 0)
+       if (fsync(dev->fd) != 0)
        {
                exfat_error("fsync failed");
                return 1;
@@ -79,31 +96,33 @@ int exfat_fsync(int fd)
        return 0;
 }
 
-off_t exfat_seek(int fd, off_t offset, int whence)
+off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence)
 {
-       return lseek(fd, offset, whence);
+       return lseek(dev->fd, offset, whence);
 }
 
-ssize_t exfat_read(int fd, void* buffer, size_t size)
+ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size)
 {
-       return read(fd, buffer, size);
+       return read(dev->fd, buffer, size);
 }
 
-ssize_t exfat_write(int fd, const void* buffer, size_t size)
+ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size)
 {
-       return write(fd, buffer, size);
+       return write(dev->fd, buffer, size);
 }
 
-void exfat_pread(int fd, void* buffer, size_t size, off_t offset)
+void exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
+               off_t offset)
 {
-       if (pread(fd, buffer, size, offset) != size)
+       if (pread(dev->fd, buffer, size, offset) != size)
                exfat_bug("failed to read %zu bytes from file at %"PRIu64, size,
                                (uint64_t) offset);
 }
 
-void exfat_pwrite(int fd, const void* buffer, size_t size, off_t offset)
+void exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
+               off_t offset)
 {
-       if (pwrite(fd, buffer, size, offset) != size)
+       if (pwrite(dev->fd, buffer, size, offset) != size)
                exfat_bug("failed to write %zu bytes to file at %"PRIu64, size,
                                (uint64_t) offset);
 }
@@ -137,7 +156,7 @@ 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->fd, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
+               exfat_pread(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
                bufp += lsize;
                loffset = 0;
                remainder -= lsize;
@@ -181,7 +200,7 @@ 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->fd, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
+               exfat_pwrite(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
                bufp += lsize;
                loffset = 0;
                remainder -= lsize;

diff --git a/libexfat/mount.c b/libexfat/mount.c
index b06fdd0..521b539 100644 (file)
--- a/libexfat/mount.c
+++ b/libexfat/mount.c
@@ -90,20 +90,21 @@ static void parse_options(struct exfat* ef, const char* options)
        ef->noatime = match_option(options, "noatime");
 }
 
-static int verify_vbr_checksum(void* sector, off_t sector_size, int fd)
+static int verify_vbr_checksum(struct exfat_dev* dev, void* sector,
+               off_t sector_size)
 {
        uint32_t vbr_checksum;
        int i;
 
-       exfat_pread(fd, sector, sector_size, 0);
+       exfat_pread(dev, sector, sector_size, 0);
        vbr_checksum = exfat_vbr_start_checksum(sector, sector_size);
        for (i = 1; i < 11; i++)
        {
-               exfat_pread(fd, sector, sector_size, i * sector_size);
+               exfat_pread(dev, sector, sector_size, i * sector_size);
                vbr_checksum = exfat_vbr_add_checksum(sector, sector_size,
                                vbr_checksum);
        }
-       exfat_pread(fd, sector, sector_size, i * sector_size);
+       exfat_pread(dev, sector, sector_size, i * sector_size);
        for (i = 0; i < sector_size / sizeof(vbr_checksum); i++)
                if (le32_to_cpu(((const le32_t*) sector)[i]) != vbr_checksum)
                {
@@ -116,8 +117,8 @@ static int verify_vbr_checksum(void* sector, off_t sector_size, int fd)
 
 static int commit_super_block(const struct exfat* ef)
 {
-       exfat_pwrite(ef->fd, ef->sb, sizeof(struct exfat_super_block), 0);
-       return exfat_fsync(ef->fd);
+       exfat_pwrite(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0);
+       return exfat_fsync(ef->dev);
 }
 
 static int prepare_super_block(const struct exfat* ef)
@@ -142,13 +143,13 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
 
        parse_options(ef, options);
 
-       ef->fd = exfat_open(spec, ef->ro);
-       if (ef->fd < 0)
+       ef->dev = exfat_open(spec, ef->ro);
+       if (ef->dev == NULL)
        {
                if (ef->ro || !match_option(options, "ro_fallback"))
                        return -EIO;
-               ef->fd = exfat_open(spec, 1);
-               if (ef->fd < 0)
+               ef->dev = exfat_open(spec, 1);
+               if (ef->dev == NULL)
                        return -EIO;
                exfat_warn("device is write-protected, mounting read-only");
                ef->ro_fallback = ef->ro = 1;
@@ -157,23 +158,23 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        ef->sb = malloc(sizeof(struct exfat_super_block));
        if (ef->sb == NULL)
        {
-               exfat_close(ef->fd);
+               exfat_close(ef->dev);
                exfat_error("failed to allocate memory for the super block");
                return -ENOMEM;
        }
        memset(ef->sb, 0, sizeof(struct exfat_super_block));
 
-       exfat_pread(ef->fd, ef->sb, sizeof(struct exfat_super_block), 0);
+       exfat_pread(ef->dev, ef->sb, sizeof(struct exfat_super_block), 0);
        if (memcmp(ef->sb->oem_name, "EXFAT   ", 8) != 0)
        {
-               exfat_close(ef->fd);
+               exfat_close(ef->dev);
                free(ef->sb);
                exfat_error("exFAT file system is not found");
                return -EIO;
        }
        if (ef->sb->version.major != 1 || ef->sb->version.minor != 0)
        {
-               exfat_close(ef->fd);
+               exfat_close(ef->dev);
                exfat_error("unsupported exFAT version: %hhu.%hhu",
                                ef->sb->version.major, ef->sb->version.minor);
                free(ef->sb);
@@ -181,7 +182,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        }
        if (ef->sb->fat_count != 1)
        {
-               exfat_close(ef->fd);
+               exfat_close(ef->dev);
                free(ef->sb);
                exfat_error("unsupported FAT count: %hhu", ef->sb->fat_count);
                return -EIO;
@@ -189,7 +190,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        /* officially exFAT supports cluster size up to 32 MB */
        if ((int) ef->sb->sector_bits + (int) ef->sb->spc_bits > 25)
        {
-               exfat_close(ef->fd);
+               exfat_close(ef->dev);
                free(ef->sb);
                exfat_error("too big cluster size: 2^%d",
                                (int) ef->sb->sector_bits + (int) ef->sb->spc_bits);
@@ -199,17 +200,17 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        ef->zero_cluster = malloc(CLUSTER_SIZE(*ef->sb));
        if (ef->zero_cluster == NULL)
        {
-               exfat_close(ef->fd);
+               exfat_close(ef->dev);
                free(ef->sb);
                exfat_error("failed to allocate zero sector");
                return -ENOMEM;
        }
        /* use zero_cluster as a temporary buffer for VBR checksum verification */
-       if (verify_vbr_checksum(ef->zero_cluster, SECTOR_SIZE(*ef->sb),
-                       ef->fd) != 0)
+       if (verify_vbr_checksum(ef->dev, ef->zero_cluster,
+                       SECTOR_SIZE(*ef->sb)) != 0)
        {
                free(ef->zero_cluster);
-               exfat_close(ef->fd);
+               exfat_close(ef->dev);
                free(ef->sb);
                return -EIO;
        }
@@ -219,7 +220,7 @@ int exfat_mount(struct exfat* ef, const char* spec, const char* options)
        if (ef->root == NULL)
        {
                free(ef->zero_cluster);
-               exfat_close(ef->fd);
+               exfat_close(ef->dev);
                free(ef->sb);
                exfat_error("failed to allocate root node");
                return -ENOMEM;
@@ -260,7 +261,7 @@ error:
        exfat_reset_cache(ef);
        free(ef->root);
        free(ef->zero_cluster);
-       exfat_close(ef->fd);
+       exfat_close(ef->dev);
        free(ef->sb);
        return -EIO;
 }
@@ -294,8 +295,8 @@ void exfat_unmount(struct exfat* ef)
        free(ef->root);
        ef->root = NULL;
        finalize_super_block(ef);
-       exfat_close(ef->fd);    /* close descriptor immediately after fsync */
-       ef->fd = 0;
+       exfat_close(ef->dev);   /* close descriptor immediately after fsync */
+       ef->dev = NULL;
        free(ef->zero_cluster);
        ef->zero_cluster = NULL;
        free(ef->cmap.chunk);

diff --git a/libexfat/node.c b/libexfat/node.c
index 384bbd3..2ae724d 100644 (file)
--- a/libexfat/node.c
+++ b/libexfat/node.c
@@ -86,7 +86,7 @@ static int opendir(struct exfat* ef, const struct exfat_node* dir,
                exfat_error("out of memory");
                return -ENOMEM;
        }
-       exfat_pread(ef->fd, it->chunk, CLUSTER_SIZE(*ef->sb),
+       exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
                        exfat_c2o(ef, it->cluster));
        return 0;
 }
@@ -118,7 +118,7 @@ static int fetch_next_entry(struct exfat* ef, const struct exfat_node* parent,
                        exfat_error("invalid cluster while reading directory");
                        return 1;
                }
-               exfat_pread(ef->fd, it->chunk, CLUSTER_SIZE(*ef->sb),
+               exfat_pread(ef->dev, it->chunk, CLUSTER_SIZE(*ef->sb),
                                exfat_c2o(ef, it->cluster));
        }
        return 0;
@@ -331,7 +331,7 @@ 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->fd, ef->upcase, le64_to_cpu(upcase->size),
+                       exfat_pread(ef->dev, ef->upcase, le64_to_cpu(upcase->size),
                                        exfat_c2o(ef, le32_to_cpu(upcase->start_cluster)));
                        break;
 
@@ -363,7 +363,7 @@ static int readdir(struct exfat* ef, const struct exfat_node* parent,
                                goto error;
                        }
 
-                       exfat_pread(ef->fd, ef->cmap.chunk, le64_to_cpu(bitmap->size),
+                       exfat_pread(ef->dev, ef->cmap.chunk, le64_to_cpu(bitmap->size),
                                        exfat_c2o(ef, ef->cmap.start_cluster));
                        break;
 
@@ -501,14 +501,14 @@ 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->fd, &meta1, sizeof(meta1), meta1_offset);
+       exfat_pread(ef->dev, &meta1, sizeof(meta1), meta1_offset);
        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->fd, &meta2, sizeof(meta2), meta2_offset);
+       exfat_pread(ef->dev, &meta2, sizeof(meta2), meta2_offset);
        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);
@@ -521,8 +521,8 @@ void exfat_flush_node(struct exfat* ef, struct exfat_node* node)
 
        meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
 
-       exfat_pwrite(ef->fd, &meta1, sizeof(meta1), meta1_offset);
-       exfat_pwrite(ef->fd, &meta2, sizeof(meta2), meta2_offset);
+       exfat_pwrite(ef->dev, &meta1, sizeof(meta1), meta1_offset);
+       exfat_pwrite(ef->dev, &meta2, sizeof(meta2), meta2_offset);
 
        node->flags &= ~EXFAT_ATTRIB_DIRTY;
 }
@@ -535,17 +535,17 @@ 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->fd, &entry_type, 1, co2o(ef, cluster, offset));
+       exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
 
        next_entry(ef, node->parent, &cluster, &offset);
        entry_type = EXFAT_ENTRY_FILE_INFO & ~EXFAT_ENTRY_VALID;
-       exfat_pwrite(ef->fd, &entry_type, 1, co2o(ef, cluster, offset));
+       exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
 
        while (name_entries--)
        {
                next_entry(ef, node->parent, &cluster, &offset);
                entry_type = EXFAT_ENTRY_FILE_NAME & ~EXFAT_ENTRY_VALID;
-               exfat_pwrite(ef->fd, &entry_type, 1, co2o(ef, cluster, offset));
+               exfat_pwrite(ef->dev, &entry_type, 1, co2o(ef, cluster, offset));
        }
 }
 
@@ -746,16 +746,16 @@ static int write_entry(struct exfat* ef, struct exfat_node* dir,
 
        meta1.checksum = exfat_calc_checksum(&meta1, &meta2, node->name);
 
-       exfat_pwrite(ef->fd, &meta1, sizeof(meta1), co2o(ef, cluster, offset));
+       exfat_pwrite(ef->dev, &meta1, sizeof(meta1), co2o(ef, cluster, offset));
        next_entry(ef, dir, &cluster, &offset);
-       exfat_pwrite(ef->fd, &meta2, sizeof(meta2), co2o(ef, cluster, offset));
+       exfat_pwrite(ef->dev, &meta2, sizeof(meta2), co2o(ef, cluster, offset));
        for (i = 0; i < name_entries; i++)
        {
                struct exfat_entry_name name_entry = {EXFAT_ENTRY_FILE_NAME, 0};
                memcpy(name_entry.name, node->name + i * EXFAT_ENAME_MAX,
                                EXFAT_ENAME_MAX * sizeof(le16_t));
                next_entry(ef, dir, &cluster, &offset);
-               exfat_pwrite(ef->fd, &name_entry, sizeof(name_entry),
+               exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
                                co2o(ef, cluster, offset));
        }
 
@@ -838,10 +838,10 @@ 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->fd, &meta1, sizeof(meta1),
+       exfat_pread(ef->dev, &meta1, sizeof(meta1),
                        co2o(ef, old_cluster, old_offset));
        next_entry(ef, node->parent, &old_cluster, &old_offset);
-       exfat_pread(ef->fd, &meta2, sizeof(meta2),
+       exfat_pread(ef->dev, &meta2, sizeof(meta2),
                        co2o(ef, old_cluster, old_offset));
        meta1.continuations = 1 + name_entries;
        meta2.name_hash = exfat_calc_name_hash(ef, name);
@@ -853,10 +853,10 @@ static void rename_entry(struct exfat* ef, struct exfat_node* dir,
        node->entry_cluster = new_cluster;
        node->entry_offset = new_offset;
 
-       exfat_pwrite(ef->fd, &meta1, sizeof(meta1),
+       exfat_pwrite(ef->dev, &meta1, sizeof(meta1),
                        co2o(ef, new_cluster, new_offset));
        next_entry(ef, dir, &new_cluster, &new_offset);
-       exfat_pwrite(ef->fd, &meta2, sizeof(meta2),
+       exfat_pwrite(ef->dev, &meta2, sizeof(meta2),
                        co2o(ef, new_cluster, new_offset));
 
        for (i = 0; i < name_entries; i++)
@@ -865,7 +865,7 @@ 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->fd, &name_entry, sizeof(name_entry),
+               exfat_pwrite(ef->dev, &name_entry, sizeof(name_entry),
                                co2o(ef, new_cluster, new_offset));
        }
 
@@ -1015,7 +1015,7 @@ int exfat_set_label(struct exfat* ef, const char* label)
        if (entry.length == 0)
                entry.type ^= EXFAT_ENTRY_VALID;
 
-       exfat_pwrite(ef->fd, &entry, sizeof(struct exfat_entry_label),
+       exfat_pwrite(ef->dev, &entry, sizeof(struct exfat_entry_label),
                        co2o(ef, cluster, offset));
        return 0;
 }

diff --git a/mkfs/cbm.c b/mkfs/cbm.c
index d5df9cb..1a79a6b 100644 (file)
--- a/mkfs/cbm.c
+++ b/mkfs/cbm.c
@@ -36,7 +36,7 @@ off_t cbm_size(void)
        return DIV_ROUND_UP(le32_to_cpu(sb.cluster_count), CHAR_BIT);
 }
 
-int cbm_write(off_t base, int fd)
+int cbm_write(struct exfat_dev* dev, off_t base)
 {
        uint32_t allocated_clusters =
                        DIV_ROUND_UP(cbm_size(), CLUSTER_SIZE(sb)) +
@@ -54,7 +54,7 @@ int cbm_write(off_t base, int fd)
                        BMAP_SET(bitmap, i);
                else
                        BMAP_CLR(bitmap, i);
-       if (exfat_write(fd, bitmap, bitmap_size) < 0)
+       if (exfat_write(dev, bitmap, bitmap_size) < 0)
                return errno;
        free(bitmap);
 

diff --git a/mkfs/cbm.h b/mkfs/cbm.h
index 796673d..b6007e0 100644 (file)
--- a/mkfs/cbm.h
+++ b/mkfs/cbm.h
@@ -23,6 +23,6 @@
 
 off_t cbm_alignment(void);
 off_t cbm_size(void);
-int cbm_write(off_t base, int fd);
+int cbm_write(struct exfat_dev* dev, off_t base);
 
 #endif /* ifndef MKFS_CBM_H_INCLUDED */

diff --git a/mkfs/fat.c b/mkfs/fat.c
index ecd5831..21d74d4 100644 (file)
--- a/mkfs/fat.c
+++ b/mkfs/fat.c
@@ -36,28 +36,30 @@ off_t fat_size(void)
        return (off_t) le32_to_cpu(sb.fat_sector_count) * SECTOR_SIZE(sb);
 }
 
-static cluster_t fat_write_entry(cluster_t cluster, cluster_t value, int fd)
+static cluster_t fat_write_entry(struct exfat_dev* dev, cluster_t cluster,
+               cluster_t value)
 {
        le32_t fat_entry = cpu_to_le32(value);
-       if (exfat_write(fd, &fat_entry, sizeof(fat_entry)) < 0)
+       if (exfat_write(dev, &fat_entry, sizeof(fat_entry)) < 0)
                return 0;
        return cluster + 1;
 }
 
-static cluster_t fat_write_entries(cluster_t cluster, uint64_t length, int fd)
+static cluster_t fat_write_entries(struct exfat_dev* dev, cluster_t cluster,
+               uint64_t length)
 {
        cluster_t end = cluster + DIV_ROUND_UP(length, CLUSTER_SIZE(sb));
 
        while (cluster < end - 1)
        {
-               cluster = fat_write_entry(cluster, cluster + 1, fd);
+               cluster = fat_write_entry(dev, cluster, cluster + 1);
                if (cluster == 0)
                        return 0;
        }
-       return fat_write_entry(cluster, EXFAT_CLUSTER_END, fd);
+       return fat_write_entry(dev, cluster, EXFAT_CLUSTER_END);
 }
 
-int fat_write(off_t base, int fd)
+int fat_write(struct exfat_dev* dev, off_t base)
 {
        cluster_t c = 0;
 
@@ -65,15 +67,15 @@ int fat_write(off_t base, int fd)
                exfat_bug("unexpected FAT location: %"PRIu64" (expected %u)",
                                base, le32_to_cpu(sb.fat_sector_start) * SECTOR_SIZE(sb));
 
-       if (!(c = fat_write_entry(c, 0xfffffff8, fd))) /* media type */
+       if (!(c = fat_write_entry(dev, c, 0xfffffff8))) /* media type */
                return errno;
-       if (!(c = fat_write_entry(c, 0xffffffff, fd))) /* some weird constant */
+       if (!(c = fat_write_entry(dev, c, 0xffffffff))) /* some weird constant */
                return errno;
-       if (!(c = fat_write_entries(c, cbm_size(), fd)))
+       if (!(c = fat_write_entries(dev, c, cbm_size())))
                return errno;
-       if (!(c = fat_write_entries(c, uct_size(), fd)))
+       if (!(c = fat_write_entries(dev, c, uct_size())))
                return errno;
-       if (!(c = fat_write_entries(c, rootdir_size(), fd)))
+       if (!(c = fat_write_entries(dev, c, rootdir_size())))
                return errno;
 
        return 0;

diff --git a/mkfs/fat.h b/mkfs/fat.h
index 0df4fea..01b5c20 100644 (file)
--- a/mkfs/fat.h
+++ b/mkfs/fat.h
@@ -23,6 +23,6 @@
 
 off_t fat_alignment(void);
 off_t fat_size(void);
-int fat_write(off_t base, int fd);
+int fat_write(struct exfat_dev* dev, off_t base);
 
 #endif /* ifndef MKFS_FAT_H_INCLUDED */

diff --git a/mkfs/main.c b/mkfs/main.c
index df976c9..885dd71 100644 (file)
--- a/mkfs/main.c
+++ b/mkfs/main.c
@@ -46,7 +46,7 @@ struct exfat_structure
        int order;
        off_t (*get_alignment)(void);
        off_t (*get_size)(void);
-       int (*write_data)(off_t, int);
+       int (*write_data)(struct exfat_dev*, off_t);
 };
 
 static int init_sb(off_t volume_size, int sector_bits, int spc_bits,
@@ -99,7 +99,7 @@ static int init_sb(off_t volume_size, int sector_bits, int spc_bits,
        return 0;
 }
 
-static int erase_device(int fd)
+static int erase_device(struct exfat_dev* dev)
 {
        off_t erase_size;
        off_t erase_blocks;
@@ -123,7 +123,7 @@ static int erase_device(int fd)
 
        erase_blocks = DIV_ROUND_UP(erase_size, block_size);
 
-       if (exfat_seek(fd, 0, SEEK_SET) == (off_t) -1)
+       if (exfat_seek(dev, 0, SEEK_SET) == (off_t) -1)
        {
                exfat_error("seek failed");
                return 1;
@@ -139,7 +139,7 @@ static int erase_device(int fd)
 
        for (i = 0; i < erase_blocks; i++)
        {
-               if (exfat_write(fd, block, block_size) < 0)
+               if (exfat_write(dev, block, block_size) < 0)
                {
                        free(block);
                        exfat_error("failed to erase block %"PRIu64, i);
@@ -183,20 +183,20 @@ static struct exfat_structure structures[] =
 };
 #undef FS_OBJECT
 
-static off_t write_structure(int fd, struct exfat_structure* structure,
-               off_t current)
+static off_t write_structure(struct exfat_dev* dev,
+               struct exfat_structure* structure, off_t current)
 {
        off_t alignment = structure->get_alignment();
        off_t base = ROUND_UP(current, alignment);
 
-       if (exfat_seek(fd, base, SEEK_SET) == (off_t) -1)
+       if (exfat_seek(dev, base, SEEK_SET) == (off_t) -1)
        {
                exfat_error("seek to %"PRIu64" failed", base);
                return -1;
        }
        if (structure->order > 0)
        {
-               int rc = structure->write_data(base, fd);
+               int rc = structure->write_data(dev, base);
                if (rc != 0)
                {
                        exfat_error("%s creation failed: %s", structure->name,
@@ -208,7 +208,7 @@ static off_t write_structure(int fd, struct exfat_structure* structure,
        return base + structure->get_size();
 }
 
-static int write_structures(int fd)
+static int write_structures(struct exfat_dev* dev)
 {
        off_t current;
        size_t i;
@@ -220,7 +220,7 @@ static int write_structures(int fd)
                remainder = 0;
                for (i = 0; i < sizeof(structures) / sizeof(structures[0]); i++)
                {
-                       current = write_structure(fd, &structures[i], current);
+                       current = write_structure(dev, &structures[i], current);
                        if (current == (off_t) -1)
                                return 1;
                        remainder += structures[i].order;
@@ -275,17 +275,17 @@ static uint32_t get_volume_serial(uint32_t user_defined)
 static int mkfs(const char* spec, int sector_bits, int spc_bits,
                const char* volume_label, uint32_t volume_serial, int first_sector)
 {
-       int fd;
+       struct exfat_dev* dev;
        off_t volume_size;
 
-       fd = exfat_open(spec, 0);
-       if (fd < 0)
+       dev = exfat_open(spec, 0);
+       if (dev == NULL)
                return 1;
 
-       volume_size = exfat_seek(fd, 0, SEEK_END);
+       volume_size = exfat_seek(dev, 0, SEEK_END);
        if (volume_size == (off_t) -1)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                exfat_error("seek failed");
                return 1;
        }
@@ -293,14 +293,14 @@ static int mkfs(const char* spec, int sector_bits, int spc_bits,
 
        if (set_volume_label(volume_label) != 0)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                return 1;
        }
 
        volume_serial = get_volume_serial(volume_serial);
        if (volume_serial == 0)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                exfat_error("failed to get current time to form volume id");
                return 1;
        }
@@ -308,33 +308,33 @@ static int mkfs(const char* spec, int sector_bits, int spc_bits,
        if (init_sb(volume_size, sector_bits, spc_bits, volume_serial,
                                first_sector) != 0)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                return 1;
        }
 
        printf("Creating... %2u%%", 0);
        fflush(stdout);
-       if (erase_device(fd) != 0)
+       if (erase_device(dev) != 0)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                return 1;
        }
-       if (write_structures(fd) != 0)
+       if (write_structures(dev) != 0)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                return 1;
        }
        puts("\b\b\b\bdone.");
 
        printf("Flushing... ");
        fflush(stdout);
-       if (exfat_fsync(fd) != 0)
+       if (exfat_fsync(dev) != 0)
        {
-               exfat_close(fd);
+               exfat_close(dev);
                return 1;
        }
        puts("done.");
-       if (exfat_close(fd) != 0)
+       if (exfat_close(dev) != 0)
                return 1;
        printf("File system created successfully.\n");
        return 0;

diff --git a/mkfs/rootdir.c b/mkfs/rootdir.c
index 98fc990..547ca3b 100644 (file)
--- a/mkfs/rootdir.c
+++ b/mkfs/rootdir.c
@@ -32,13 +32,13 @@ off_t rootdir_size(void)
        return CLUSTER_SIZE(sb);
 }
 
-int rootdir_write(off_t base, int fd)
+int rootdir_write(struct exfat_dev* dev, off_t base)
 {
-       if (exfat_write(fd, &label_entry, sizeof(struct exfat_entry)) < 0)
+       if (exfat_write(dev, &label_entry, sizeof(struct exfat_entry)) < 0)
                return 1;
-       if (exfat_write(fd, &bitmap_entry, sizeof(struct exfat_entry)) < 0)
+       if (exfat_write(dev, &bitmap_entry, sizeof(struct exfat_entry)) < 0)
                return 1;
-       if (exfat_write(fd, &upcase_entry, sizeof(struct exfat_entry)) < 0)
+       if (exfat_write(dev, &upcase_entry, sizeof(struct exfat_entry)) < 0)
                return 1;
        sb.rootdir_cluster = cpu_to_le32(OFFSET_TO_CLUSTER(base));
        return 0;

diff --git a/mkfs/rootdir.h b/mkfs/rootdir.h
index 07ec2ad..f3df708 100644 (file)
--- a/mkfs/rootdir.h
+++ b/mkfs/rootdir.h
@@ -23,6 +23,6 @@
 
 off_t rootdir_alignment(void);
 off_t rootdir_size(void);
-int rootdir_write(off_t base, int fd);
+int rootdir_write(struct exfat_dev* dev, off_t base);
 
 #endif /* ifndef MKFS_ROOTDIR_H_INCLUDED */

diff --git a/mkfs/uct.c b/mkfs/uct.c
index 6c58197..886bd32 100644 (file)
--- a/mkfs/uct.c
+++ b/mkfs/uct.c
@@ -43,9 +43,9 @@ static le32_t uct_checksum(void)
        return cpu_to_le32(sum);
 }
 
-int uct_write(off_t base, int fd)
+int uct_write(struct exfat_dev* dev, off_t base)
 {
-       if (exfat_write(fd, upcase_table, sizeof(upcase_table)) < 0)
+       if (exfat_write(dev, upcase_table, sizeof(upcase_table)) < 0)
                return errno;
        upcase_entry.checksum = uct_checksum();
        upcase_entry.start_cluster = cpu_to_le32(OFFSET_TO_CLUSTER(base));

diff --git a/mkfs/uct.h b/mkfs/uct.h
index 154c87d..b35a612 100644 (file)
--- a/mkfs/uct.h
+++ b/mkfs/uct.h
@@ -23,6 +23,6 @@
 
 off_t uct_alignment(void);
 off_t uct_size(void);
-int uct_write(off_t base, int fd);
+int uct_write(struct exfat_dev* dev, off_t base);
 
 #endif /* ifndef MKFS_UCT_H_INCLUDED */

diff --git a/mkfs/vbr.c b/mkfs/vbr.c
index 62fdccf..4580565 100644 (file)
--- a/mkfs/vbr.c
+++ b/mkfs/vbr.c
@@ -33,7 +33,7 @@ off_t vbr_size(void)
        return 12 * SECTOR_SIZE(sb);
 }
 
-int vbr_write(off_t base, int fd)
+int vbr_write(struct exfat_dev* dev, off_t base)
 {
        uint32_t checksum;
        le32_t* sector = malloc(SECTOR_SIZE(sb));
@@ -42,7 +42,7 @@ int vbr_write(off_t base, int fd)
        if (sector == NULL)
                return errno;
 
-       if (exfat_write(fd, &sb, sizeof(struct exfat_super_block)) < 0)
+       if (exfat_write(dev, &sb, sizeof(struct exfat_super_block)) < 0)
        {
                free(sector);
                return errno;
@@ -53,7 +53,7 @@ int vbr_write(off_t base, int fd)
        sector[SECTOR_SIZE(sb) / sizeof(sector[0]) - 1] = cpu_to_le32(0xaa550000);
        for (i = 0; i < 8; i++)
        {
-               if (exfat_write(fd, sector, SECTOR_SIZE(sb)) < 0)
+               if (exfat_write(dev, sector, SECTOR_SIZE(sb)) < 0)
                {
                        free(sector);
                        return errno;
@@ -62,13 +62,13 @@ int vbr_write(off_t base, int fd)
        }
 
        memset(sector, 0, SECTOR_SIZE(sb));
-       if (exfat_write(fd, sector, SECTOR_SIZE(sb)) < 0)
+       if (exfat_write(dev, sector, SECTOR_SIZE(sb)) < 0)
        {
                free(sector);
                return errno;
        }
        checksum = exfat_vbr_add_checksum(sector, SECTOR_SIZE(sb), checksum);
-       if (exfat_write(fd, sector, SECTOR_SIZE(sb)) < 0)
+       if (exfat_write(dev, sector, SECTOR_SIZE(sb)) < 0)
        {
                free(sector);
                return errno;
@@ -77,7 +77,7 @@ int vbr_write(off_t base, int fd)
 
        for (i = 0; i < SECTOR_SIZE(sb) / sizeof(sector[0]); i++)
                sector[i] = cpu_to_le32(checksum);
-       if (exfat_write(fd, sector, SECTOR_SIZE(sb)) < 0)
+       if (exfat_write(dev, sector, SECTOR_SIZE(sb)) < 0)
        {
                free(sector);
                return errno;

diff --git a/mkfs/vbr.h b/mkfs/vbr.h
index fb6b7cd..d4cd56d 100644 (file)
--- a/mkfs/vbr.h
+++ b/mkfs/vbr.h
@@ -23,6 +23,6 @@
 
 off_t vbr_alignment(void);
 off_t vbr_size(void);
-int vbr_write(off_t base, int fd);
+int vbr_write(struct exfat_dev* dev, off_t base);
 
 #endif /* ifndef MKFS_VBR_H_INCLUDED */