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