libexfat/io.c

   1 /*
   2         io.c (02.09.09)
   3         exFAT file system implementation library.
   4
   5         Copyright (C) 2009, 2010  Andrew Nayenko
   6
   7         This program is free software: you can redistribute it and/or modify
   8         it under the terms of the GNU General Public License as published by
   9         the Free Software Foundation, either version 3 of the License, or
  10         (at your option) any later version.
  11
  12         This program is distributed in the hope that it will be useful,
  13         but WITHOUT ANY WARRANTY; without even the implied warranty of
  14         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15         GNU General Public License for more details.
  16
  17         You should have received a copy of the GNU General Public License
  18         along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #define _XOPEN_SOURCE 500 /* for pread() and pwrite() in Linux */
  22 #include "exfat.h"
  23 #include <inttypes.h>
  24 #include <sys/types.h>
  25 #include <sys/uio.h>
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29
  30 #if _FILE_OFFSET_BITS != 64
  31         #error You should define _FILE_OFFSET_BITS=64
  32 #endif
  33
  34 int exfat_open(const char* spec, int ro)
  35 {
  36         int fd;
  37         struct stat stbuf;
  38
  39         fd = open(spec, ro ? O_RDONLY : O_RDWR);
  40         if (fd < 0)
  41         {
  42                 exfat_error("failed to open `%s' in read-%s mode", spec,
  43                                 ro ? "only" : "write");
  44                 return -1;
  45         }
  46         if (fstat(fd, &stbuf) != 0)
  47         {
  48                 exfat_close(fd);
  49                 exfat_error("failed to fstat `%s'", spec);
  50                 return -1;
  51         }
  52         if (!S_ISBLK(stbuf.st_mode) && !S_ISREG(stbuf.st_mode))
  53         {
  54                 exfat_close(fd);
  55                 exfat_error("`%s' is neither a block device, nor a regular file",
  56                                 spec);
  57                 return -1;
  58         }
  59         return fd;
  60 }
  61
  62 int exfat_close(int fd)
  63 {
  64         if (close(fd) != 0)
  65         {
  66                 exfat_error("close failed");
  67                 return 1;
  68         }
  69         return 0;
  70 }
  71
  72 int exfat_fsync(int fd)
  73 {
  74         if (fsync(fd) != 0)
  75         {
  76                 exfat_error("fsync failed");
  77                 return 1;
  78         }
  79         return 0;
  80 }
  81
  82 ssize_t exfat_read(int fd, void* buffer, size_t size)
  83 {
  84         return read(fd, buffer, size);
  85 }
  86
  87 ssize_t exfat_write(int fd, const void* buffer, size_t size)
  88 {
  89         return write(fd, buffer, size);
  90 }
  91
  92 void exfat_pread(int fd, void* buffer, size_t size, off_t offset)
  93 {
  94         if (pread(fd, buffer, size, offset) != size)
  95                 exfat_bug("failed to read %zu bytes from file at %"PRIu64, size,
  96                                 (uint64_t) offset);
  97 }
  98
  99 void exfat_pwrite(int fd, const void* buffer, size_t size, off_t offset)
 100 {
 101         if (pwrite(fd, buffer, size, offset) != size)
 102                 exfat_bug("failed to write %zu bytes to file at %"PRIu64, size,
 103                                 (uint64_t) offset);
 104 }
 105
 106 ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
 107                 void* buffer, size_t size, off_t offset)
 108 {
 109         cluster_t cluster;
 110         char* bufp = buffer;
 111         off_t lsize, loffset, remainder;
 112
 113         if (offset >= node->size)
 114                 return 0;
 115         if (size == 0)
 116                 return 0;
 117
 118         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
 119         if (CLUSTER_INVALID(cluster))
 120         {
 121                 exfat_error("got invalid cluster");
 122                 return -1;
 123         }
 124
 125         loffset = offset % CLUSTER_SIZE(*ef->sb);
 126         remainder = MIN(size, node->size - offset);
 127         while (remainder > 0)
 128         {
 129                 if (CLUSTER_INVALID(cluster))
 130                 {
 131                         exfat_error("got invalid cluster");
 132                         return -1;
 133                 }
 134                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
 135                 exfat_pread(ef->fd, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
 136                 bufp += lsize;
 137                 loffset = 0;
 138                 remainder -= lsize;
 139                 cluster = exfat_next_cluster(ef, node, cluster);
 140         }
 141         if (!ef->ro && !ef->noatime)
 142                 exfat_update_atime(node);
 143         return size - remainder;
 144 }
 145
 146 ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
 147                 const void* buffer, size_t size, off_t offset)
 148 {
 149         cluster_t cluster;
 150         const char* bufp = buffer;
 151         off_t lsize, loffset, remainder;
 152
 153         if (offset + size > node->size)
 154         {
 155                 int rc = exfat_truncate(ef, node, offset + size);
 156                 if (rc != 0)
 157                         return rc;
 158         }
 159         if (size == 0)
 160                 return 0;
 161
 162         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
 163         if (CLUSTER_INVALID(cluster))
 164         {
 165                 exfat_error("got invalid cluster");
 166                 return -1;
 167         }
 168
 169         loffset = offset % CLUSTER_SIZE(*ef->sb);
 170         remainder = size;
 171         while (remainder > 0)
 172         {
 173                 if (CLUSTER_INVALID(cluster))
 174                 {
 175                         exfat_error("got invalid cluster");
 176                         return -1;
 177                 }
 178                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
 179                 exfat_pwrite(ef->fd, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
 180                 bufp += lsize;
 181                 loffset = 0;
 182                 remainder -= lsize;
 183                 cluster = exfat_next_cluster(ef, node, cluster);
 184         }
 185         exfat_update_mtime(node);
 186         return size - remainder;
 187 }