2 Unix SMB/Netbios implementation.
4 sendfile implementations.
5 Copyright (C) Jeremy Allison 2002.
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 2 of the License, or
10 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 * This file handles the OS dependent sendfile implementations.
23 * The API is such that it returns -1 on error, else returns the
24 * number of bytes written.
29 #if defined(LINUX_SENDFILE_API)
31 #include <sys/sendfile.h>
34 #define MSG_MORE 0x8000
37 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
44 * Send the header first.
45 * Use MSG_MORE to cork the TCP output until sendfile is called.
49 hdr_len = header->length;
50 while (total < hdr_len) {
51 ret = sys_send(tofd, header->data + total,hdr_len - total, MSG_MORE);
62 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_SENDFILE64)
63 nwritten = sendfile64(tofd, fromfd, &offset, total);
65 nwritten = sendfile(tofd, fromfd, &offset, total);
67 } while (nwritten == -1 && errno == EINTR);
71 return -1; /* I think we're at EOF here... */
74 return count + hdr_len;
77 #elif defined(LINUX_BROKEN_SENDFILE_API)
80 * We must use explicit 32 bit types here. This code path means Linux
81 * won't do proper 64-bit sendfile. JRA.
84 extern int32 sendfile (int out_fd, int in_fd, int32 *offset, uint32 count);
88 #define MSG_MORE 0x8000
91 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
96 uint32 small_total = 0;
100 * Fix for broken Linux 2.4 systems with no working sendfile64().
101 * If the offset+count > 2 GB then pretend we don't have the
102 * system call sendfile at all. The upper layer catches this
103 * and uses a normal read. JRA.
106 if ((sizeof(SMB_OFF_T) >= 8) && (offset + count > (SMB_OFF_T)0x7FFFFFFF)) {
112 * Send the header first.
113 * Use MSG_MORE to cork the TCP output until sendfile is called.
117 hdr_len = header->length;
118 while (total < hdr_len) {
119 ret = sys_send(tofd, header->data + total,hdr_len - total, MSG_MORE);
126 small_total = (uint32)count;
127 small_offset = (int32)offset;
129 while (small_total) {
132 nwritten = sendfile(tofd, fromfd, &small_offset, small_total);
133 } while (nwritten == -1 && errno == EINTR);
137 return -1; /* I think we're at EOF here... */
138 small_total -= nwritten;
140 return count + hdr_len;
144 #elif defined(SOLARIS_SENDFILE_API)
147 * Solaris sendfile code written by Pierre Belanger <belanger@pobox.com>.
150 #include <sys/sendfile.h>
152 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
155 size_t total, xferred;
156 struct sendfilevec vec[2];
162 vec[0].sfv_fd = SFV_FD_SELF;
164 vec[0].sfv_off = header->data;
165 vec[0].sfv_len = hdr_len = header->length;
167 vec[1].sfv_fd = fromfd;
169 vec[1].sfv_off = offset;
170 vec[1].sfv_len = count;
175 vec[0].sfv_fd = fromfd;
177 vec[0].sfv_off = offset;
178 vec[0].sfv_len = count;
181 total = count + hdr_len;
187 * Although not listed in the API error returns, this is almost certainly
188 * a slow system call and will be interrupted by a signal with EINTR. JRA.
193 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_SENDFILEV64)
194 nwritten = sendfilev64(tofd, vec, sfvcnt, &xferred);
196 nwritten = sendfilev(tofd, vec, sfvcnt, &xferred);
198 if (nwritten == -1 && errno == EINTR) {
200 continue; /* Nothing written yet. */
208 return -1; /* I think we're at EOF here... */
211 * If this was a short (signal interrupted) write we may need
212 * to subtract it from the header data, or null out the header
213 * data altogether if we wrote more than vec[0].sfv_len bytes.
214 * We move vec[1].* to vec[0].* and set sfvcnt to 1
217 if (sfvcnt == 2 && nwritten >= vec[0].sfv_len) {
218 vec[1].sfv_off += nwritten - vec[0].sfv_len;
219 vec[1].sfv_len -= nwritten - vec[0].sfv_len;
221 /* Move vec[1].* to vec[0].* and set sfvcnt to 1 */
225 vec[0].sfv_off += nwritten;
226 vec[0].sfv_len -= nwritten;
230 return count + hdr_len;
233 #elif defined(HPUX_SENDFILE_API)
235 #include <sys/socket.h>
238 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
241 struct iovec hdtrl[2];
245 /* Set up the header/trailer iovec. */
246 hdtrl[0].iov_base = header->data;
247 hdtrl[0].iov_len = hdr_len = header->length;
249 hdtrl[0].iov_base = NULL;
250 hdtrl[0].iov_len = hdr_len = 0;
252 hdtrl[1].iov_base = NULL;
253 hdtrl[1].iov_base = 0;
256 while (total + hdtrl[0].iov_len) {
260 * HPUX guarantees that if any data was written before
261 * a signal interrupt then sendfile returns the number of
262 * bytes written (which may be less than requested) not -1.
263 * nwritten includes the header data sent.
267 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_SENDFILE64)
268 nwritten = sendfile64(tofd, fromfd, offset, total, &hdtrl[0], 0);
270 nwritten = sendfile(tofd, fromfd, offset, total, &hdtrl[0], 0);
272 } while (nwritten == -1 && errno == EINTR);
276 return -1; /* I think we're at EOF here... */
279 * If this was a short (signal interrupted) write we may need
280 * to subtract it from the header data, or null out the header
281 * data altogether if we wrote more than hdtrl[0].iov_len bytes.
282 * We change nwritten to be the number of file bytes written.
285 if (hdtrl[0].iov_base && hdtrl[0].iov_len) {
286 if (nwritten >= hdtrl[0].iov_len) {
287 nwritten -= hdtrl[0].iov_len;
288 hdtrl[0].iov_base = NULL;
289 hdtrl[0].iov_len = 0;
291 /* iov_base is defined as a void *... */
292 hdtrl[0].iov_base = ((char *)hdtrl[0].iov_base) + nwritten;
293 hdtrl[0].iov_len -= nwritten;
300 return count + hdr_len;
303 #elif defined(FREEBSD_SENDFILE_API)
305 #include <sys/types.h>
306 #include <sys/socket.h>
309 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
316 hdr.headers = &hdtrl;
321 /* Set up the header iovec. */
323 hdtrl.iov_base = header->data;
324 hdtrl.iov_len = hdr_len = header->length;
326 hdtrl.iov_base = NULL;
331 while (total + hdtrl.iov_len) {
336 * FreeBSD sendfile returns 0 on success, -1 on error.
337 * Remember, the tofd and fromfd are reversed..... :-).
338 * nwritten includes the header data sent.
342 ret = sendfile(fromfd, tofd, offset, total, &hdr, &nwritten, 0);
343 } while (ret == -1 && errno == EINTR);
348 return -1; /* I think we're at EOF here... */
351 * If this was a short (signal interrupted) write we may need
352 * to subtract it from the header data, or null out the header
353 * data altogether if we wrote more than hdtrl.iov_len bytes.
354 * We change nwritten to be the number of file bytes written.
357 if (hdtrl.iov_base && hdtrl.iov_len) {
358 if (nwritten >= hdtrl.iov_len) {
359 nwritten -= hdtrl.iov_len;
360 hdtrl.iov_base = NULL;
363 hdtrl.iov_base += nwritten;
364 hdtrl.iov_len -= nwritten;
371 return count + hdr_len;
374 #else /* No sendfile implementation. Return error. */
376 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
378 /* No sendfile syscall. */