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 <sys/types.h>
  12 #include <sys/uio.h>
  13 #define __USE_UNIX98 /* for pread() in Linux */
  14 #include <unistd.h>
  15
  16 #if _FILE_OFFSET_BITS != 64
  17         #error You should define _FILE_OFFSET_BITS=64
  18 #endif
  19
  20 void exfat_read_raw(void* buffer, size_t size, off_t offset, int fd)
  21 {
  22         if (pread(fd, buffer, size, offset) != size)
  23                 exfat_bug("failed to read %zu bytes from file at %llu", size, offset);
  24 }
  25
  26 void exfat_write_raw(const void* buffer, size_t size, off_t offset, int fd)
  27 {
  28         if (pwrite(fd, buffer, size, offset) != size)
  29                 exfat_bug("failed to write %zu bytes to file at %llu", size, offset);
  30 }
  31
  32 ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node,
  33                 void* buffer, size_t size, off_t offset)
  34 {
  35         cluster_t cluster;
  36         char* bufp = buffer;
  37         off_t lsize, loffset, remainder;
  38
  39         if (offset >= node->size)
  40                 return 0;
  41         if (size == 0)
  42                 return 0;
  43
  44         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
  45         if (CLUSTER_INVALID(cluster))
  46         {
  47                 exfat_error("got invalid cluster");
  48                 return -1;
  49         }
  50
  51         loffset = offset % CLUSTER_SIZE(*ef->sb);
  52         remainder = MIN(size, node->size - offset);
  53         while (remainder > 0)
  54         {
  55                 if (CLUSTER_INVALID(cluster))
  56                 {
  57                         exfat_error("got invalid cluster");
  58                         return -1;
  59                 }
  60                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
  61                 exfat_read_raw(bufp, lsize, exfat_c2o(ef, cluster) + loffset, ef->fd);
  62                 bufp += lsize;
  63                 loffset = 0;
  64                 remainder -= lsize;
  65                 cluster = exfat_next_cluster(ef, node, cluster);
  66         }
  67         return size - remainder;
  68 }
  69
  70 ssize_t exfat_write(struct exfat* ef, struct exfat_node* node,
  71                 const void* buffer, size_t size, off_t offset)
  72 {
  73         cluster_t cluster;
  74         const char* bufp = buffer;
  75         off_t lsize, loffset, remainder;
  76
  77         if (offset + size > node->size)
  78                 exfat_truncate(ef, node, offset + size);
  79         if (size == 0)
  80                 return 0;
  81
  82         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
  83         if (CLUSTER_INVALID(cluster))
  84         {
  85                 exfat_error("got invalid cluster");
  86                 return -1;
  87         }
  88
  89         loffset = offset % CLUSTER_SIZE(*ef->sb);
  90         remainder = size;
  91         while (remainder > 0)
  92         {
  93                 if (CLUSTER_INVALID(cluster))
  94                 {
  95                         exfat_error("got invalid cluster");
  96                         return -1;
  97                 }
  98                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
  99                 exfat_write_raw(bufp, lsize, exfat_c2o(ef, cluster) + loffset, ef->fd);
 100                 bufp += lsize;
 101                 loffset = 0;
 102                 remainder -= lsize;
 103                 cluster = exfat_next_cluster(ef, node, cluster);
 104         }
 105         node->mtime = time(NULL);
 106         node->flags |= EXFAT_ATTRIB_DIRTY;
 107         return size - remainder;
 108 }