![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to network_write_mmap.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_write_mmap.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src |
1.1 misho 1: #include "first.h"
2:
3: #include "network_backends.h"
4:
5: #include "network.h"
6: #include "log.h"
7: #include "sys-mmap.h"
8:
9: #include <setjmp.h>
10: #include <signal.h>
11: #include <unistd.h>
12:
13: #include <errno.h>
14: #include <string.h>
15:
16: #define MMAP_CHUNK_SIZE (512*1024)
17:
18: off_t mmap_align_offset(off_t start) {
19: static long pagesize = 0;
20: if (0 == pagesize) {
21: pagesize = sysconf(_SC_PAGESIZE);
22: force_assert(pagesize < MMAP_CHUNK_SIZE);
23: }
24: force_assert(start >= (start % pagesize));
25: return start - (start % pagesize);
26: }
27:
28: #if defined(USE_MMAP)
29:
30: static volatile int sigbus_jmp_valid;
31: static sigjmp_buf sigbus_jmp;
32:
33: static void sigbus_handler(int sig) {
34: UNUSED(sig);
35: if (sigbus_jmp_valid) siglongjmp(sigbus_jmp, 1);
36: log_failed_assert(__FILE__, __LINE__, "SIGBUS");
37: }
38:
39: #if 0
40: /* read mmap()ed data into local buffer */
41: #define LOCAL_BUFFERING 1
42: #endif
43:
44: int network_write_file_chunk_mmap(server *srv, connection *con, int fd, chunkqueue *cq, off_t *p_max_bytes) {
45: chunk* const c = cq->first;
46: off_t offset, toSend, file_end;
47: ssize_t r;
48: size_t mmap_offset, mmap_avail;
49: const char *data;
50:
51: force_assert(NULL != c);
52: force_assert(FILE_CHUNK == c->type);
53: force_assert(c->offset >= 0 && c->offset <= c->file.length);
54:
55: offset = c->file.start + c->offset;
56: toSend = c->file.length - c->offset;
57: if (toSend > *p_max_bytes) toSend = *p_max_bytes;
58: file_end = c->file.start + c->file.length; /* offset to file end in this chunk */
59:
60: if (0 == toSend) {
61: chunkqueue_remove_finished_chunks(cq);
62: return 0;
63: }
64:
65: if (0 != network_open_file_chunk(srv, con, cq)) return -1;
66:
67: /* setup SIGBUS handler, but don't activate sigbus_jmp_valid yet */
68: if (0 != sigsetjmp(sigbus_jmp, 1)) {
69: sigbus_jmp_valid = 0;
70:
71: log_error_write(srv, __FILE__, __LINE__, "sbd", "SIGBUS in mmap:",
72: c->file.name, c->file.fd);
73:
74: munmap(c->file.mmap.start, c->file.mmap.length);
75: c->file.mmap.start = MAP_FAILED;
76: #ifdef LOCAL_BUFFERING
77: buffer_reset(c->mem);
78: #endif
79:
80: return -1;
81: }
82:
83: signal(SIGBUS, sigbus_handler);
84:
85: /* mmap the buffer if offset is outside old mmap area or not mapped at all */
86: if (MAP_FAILED == c->file.mmap.start
87: || offset < c->file.mmap.offset
88: || offset >= (off_t)(c->file.mmap.offset + c->file.mmap.length)) {
89:
90: if (MAP_FAILED != c->file.mmap.start) {
91: munmap(c->file.mmap.start, c->file.mmap.length);
92: c->file.mmap.start = MAP_FAILED;
93: }
94:
95: /* Optimizations for the future:
96: *
97: * adaptive mem-mapping
98: * the problem:
99: * we mmap() the whole file. If someone has alot large files and 32bit
100: * machine the virtual address area will be unrun and we will have a failing
101: * mmap() call.
102: * solution:
103: * only mmap 16M in one chunk and move the window as soon as we have finished
104: * the first 8M
105: *
106: * read-ahead buffering
107: * the problem:
108: * sending out several large files in parallel trashes the read-ahead of the
109: * kernel leading to long wait-for-seek times.
110: * solutions: (increasing complexity)
111: * 1. use madvise
112: * 2. use a internal read-ahead buffer in the chunk-structure
113: * 3. use non-blocking IO for file-transfers
114: * */
115:
116: c->file.mmap.offset = mmap_align_offset(offset);
117:
118: /* all mmap()ed areas are MMAP_CHUNK_SIZE except the last which might be smaller */
119: c->file.mmap.length = MMAP_CHUNK_SIZE;
120: if (c->file.mmap.offset > file_end - (off_t)c->file.mmap.length) {
121: c->file.mmap.length = file_end - c->file.mmap.offset;
122: }
123:
124: if (MAP_FAILED == (c->file.mmap.start = mmap(NULL, c->file.mmap.length, PROT_READ, MAP_SHARED, c->file.fd, c->file.mmap.offset))) {
125: log_error_write(srv, __FILE__, __LINE__, "ssbdoo", "mmap failed:",
126: strerror(errno), c->file.name, c->file.fd, c->file.mmap.offset, (off_t) c->file.mmap.length);
127: return -1;
128: }
129:
130: #if defined(LOCAL_BUFFERING)
131: sigbus_jmp_valid = 1;
132: buffer_copy_string_len(c->mem, c->file.mmap.start, c->file.mmap.length);
133: sigbus_jmp_valid = 0;
134: #else
135: # if defined(HAVE_MADVISE)
136: /* don't advise files < 64Kb */
137: if (c->file.mmap.length > (64*1024)) {
138: /* darwin 7 is returning EINVAL all the time and I don't know how to
139: * detect this at runtime.
140: *
141: * ignore the return value for now */
142: madvise(c->file.mmap.start, c->file.mmap.length, MADV_WILLNEED);
143: }
144: # endif
145: #endif
146: }
147:
148: force_assert(offset >= c->file.mmap.offset);
149: mmap_offset = offset - c->file.mmap.offset;
150: force_assert(c->file.mmap.length > mmap_offset);
151: mmap_avail = c->file.mmap.length - mmap_offset;
152: if (toSend > (off_t) mmap_avail) toSend = mmap_avail;
153:
154: #if defined(LOCAL_BUFFERING)
155: data = c->mem->ptr + mmap_offset;
156: #else
157: data = c->file.mmap.start + mmap_offset;
158: #endif
159:
160: sigbus_jmp_valid = 1;
161: #if defined(__WIN32)
162: r = send(fd, data, toSend, 0);
163: #else /* __WIN32 */
164: r = write(fd, data, toSend);
165: #endif /* __WIN32 */
166: sigbus_jmp_valid = 0;
167:
168: #if defined(__WIN32)
169: if (r < 0) {
170: int lastError = WSAGetLastError();
171: switch (lastError) {
172: case WSAEINTR:
173: case WSAEWOULDBLOCK:
174: break;
175: case WSAECONNRESET:
176: case WSAETIMEDOUT:
177: case WSAECONNABORTED:
178: return -2;
179: default:
180: log_error_write(srv, __FILE__, __LINE__, "sdd",
181: "send failed: ", lastError, fd);
182: return -1;
183: }
184: }
185: #else /* __WIN32 */
186: if (r < 0) {
187: switch (errno) {
188: case EAGAIN:
189: case EINTR:
190: break;
191: case EPIPE:
192: case ECONNRESET:
193: return -2;
194: default:
195: log_error_write(srv, __FILE__, __LINE__, "ssd",
196: "write failed:", strerror(errno), fd);
197: return -1;
198: }
199: }
200: #endif /* __WIN32 */
201:
202: if (r >= 0) {
203: *p_max_bytes -= r;
204: chunkqueue_mark_written(cq, r);
205: }
206:
207: return (r > 0 && r == toSend) ? 0 : -3;
208: }
209:
210: #endif /* USE_MMAP */