![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to network_writev.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src|
Return to network_writev.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src |
1.1 misho 1: #include "network_backends.h"
2:
3: #ifdef USE_WRITEV
4:
5: #include "network.h"
6: #include "fdevent.h"
7: #include "log.h"
8: #include "stat_cache.h"
9:
10: #include <sys/types.h>
11: #include <sys/socket.h>
12: #include <sys/uio.h>
13: #include <sys/stat.h>
14: #include <sys/time.h>
15: #include <sys/resource.h>
16: #include <netinet/in.h>
17: #include <netinet/tcp.h>
18:
19: #include <errno.h>
20: #include <fcntl.h>
21: #include <unistd.h>
22: #include <netdb.h>
23: #include <string.h>
24: #include <stdlib.h>
25: #include <limits.h>
26: #include <stdio.h>
27: #include <assert.h>
28:
29: #if 0
30: #define LOCAL_BUFFERING 1
31: #endif
32:
33: #if defined(UIO_MAXIOV)
34: # define MAX_CHUNKS UIO_MAXIOV
35: #elif defined(IOV_MAX)
36: /* new name for UIO_MAXIOV since IEEE Std 1003.1-2001 */
37: # define MAX_CHUNKS IOV_MAX
38: #elif defined(_XOPEN_IOV_MAX)
39: /* minimum value for sysconf(_SC_IOV_MAX); posix requires this to be at least 16, which is good enough - no need to call sysconf() */
40: # define MAX_CHUNKS _XOPEN_IOV_MAX
41: #else
42: # error neither UIO_MAXIOV nor IOV_MAX nor _XOPEN_IOV_MAX are defined
43: #endif
44:
45: int network_write_chunkqueue_writev(server *srv, connection *con, int fd, chunkqueue *cq, off_t max_bytes) {
46: chunk *c;
47:
48: for(c = cq->first; (max_bytes > 0) && (NULL != c); c = c->next) {
49: int chunk_finished = 0;
50:
51: switch(c->type) {
52: case MEM_CHUNK: {
53: char * offset;
54: off_t toSend;
55: ssize_t r;
56:
57: size_t num_chunks, i;
58: struct iovec *chunks;
59: chunk *tc;
60: size_t num_bytes = 0;
61:
62: /* build writev list
63: *
64: * 1. limit: num_chunks < MAX_CHUNKS
65: * 2. limit: num_bytes < max_bytes
66: */
67: for (num_chunks = 0, tc = c; tc && tc->type == MEM_CHUNK && num_chunks < MAX_CHUNKS; num_chunks++, tc = tc->next);
68:
69: chunks = calloc(num_chunks, sizeof(*chunks));
70:
71: for(tc = c, i = 0; i < num_chunks; tc = tc->next, i++) {
72: if (tc->mem->used == 0) {
73: chunks[i].iov_base = tc->mem->ptr;
74: chunks[i].iov_len = 0;
75: } else {
76: offset = tc->mem->ptr + tc->offset;
77: toSend = tc->mem->used - 1 - tc->offset;
78:
79: chunks[i].iov_base = offset;
80:
81: /* protect the return value of writev() */
82: if (toSend > max_bytes ||
83: (off_t) num_bytes + toSend > max_bytes) {
84: chunks[i].iov_len = max_bytes - num_bytes;
85:
86: num_chunks = i + 1;
87: break;
88: } else {
89: chunks[i].iov_len = toSend;
90: }
91:
92: num_bytes += toSend;
93: }
94: }
95:
96: if ((r = writev(fd, chunks, num_chunks)) < 0) {
97: switch (errno) {
98: case EAGAIN:
99: case EINTR:
100: r = 0;
101: break;
102: case EPIPE:
103: case ECONNRESET:
104: free(chunks);
105: return -2;
106: default:
107: log_error_write(srv, __FILE__, __LINE__, "ssd",
108: "writev failed:", strerror(errno), fd);
109:
110: free(chunks);
111: return -1;
112: }
113: }
114:
115: cq->bytes_out += r;
116: max_bytes -= r;
117:
118: /* check which chunks have been written */
119:
120: for(i = 0, tc = c; i < num_chunks; i++, tc = tc->next) {
121: if (r >= (ssize_t)chunks[i].iov_len) {
122: /* written */
123: r -= chunks[i].iov_len;
124: tc->offset += chunks[i].iov_len;
125:
126: if (chunk_finished) {
127: /* skip the chunks from further touches */
128: c = c->next;
129: } else {
130: /* chunks_written + c = c->next is done in the for()*/
131: chunk_finished = 1;
132: }
133: } else {
134: /* partially written */
135:
136: tc->offset += r;
137: chunk_finished = 0;
138:
139: break;
140: }
141: }
142: free(chunks);
143:
144: break;
145: }
146: case FILE_CHUNK: {
147: ssize_t r;
148: off_t abs_offset;
149: off_t toSend;
150: stat_cache_entry *sce = NULL;
151:
152: #define KByte * 1024
153: #define MByte * 1024 KByte
154: #define GByte * 1024 MByte
155: const off_t we_want_to_mmap = 512 KByte;
156: char *start = NULL;
157:
158: if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) {
159: log_error_write(srv, __FILE__, __LINE__, "sb",
160: strerror(errno), c->file.name);
161: return -1;
162: }
163:
164: abs_offset = c->file.start + c->offset;
165:
166: if (abs_offset > sce->st.st_size) {
167: log_error_write(srv, __FILE__, __LINE__, "sb",
168: "file was shrinked:", c->file.name);
169:
170: return -1;
171: }
172:
173: /* mmap the buffer
174: * - first mmap
175: * - new mmap as the we are at the end of the last one */
176: if (c->file.mmap.start == MAP_FAILED ||
177: abs_offset == (off_t)(c->file.mmap.offset + c->file.mmap.length)) {
178:
179: /* Optimizations for the future:
180: *
181: * adaptive mem-mapping
182: * the problem:
183: * we mmap() the whole file. If someone has alot large files and 32bit
184: * machine the virtual address area will be unrun and we will have a failing
185: * mmap() call.
186: * solution:
187: * only mmap 16M in one chunk and move the window as soon as we have finished
188: * the first 8M
189: *
190: * read-ahead buffering
191: * the problem:
192: * sending out several large files in parallel trashes the read-ahead of the
193: * kernel leading to long wait-for-seek times.
194: * solutions: (increasing complexity)
195: * 1. use madvise
196: * 2. use a internal read-ahead buffer in the chunk-structure
197: * 3. use non-blocking IO for file-transfers
198: * */
199:
200: /* all mmap()ed areas are 512kb expect the last which might be smaller */
201: off_t we_want_to_send;
202: size_t to_mmap;
203:
204: /* this is a remap, move the mmap-offset */
205: if (c->file.mmap.start != MAP_FAILED) {
206: munmap(c->file.mmap.start, c->file.mmap.length);
207: c->file.mmap.offset += we_want_to_mmap;
208: } else {
209: /* in case the range-offset is after the first mmap()ed area we skip the area */
210: c->file.mmap.offset = 0;
211:
212: while (c->file.mmap.offset + we_want_to_mmap < c->file.start) {
213: c->file.mmap.offset += we_want_to_mmap;
214: }
215: }
216:
217: /* length is rel, c->offset too, assume there is no limit at the mmap-boundaries */
218: we_want_to_send = c->file.length - c->offset;
219: to_mmap = (c->file.start + c->file.length) - c->file.mmap.offset;
220:
221: /* we have more to send than we can mmap() at once */
222: if (abs_offset + we_want_to_send > c->file.mmap.offset + we_want_to_mmap) {
223: we_want_to_send = (c->file.mmap.offset + we_want_to_mmap) - abs_offset;
224: to_mmap = we_want_to_mmap;
225: }
226:
227: if (-1 == c->file.fd) { /* open the file if not already open */
228: if (-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY))) {
229: log_error_write(srv, __FILE__, __LINE__, "sbs", "open failed for:", c->file.name, strerror(errno));
230:
231: return -1;
232: }
233: #ifdef FD_CLOEXEC
234: fcntl(c->file.fd, F_SETFD, FD_CLOEXEC);
235: #endif
236: }
237:
238: if (MAP_FAILED == (c->file.mmap.start = mmap(NULL, to_mmap, PROT_READ, MAP_SHARED, c->file.fd, c->file.mmap.offset))) {
239: /* close it here, otherwise we'd have to set FD_CLOEXEC */
240:
241: log_error_write(srv, __FILE__, __LINE__, "ssbd", "mmap failed:",
242: strerror(errno), c->file.name, c->file.fd);
243:
244: return -1;
245: }
246:
247: c->file.mmap.length = to_mmap;
248: #ifdef LOCAL_BUFFERING
249: buffer_copy_string_len(c->mem, c->file.mmap.start, c->file.mmap.length);
250: #else
251: #ifdef HAVE_MADVISE
252: /* don't advise files < 64Kb */
253: if (c->file.mmap.length > (64 KByte)) {
254: /* darwin 7 is returning EINVAL all the time and I don't know how to
255: * detect this at runtime.i
256: *
257: * ignore the return value for now */
258: madvise(c->file.mmap.start, c->file.mmap.length, MADV_WILLNEED);
259: }
260: #endif
261: #endif
262:
263: /* chunk_reset() or chunk_free() will cleanup for us */
264: }
265:
266: /* to_send = abs_mmap_end - abs_offset */
267: toSend = (c->file.mmap.offset + c->file.mmap.length) - (abs_offset);
268:
269: if (toSend < 0) {
270: log_error_write(srv, __FILE__, __LINE__, "soooo",
271: "toSend is negative:",
272: toSend,
273: c->file.mmap.length,
274: abs_offset,
275: c->file.mmap.offset);
276: assert(toSend < 0);
277: }
278:
279: if (toSend > max_bytes) toSend = max_bytes;
280:
281: #ifdef LOCAL_BUFFERING
282: start = c->mem->ptr;
283: #else
284: start = c->file.mmap.start;
285: #endif
286:
287: if ((r = write(fd, start + (abs_offset - c->file.mmap.offset), toSend)) < 0) {
288: switch (errno) {
289: case EAGAIN:
290: case EINTR:
291: r = 0;
292: break;
293: case EPIPE:
294: case ECONNRESET:
295: return -2;
296: default:
297: log_error_write(srv, __FILE__, __LINE__, "ssd",
298: "write failed:", strerror(errno), fd);
299:
300: return -1;
301: }
302: }
303:
304: c->offset += r;
305: cq->bytes_out += r;
306: max_bytes -= r;
307:
308: if (c->offset == c->file.length) {
309: chunk_finished = 1;
310:
311: /* we don't need the mmaping anymore */
312: if (c->file.mmap.start != MAP_FAILED) {
313: munmap(c->file.mmap.start, c->file.mmap.length);
314: c->file.mmap.start = MAP_FAILED;
315: }
316: }
317:
318: break;
319: }
320: default:
321:
322: log_error_write(srv, __FILE__, __LINE__, "ds", c, "type not known");
323:
324: return -1;
325: }
326:
327: if (!chunk_finished) {
328: /* not finished yet */
329:
330: break;
331: }
332: }
333:
334: return 0;
335: }
336:
337: #endif