Merge tag 'upstream/0.9.7'
[sven/exfat-utils.git] / 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 #include <string.h>
30 #ifdef USE_UBLIO
31 #include <sys/uio.h>
32 #include <ublio.h>
33 #endif
34
35 #if _FILE_OFFSET_BITS != 64
36         #error You should define _FILE_OFFSET_BITS=64
37 #endif
38
39 struct exfat_dev
40 {
41         int fd;
42 #ifdef USE_UBLIO
43         off_t pos;
44         ublio_filehandle_t ufh;
45 #endif
46 };
47
48 struct exfat_dev* exfat_open(const char* spec, int ro)
49 {
50         struct exfat_dev* dev;
51         struct stat stbuf;
52 #ifdef USE_UBLIO
53         struct ublio_param up;
54 #endif
55
56         dev = malloc(sizeof(struct exfat_dev));
57         if (dev == NULL)
58         {
59                 exfat_error("failed to allocate memory for device structure");
60                 return NULL;
61         }
62
63         dev->fd = open(spec, ro ? O_RDONLY : O_RDWR);
64         if (dev->fd < 0)
65         {
66                 free(dev);
67                 exfat_error("failed to open `%s' in read-%s mode", spec,
68                                 ro ? "only" : "write");
69                 return NULL;
70         }
71         if (fstat(dev->fd, &stbuf) != 0)
72         {
73                 close(dev->fd);
74                 free(dev);
75                 exfat_error("failed to fstat `%s'", spec);
76                 return NULL;
77         }
78         if (!S_ISBLK(stbuf.st_mode) &&
79                 !S_ISCHR(stbuf.st_mode) &&
80                 !S_ISREG(stbuf.st_mode))
81         {
82                 close(dev->fd);
83                 free(dev);
84                 exfat_error("`%s' is neither a device, nor a regular file", spec);
85                 return NULL;
86         }
87
88 #ifdef USE_UBLIO
89         memset(&up, 0, sizeof(struct ublio_param));
90         up.up_blocksize = 256 * 1024;
91         up.up_items = 64;
92         up.up_grace = 32;
93         up.up_priv = &dev->fd;
94
95         dev->pos = 0;
96         dev->ufh = ublio_open(&up);
97         if (dev->ufh == NULL)
98         {
99                 close(dev->fd);
100                 free(dev);
101                 exfat_error("failed to initialize ublio");
102                 return NULL;
103         }
104 #endif
105
106         return dev;
107 }
108
109 int exfat_close(struct exfat_dev* dev)
110 {
111 #ifdef USE_UBLIO
112         if (ublio_close(dev->ufh) != 0)
113                 exfat_error("failed to close ublio");
114 #endif
115         if (close(dev->fd) != 0)
116         {
117                 free(dev);
118                 exfat_error("failed to close device");
119                 return 1;
120         }
121         free(dev);
122         return 0;
123 }
124
125 int exfat_fsync(struct exfat_dev* dev)
126 {
127 #ifdef USE_UBLIO
128         if (ublio_fsync(dev->ufh) != 0)
129 #else
130         if (fsync(dev->fd) != 0)
131 #endif
132         {
133                 exfat_error("fsync failed");
134                 return 1;
135         }
136         return 0;
137 }
138
139 off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence)
140 {
141 #ifdef USE_UBLIO
142         /* XXX SEEK_CUR will be handled incorrectly */
143         return dev->pos = lseek(dev->fd, offset, whence);
144 #else
145         return lseek(dev->fd, offset, whence);
146 #endif
147 }
148
149 ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size)
150 {
151 #ifdef USE_UBLIO
152         ssize_t result = ublio_pread(dev->ufh, buffer, size, dev->pos);
153         if (result >= 0)
154                 dev->pos += size;
155         return result;
156 #else
157         return read(dev->fd, buffer, size);
158 #endif
159 }
160
161 ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size)
162 {
163 #ifdef USE_UBLIO
164         ssize_t result = ublio_pwrite(dev->ufh, buffer, size, dev->pos);
165         if (result >= 0)
166                 dev->pos += size;
167         return result;
168 #else
169         return write(dev->fd, buffer, size);
170 #endif
171 }
172
173 void exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
174                 off_t offset)
175 {
176 #ifdef USE_UBLIO
177         if (ublio_pread(dev->ufh, buffer, size, offset) != size)
178 #else
179         if (pread(dev->fd, buffer, size, offset) != size)
180 #endif
181                 exfat_bug("failed to read %zu bytes from file at %"PRIu64, size,
182                                 (uint64_t) offset);
183 }
184
185 void exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
186                 off_t offset)
187 {
188 #ifdef USE_UBLIO
189         if (ublio_pwrite(dev->ufh, buffer, size, offset) != size)
190 #else
191         if (pwrite(dev->fd, buffer, size, offset) != size)
192 #endif
193                 exfat_bug("failed to write %zu bytes to file at %"PRIu64, size,
194                                 (uint64_t) offset);
195 }
196
197 ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
198                 void* buffer, size_t size, off_t offset)
199 {
200         cluster_t cluster;
201         char* bufp = buffer;
202         off_t lsize, loffset, remainder;
203
204         if (offset >= node->size)
205                 return 0;
206         if (size == 0)
207                 return 0;
208
209         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
210         if (CLUSTER_INVALID(cluster))
211         {
212                 exfat_error("got invalid cluster");
213                 return -1;
214         }
215
216         loffset = offset % CLUSTER_SIZE(*ef->sb);
217         remainder = MIN(size, node->size - offset);
218         while (remainder > 0)
219         {
220                 if (CLUSTER_INVALID(cluster))
221                 {
222                         exfat_error("got invalid cluster");
223                         return -1;
224                 }
225                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
226                 exfat_pread(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
227                 bufp += lsize;
228                 loffset = 0;
229                 remainder -= lsize;
230                 cluster = exfat_next_cluster(ef, node, cluster);
231         }
232         if (!ef->ro && !ef->noatime)
233                 exfat_update_atime(node);
234         return size - remainder;
235 }
236
237 ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
238                 const void* buffer, size_t size, off_t offset)
239 {
240         cluster_t cluster;
241         const char* bufp = buffer;
242         off_t lsize, loffset, remainder;
243
244         if (offset + size > node->size)
245         {
246                 int rc = exfat_truncate(ef, node, offset + size);
247                 if (rc != 0)
248                         return rc;
249         }
250         if (size == 0)
251                 return 0;
252
253         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
254         if (CLUSTER_INVALID(cluster))
255         {
256                 exfat_error("got invalid cluster");
257                 return -1;
258         }
259
260         loffset = offset % CLUSTER_SIZE(*ef->sb);
261         remainder = size;
262         while (remainder > 0)
263         {
264                 if (CLUSTER_INVALID(cluster))
265                 {
266                         exfat_error("got invalid cluster");
267                         return -1;
268                 }
269                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
270                 exfat_pwrite(ef->dev, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
271                 bufp += lsize;
272                 loffset = 0;
273                 remainder -= lsize;
274                 cluster = exfat_next_cluster(ef, node, cluster);
275         }
276         exfat_update_mtime(node);
277         return size - remainder;
278 }