Added reminder to update rsync.yo manpage when adding to
[rsync/rsync.git] / fileio.c
CommitLineData
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
25static char last_byte;
26static int last_sparse;
27extern int sparse_files;
28
29int 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 40static 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
9533e15a
S
72/*
73 * write_file does not allow incomplete writes. It loops internally
74 * until len bytes are written or errno is set.
75 */
9dd891bb 76int write_file(int f,char *buf,size_t len)
4c36ddbe
AT
77{
78 int ret = 0;
79
4c36ddbe 80 while (len>0) {
9533e15a
S
81 int r1;
82 if (sparse_files) {
83 int len1 = MIN(len, SPARSE_WRITE_SIZE);
84 r1 = write_sparse(f, buf, len1);
85 } else {
86 r1 = write(f, buf, len);
87 }
4c36ddbe
AT
88 if (r1 <= 0) {
89 if (ret > 0) return ret;
90 return r1;
91 }
92 len -= r1;
93 buf += r1;
94 ret += r1;
95 }
96 return ret;
97}
98
99
100
4440b8aa
AT
101/* this provides functionality somewhat similar to mmap() but using
102 read(). It gives sliding window access to a file. mmap() is not
103 used because of the possibility of another program (such as a
104 mailer) truncating the file thus giving us a SIGBUS */
4c36ddbe
AT
105struct map_struct *map_file(int fd,OFF_T len)
106{
4440b8aa
AT
107 struct map_struct *map;
108 map = (struct map_struct *)malloc(sizeof(*map));
109 if (!map) out_of_memory("map_file");
110
111 map->fd = fd;
112 map->file_size = len;
113 map->p = NULL;
114 map->p_size = 0;
115 map->p_offset = 0;
116 map->p_fd_offset = 0;
117 map->p_len = 0;
6a7cc46c 118 map->status = 0;
4440b8aa
AT
119
120 return map;
4c36ddbe
AT
121}
122
4440b8aa 123/* slide the read window in the file */
4c36ddbe
AT
124char *map_ptr(struct map_struct *map,OFF_T offset,int len)
125{
126 int nread;
4440b8aa
AT
127 OFF_T window_start, read_start;
128 int window_size, read_size, read_offset;
4c36ddbe 129
4440b8aa 130 if (len == 0) {
4c36ddbe 131 return NULL;
4440b8aa 132 }
4c36ddbe 133
4440b8aa
AT
134 /* can't go beyond the end of file */
135 if (len > (map->file_size - offset)) {
136 len = map->file_size - offset;
4c36ddbe 137 }
4c36ddbe 138
4440b8aa 139 /* in most cases the region will already be available */
4c36ddbe
AT
140 if (offset >= map->p_offset &&
141 offset+len <= map->p_offset+map->p_len) {
142 return (map->p + (offset - map->p_offset));
143 }
144
4c36ddbe 145
4440b8aa
AT
146 /* nope, we are going to have to do a read. Work out our desired window */
147 if (offset > 2*CHUNK_SIZE) {
148 window_start = offset - 2*CHUNK_SIZE;
149 window_start &= ~((OFF_T)(CHUNK_SIZE-1)); /* assumes power of 2 */
150 } else {
151 window_start = 0;
152 }
153 window_size = MAX_MAP_SIZE;
154 if (window_start + window_size > map->file_size) {
155 window_size = map->file_size - window_start;
156 }
157 if (offset + len > window_start + window_size) {
158 window_size = (offset+len) - window_start;
4c36ddbe
AT
159 }
160
4440b8aa
AT
161 /* make sure we have allocated enough memory for the window */
162 if (window_size > map->p_size) {
163 map->p = (char *)Realloc(map->p, window_size);
164 if (!map->p) out_of_memory("map_ptr");
165 map->p_size = window_size;
166 }
4c36ddbe 167
4440b8aa
AT
168 /* now try to avoid re-reading any bytes by reusing any bytes from the previous
169 buffer. */
170 if (window_start >= map->p_offset &&
171 window_start < map->p_offset + map->p_len &&
172 window_start + window_size >= map->p_offset + map->p_len) {
173 read_start = map->p_offset + map->p_len;
174 read_offset = read_start - window_start;
175 read_size = window_size - read_offset;
176 memmove(map->p, map->p + (map->p_len - read_offset), read_offset);
177 } else {
178 read_start = window_start;
179 read_size = window_size;
180 read_offset = 0;
4c36ddbe
AT
181 }
182
4440b8aa
AT
183 if (read_size <= 0) {
184 rprintf(FINFO,"Warning: unexpected read size of %d in map_ptr\n", read_size);
185 } else {
186 if (map->p_fd_offset != read_start) {
187 if (do_lseek(map->fd,read_start,SEEK_SET) != read_start) {
188 rprintf(FERROR,"lseek failed in map_ptr\n");
189 exit_cleanup(RERR_FILEIO);
190 }
191 map->p_fd_offset = read_start;
192 }
193
194 if ((nread=read(map->fd,map->p + read_offset,read_size)) != read_size) {
6a7cc46c
S
195 if (nread < 0) {
196 nread = 0;
197 if (!map->status)
198 map->status = errno;
199 }
4440b8aa
AT
200 /* the best we can do is zero the buffer - the file
201 has changed mid transfer! */
202 memset(map->p+read_offset+nread, 0, read_size - nread);
203 }
204 map->p_fd_offset += nread;
4c36ddbe 205 }
4440b8aa
AT
206
207 map->p_offset = window_start;
208 map->p_len = window_size;
4c36ddbe 209
4440b8aa 210 return map->p + (offset - map->p_offset);
4c36ddbe
AT
211}
212
213
6a7cc46c 214int unmap_file(struct map_struct *map)
4c36ddbe 215{
6a7cc46c
S
216 int ret;
217
4c36ddbe
AT
218 if (map->p) {
219 free(map->p);
220 map->p = NULL;
221 }
6a7cc46c 222 ret = map->status;
4c36ddbe
AT
223 memset(map, 0, sizeof(*map));
224 free(map);
6a7cc46c
S
225
226 return ret;
4c36ddbe
AT
227}
228