Commit | Line | Data |
---|---|---|
4c36ddbe AT |
1 | /* |
2 | Copyright (C) Andrew Tridgell 1998 | |
a261989c | 3 | Copyright (C) 2002 by Martin Pool |
4c36ddbe AT |
4 | |
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 2 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the Free Software | |
17 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
18 | */ | |
19 | ||
20 | /* | |
21 | File IO utilities used in rsync | |
22 | */ | |
23 | #include "rsync.h" | |
24 | ||
25 | static char last_byte; | |
26 | static int last_sparse; | |
27 | extern int sparse_files; | |
28 | ||
29 | int sparse_end(int f) | |
30 | { | |
31 | if (last_sparse) { | |
32 | do_lseek(f,-1,SEEK_CUR); | |
33 | return (write(f,&last_byte,1) == 1 ? 0 : -1); | |
34 | } | |
35 | last_sparse = 0; | |
36 | return 0; | |
37 | } | |
38 | ||
39 | ||
9dd891bb | 40 | static int write_sparse(int f,char *buf,size_t len) |
4c36ddbe | 41 | { |
a261989c | 42 | size_t l1=0, l2=0; |
4c36ddbe AT |
43 | int ret; |
44 | ||
45 | for (l1=0;l1<len && buf[l1]==0;l1++) ; | |
46 | for (l2=0;l2<(len-l1) && buf[len-(l2+1)]==0;l2++) ; | |
47 | ||
48 | last_byte = buf[len-1]; | |
49 | ||
50 | if (l1 == len || l2 > 0) | |
51 | last_sparse=1; | |
52 | ||
4440b8aa | 53 | if (l1 > 0) { |
4c36ddbe | 54 | do_lseek(f,l1,SEEK_CUR); |
4440b8aa | 55 | } |
4c36ddbe AT |
56 | |
57 | if (l1 == len) | |
58 | return len; | |
59 | ||
a261989c MP |
60 | ret = write(f, buf + l1, len - (l1+l2)); |
61 | if (ret == -1 || ret == 0) | |
62 | return ret; | |
63 | else if (ret != (int) (len - (l1+l2))) | |
4c36ddbe | 64 | return (l1+ret); |
4c36ddbe AT |
65 | |
66 | if (l2 > 0) | |
67 | do_lseek(f,l2,SEEK_CUR); | |
68 | ||
69 | return len; | |
70 | } | |
71 | ||
76c21947 WD |
72 | |
73 | static char *wf_writeBuf; | |
74 | static size_t wf_writeBufSize; | |
75 | static size_t wf_writeBufCnt; | |
76 | ||
77 | int flush_write_file(int f) | |
78 | { | |
9b9c8aaf WD |
79 | int ret = 0; |
80 | char *bp = wf_writeBuf; | |
81 | ||
82 | while (wf_writeBufCnt > 0) { | |
83 | if ((ret = write(f, bp, wf_writeBufCnt)) < 0) { | |
84 | if (errno == EINTR) | |
85 | continue; | |
86 | return ret; | |
87 | } | |
88 | wf_writeBufCnt -= ret; | |
89 | bp += ret; | |
90 | } | |
76c21947 WD |
91 | return ret; |
92 | } | |
93 | ||
9533e15a S |
94 | /* |
95 | * write_file does not allow incomplete writes. It loops internally | |
96 | * until len bytes are written or errno is set. | |
97 | */ | |
9dd891bb | 98 | int write_file(int f,char *buf,size_t len) |
4c36ddbe AT |
99 | { |
100 | int ret = 0; | |
101 | ||
9b9c8aaf | 102 | while (len > 0) { |
9533e15a S |
103 | int r1; |
104 | if (sparse_files) { | |
105 | int len1 = MIN(len, SPARSE_WRITE_SIZE); | |
106 | r1 = write_sparse(f, buf, len1); | |
107 | } else { | |
76c21947 WD |
108 | if (!wf_writeBuf) { |
109 | wf_writeBufSize = MAX_MAP_SIZE; | |
110 | wf_writeBufCnt = 0; | |
111 | wf_writeBuf = new_array(char, MAX_MAP_SIZE); | |
9b9c8aaf WD |
112 | if (!wf_writeBuf) |
113 | out_of_memory("write_file"); | |
76c21947 WD |
114 | } |
115 | r1 = MIN(len, wf_writeBufSize - wf_writeBufCnt); | |
116 | if (r1) { | |
117 | memcpy(wf_writeBuf + wf_writeBufCnt, buf, r1); | |
118 | wf_writeBufCnt += r1; | |
119 | } | |
120 | if (wf_writeBufCnt == wf_writeBufSize) { | |
9b9c8aaf WD |
121 | if (flush_write_file(f) < 0) |
122 | return -1; | |
76c21947 WD |
123 | if (!r1 && len) |
124 | continue; | |
125 | } | |
9533e15a | 126 | } |
4c36ddbe AT |
127 | if (r1 <= 0) { |
128 | if (ret > 0) return ret; | |
129 | return r1; | |
130 | } | |
131 | len -= r1; | |
132 | buf += r1; | |
133 | ret += r1; | |
134 | } | |
135 | return ret; | |
136 | } | |
137 | ||
138 | ||
139 | ||
4440b8aa AT |
140 | /* this provides functionality somewhat similar to mmap() but using |
141 | read(). It gives sliding window access to a file. mmap() is not | |
142 | used because of the possibility of another program (such as a | |
143 | mailer) truncating the file thus giving us a SIGBUS */ | |
4c36ddbe AT |
144 | struct map_struct *map_file(int fd,OFF_T len) |
145 | { | |
4440b8aa | 146 | struct map_struct *map; |
58cadc86 | 147 | map = new(struct map_struct); |
4440b8aa AT |
148 | if (!map) out_of_memory("map_file"); |
149 | ||
150 | map->fd = fd; | |
151 | map->file_size = len; | |
152 | map->p = NULL; | |
153 | map->p_size = 0; | |
154 | map->p_offset = 0; | |
155 | map->p_fd_offset = 0; | |
156 | map->p_len = 0; | |
6a7cc46c | 157 | map->status = 0; |
4440b8aa AT |
158 | |
159 | return map; | |
4c36ddbe AT |
160 | } |
161 | ||
4440b8aa | 162 | /* slide the read window in the file */ |
4c36ddbe AT |
163 | char *map_ptr(struct map_struct *map,OFF_T offset,int len) |
164 | { | |
165 | int nread; | |
4440b8aa AT |
166 | OFF_T window_start, read_start; |
167 | int window_size, read_size, read_offset; | |
4c36ddbe | 168 | |
4440b8aa | 169 | if (len == 0) { |
4c36ddbe | 170 | return NULL; |
4440b8aa | 171 | } |
4c36ddbe | 172 | |
4440b8aa AT |
173 | /* can't go beyond the end of file */ |
174 | if (len > (map->file_size - offset)) { | |
175 | len = map->file_size - offset; | |
4c36ddbe | 176 | } |
4c36ddbe | 177 | |
4440b8aa | 178 | /* in most cases the region will already be available */ |
4c36ddbe AT |
179 | if (offset >= map->p_offset && |
180 | offset+len <= map->p_offset+map->p_len) { | |
181 | return (map->p + (offset - map->p_offset)); | |
182 | } | |
183 | ||
4c36ddbe | 184 | |
4440b8aa AT |
185 | /* nope, we are going to have to do a read. Work out our desired window */ |
186 | if (offset > 2*CHUNK_SIZE) { | |
187 | window_start = offset - 2*CHUNK_SIZE; | |
188 | window_start &= ~((OFF_T)(CHUNK_SIZE-1)); /* assumes power of 2 */ | |
189 | } else { | |
190 | window_start = 0; | |
191 | } | |
192 | window_size = MAX_MAP_SIZE; | |
193 | if (window_start + window_size > map->file_size) { | |
194 | window_size = map->file_size - window_start; | |
195 | } | |
196 | if (offset + len > window_start + window_size) { | |
197 | window_size = (offset+len) - window_start; | |
4c36ddbe AT |
198 | } |
199 | ||
4440b8aa AT |
200 | /* make sure we have allocated enough memory for the window */ |
201 | if (window_size > map->p_size) { | |
58cadc86 | 202 | map->p = realloc_array(map->p, char, window_size); |
4440b8aa AT |
203 | if (!map->p) out_of_memory("map_ptr"); |
204 | map->p_size = window_size; | |
205 | } | |
4c36ddbe | 206 | |
4440b8aa AT |
207 | /* now try to avoid re-reading any bytes by reusing any bytes from the previous |
208 | buffer. */ | |
209 | if (window_start >= map->p_offset && | |
210 | window_start < map->p_offset + map->p_len && | |
211 | window_start + window_size >= map->p_offset + map->p_len) { | |
212 | read_start = map->p_offset + map->p_len; | |
213 | read_offset = read_start - window_start; | |
214 | read_size = window_size - read_offset; | |
215 | memmove(map->p, map->p + (map->p_len - read_offset), read_offset); | |
216 | } else { | |
217 | read_start = window_start; | |
218 | read_size = window_size; | |
219 | read_offset = 0; | |
4c36ddbe AT |
220 | } |
221 | ||
4440b8aa AT |
222 | if (read_size <= 0) { |
223 | rprintf(FINFO,"Warning: unexpected read size of %d in map_ptr\n", read_size); | |
224 | } else { | |
225 | if (map->p_fd_offset != read_start) { | |
226 | if (do_lseek(map->fd,read_start,SEEK_SET) != read_start) { | |
227 | rprintf(FERROR,"lseek failed in map_ptr\n"); | |
228 | exit_cleanup(RERR_FILEIO); | |
229 | } | |
230 | map->p_fd_offset = read_start; | |
231 | } | |
232 | ||
233 | if ((nread=read(map->fd,map->p + read_offset,read_size)) != read_size) { | |
6a7cc46c S |
234 | if (nread < 0) { |
235 | nread = 0; | |
236 | if (!map->status) | |
237 | map->status = errno; | |
238 | } | |
4440b8aa AT |
239 | /* the best we can do is zero the buffer - the file |
240 | has changed mid transfer! */ | |
241 | memset(map->p+read_offset+nread, 0, read_size - nread); | |
242 | } | |
243 | map->p_fd_offset += nread; | |
4c36ddbe | 244 | } |
4440b8aa AT |
245 | |
246 | map->p_offset = window_start; | |
247 | map->p_len = window_size; | |
4c36ddbe | 248 | |
4440b8aa | 249 | return map->p + (offset - map->p_offset); |
4c36ddbe AT |
250 | } |
251 | ||
252 | ||
6a7cc46c | 253 | int unmap_file(struct map_struct *map) |
4c36ddbe | 254 | { |
6a7cc46c S |
255 | int ret; |
256 | ||
4c36ddbe AT |
257 | if (map->p) { |
258 | free(map->p); | |
259 | map->p = NULL; | |
260 | } | |
6a7cc46c | 261 | ret = map->status; |
4c36ddbe AT |
262 | memset(map, 0, sizeof(*map)); |
263 | free(map); | |
6a7cc46c S |
264 | |
265 | return ret; | |
4c36ddbe AT |
266 | } |
267 |