libexfat/io.c

   1 /*
   2  *  io.c
   3  *  exFAT file system implementation library.
   4  *
   5  *  Created by Andrew Nayenko on 02.09.09.
   6  *  This software is distributed under the GNU General Public License
   7  *  version 3 or any later.
   8  */
   9
  10 #include "exfat.h"
  11 #include <inttypes.h>
  12 #include <sys/types.h>
  13 #include <sys/uio.h>
  14 #define __USE_UNIX98 /* for pread() in Linux */
  15 #include <unistd.h>
  16
  17 #if _FILE_OFFSET_BITS != 64
  18         #error You should define _FILE_OFFSET_BITS=64
  19 #endif
  20
  21 void exfat_read_raw(void* buffer, size_t size, off_t offset, int fd)
  22 {
  23         if (pread(fd, buffer, size, offset) != size)
  24                 exfat_bug("failed to read %zu bytes from file at %"PRIu64, size,
  25                                 (uint64_t) offset);
  26 }
  27
  28 void exfat_write_raw(const void* buffer, size_t size, off_t offset, int fd)
  29 {
  30         if (pwrite(fd, buffer, size, offset) != size)
  31                 exfat_bug("failed to write %zu bytes to file at %"PRIu64, size,
  32                                 (uint64_t) offset);
  33 }
  34
  35 ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node,
  36                 void* buffer, size_t size, off_t offset)
  37 {
  38         cluster_t cluster;
  39         char* bufp = buffer;
  40         off_t lsize, loffset, remainder;
  41
  42         if (offset >= node->size)
  43                 return 0;
  44         if (size == 0)
  45                 return 0;
  46
  47         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
  48         if (CLUSTER_INVALID(cluster))
  49         {
  50                 exfat_error("got invalid cluster");
  51                 return -1;
  52         }
  53
  54         loffset = offset % CLUSTER_SIZE(*ef->sb);
  55         remainder = MIN(size, node->size - offset);
  56         while (remainder > 0)
  57         {
  58                 if (CLUSTER_INVALID(cluster))
  59                 {
  60                         exfat_error("got invalid cluster");
  61                         return -1;
  62                 }
  63                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
  64                 exfat_read_raw(bufp, lsize, exfat_c2o(ef, cluster) + loffset, ef->fd);
  65                 bufp += lsize;
  66                 loffset = 0;
  67                 remainder -= lsize;
  68                 cluster = exfat_next_cluster(ef, node, cluster);
  69         }
  70         return size - remainder;
  71 }
  72
  73 ssize_t exfat_write(struct exfat* ef, struct exfat_node* node,
  74                 const void* buffer, size_t size, off_t offset)
  75 {
  76         cluster_t cluster;
  77         const char* bufp = buffer;
  78         off_t lsize, loffset, remainder;
  79
  80         if (offset + size > node->size)
  81         {
  82                 int rc = exfat_truncate(ef, node, offset + size);
  83                 if (rc != 0)
  84                         return rc;
  85         }
  86         if (size == 0)
  87                 return 0;
  88
  89         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
  90         if (CLUSTER_INVALID(cluster))
  91         {
  92                 exfat_error("got invalid cluster");
  93                 return -1;
  94         }
  95
  96         loffset = offset % CLUSTER_SIZE(*ef->sb);
  97         remainder = size;
  98         while (remainder > 0)
  99         {
 100                 if (CLUSTER_INVALID(cluster))
 101                 {
 102                         exfat_error("got invalid cluster");
 103                         return -1;
 104                 }
 105                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
 106                 exfat_write_raw(bufp, lsize, exfat_c2o(ef, cluster) + loffset, ef->fd);
 107                 bufp += lsize;
 108                 loffset = 0;
 109                 remainder -= lsize;
 110                 cluster = exfat_next_cluster(ef, node, cluster);
 111         }
 112         node->mtime = time(NULL);
 113         node->flags |= EXFAT_ATTRIB_DIRTY;
 114         return size - remainder;
 115 }