OSDN Git Service

Use appropriate feature test macro to enable pread() and pwrite() declarations.
[android-x86/external-exfat.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
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 void exfat_pread(int fd, void* buffer, size_t size, off_t offset)
83 {
84         if (pread(fd, buffer, size, offset) != size)
85                 exfat_bug("failed to read %zu bytes from file at %"PRIu64, size,
86                                 (uint64_t) offset);
87 }
88
89 void exfat_pwrite(int fd, const void* buffer, size_t size, off_t offset)
90 {
91         if (pwrite(fd, buffer, size, offset) != size)
92                 exfat_bug("failed to write %zu bytes to file at %"PRIu64, size,
93                                 (uint64_t) offset);
94 }
95
96 ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
97                 void* buffer, size_t size, off_t offset)
98 {
99         cluster_t cluster;
100         char* bufp = buffer;
101         off_t lsize, loffset, remainder;
102
103         if (offset >= node->size)
104                 return 0;
105         if (size == 0)
106                 return 0;
107
108         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
109         if (CLUSTER_INVALID(cluster))
110         {
111                 exfat_error("got invalid cluster");
112                 return -1;
113         }
114
115         loffset = offset % CLUSTER_SIZE(*ef->sb);
116         remainder = MIN(size, node->size - offset);
117         while (remainder > 0)
118         {
119                 if (CLUSTER_INVALID(cluster))
120                 {
121                         exfat_error("got invalid cluster");
122                         return -1;
123                 }
124                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
125                 exfat_pread(ef->fd, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
126                 bufp += lsize;
127                 loffset = 0;
128                 remainder -= lsize;
129                 cluster = exfat_next_cluster(ef, node, cluster);
130         }
131         if (!ef->ro && !ef->noatime)
132                 exfat_update_atime(node);
133         return size - remainder;
134 }
135
136 ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
137                 const void* buffer, size_t size, off_t offset)
138 {
139         cluster_t cluster;
140         const char* bufp = buffer;
141         off_t lsize, loffset, remainder;
142
143         if (offset + size > node->size)
144         {
145                 int rc = exfat_truncate(ef, node, offset + size);
146                 if (rc != 0)
147                         return rc;
148         }
149         if (size == 0)
150                 return 0;
151
152         cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
153         if (CLUSTER_INVALID(cluster))
154         {
155                 exfat_error("got invalid cluster");
156                 return -1;
157         }
158
159         loffset = offset % CLUSTER_SIZE(*ef->sb);
160         remainder = size;
161         while (remainder > 0)
162         {
163                 if (CLUSTER_INVALID(cluster))
164                 {
165                         exfat_error("got invalid cluster");
166                         return -1;
167                 }
168                 lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
169                 exfat_pwrite(ef->fd, bufp, lsize, exfat_c2o(ef, cluster) + loffset);
170                 bufp += lsize;
171                 loffset = 0;
172                 remainder -= lsize;
173                 cluster = exfat_next_cluster(ef, node, cluster);
174         }
175         exfat_update_mtime(node);
176         return size - remainder;
177 }