Mercurial > hg > nginx-vendor-0-5
comparison src/os/unix/ngx_solaris_sendfilev_chain.c @ 22:8b6db3bda591 NGINX_0_1_11
nginx 0.1.11
*) Feature: the worker_priority directive.
*) Change: both tcp_nopush and tcp_nodelay directives affect the
transferred response.
*) Bugfix: nginx did not call initgroups().
Thanks to Andrew Sitnikov and Andrei Nigmatulin.
*) Change: now the ngx_http_autoindex_module shows the file size in the
bytes.
*) Bugfix: the ngx_http_autoindex_module returned the 500 error if the
broken symlink was in a directory.
*) Bugfix: the files bigger than 4G could not be transferred using
sendfile.
*) Bugfix: if the backend was resolved to several backends and there
was an error while the response waiting then process may got caught
in an endless loop.
*) Bugfix: the worker process may exit with the "unknown cycle" message
when the /dev/poll method was used.
*) Bugfix: "close() channel failed" errors.
*) Bugfix: the autodetection of the "nobody" and "nogroup" groups.
*) Bugfix: the send_lowat directive did not work on Linux.
*) Bugfix: the segmentation fault occurred if there was no events
section in configuration.
*) Bugfix: nginx could not be built on OpenBSD.
*) Bugfix: the double slashes in "://" in the URI were converted to
":/".
author | Igor Sysoev <http://sysoev.ru> |
---|---|
date | Thu, 02 Dec 2004 00:00:00 +0300 |
parents | 46833bd150cb |
children | 45fe5b98a9de |
comparison
equal
deleted
inserted
replaced
21:4eeb9cfef970 | 22:8b6db3bda591 |
---|---|
5 | 5 |
6 | 6 |
7 #include <ngx_config.h> | 7 #include <ngx_config.h> |
8 #include <ngx_core.h> | 8 #include <ngx_core.h> |
9 #include <ngx_event.h> | 9 #include <ngx_event.h> |
10 | |
11 | |
12 #if (NGX_TEST_BUILD_SOLARIS_SENDFILEV) | |
13 | |
14 /* Solaris declarations */ | |
15 | |
16 typedef struct sendfilevec { | |
17 int sfv_fd; | |
18 u_int sfv_flag; | |
19 off_t sfv_off; | |
20 size_t sfv_len; | |
21 } sendfilevec_t; | |
22 | |
23 #define SFV_FD_SELF -2 | |
24 | |
25 static ssize_t sendfilev(int fd, const struct sendfilevec *vec, | |
26 int sfvcnt, size_t *xferred) | |
27 { | |
28 return -1; | |
29 } | |
30 | |
31 #endif | |
10 | 32 |
11 | 33 |
12 #define NGX_SENDFILEVECS 16 | 34 #define NGX_SENDFILEVECS 16 |
13 | 35 |
14 | 36 |
15 ngx_chain_t *ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in, | 37 ngx_chain_t *ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in, |
16 off_t limit) | 38 off_t limit) |
17 { | 39 { |
18 int fd; | 40 int fd; |
19 u_char *prev; | 41 u_char *prev; |
20 off_t fprev, sprev, send, aligned; | 42 off_t size, send, prev_send, aligned, fprev; |
21 ssize_t size, sent, n; | 43 size_t sent; |
44 ssize_t n; | |
22 ngx_int_t eintr, complete; | 45 ngx_int_t eintr, complete; |
23 ngx_err_t err; | 46 ngx_err_t err; |
24 sendfilevec_t *sfv, sfvs[NGX_SENDFILEVECS]; | 47 sendfilevec_t *sfv, sfvs[NGX_SENDFILEVECS]; |
25 ngx_array_t vec; | 48 ngx_array_t vec; |
26 ngx_event_t *wev; | 49 ngx_event_t *wev; |
33 } | 56 } |
34 | 57 |
35 if (!c->sendfile) { | 58 if (!c->sendfile) { |
36 return ngx_writev_chain(c, in, limit); | 59 return ngx_writev_chain(c, in, limit); |
37 } | 60 } |
61 | |
62 | |
63 /* the maximum limit size is the maximum size_t value - the page size */ | |
64 | |
65 if (limit == 0 || limit > MAX_SIZE_T_VALUE - ngx_pagesize) { | |
66 limit = MAX_SIZE_T_VALUE - ngx_pagesize; | |
67 } | |
68 | |
38 | 69 |
39 send = 0; | 70 send = 0; |
40 complete = 0; | 71 complete = 0; |
41 | 72 |
42 vec.elts = sfvs; | 73 vec.elts = sfvs; |
49 prev = NULL; | 80 prev = NULL; |
50 fprev = 0; | 81 fprev = 0; |
51 sfv = NULL; | 82 sfv = NULL; |
52 eintr = 0; | 83 eintr = 0; |
53 sent = 0; | 84 sent = 0; |
54 sprev = send; | 85 prev_send = send; |
55 | 86 |
56 vec.nelts = 0; | 87 vec.nelts = 0; |
57 | 88 |
58 /* create the sendfilevec and coalesce the neighbouring bufs */ | 89 /* create the sendfilevec and coalesce the neighbouring bufs */ |
59 | 90 |
71 if (send + size > limit) { | 102 if (send + size > limit) { |
72 size = limit - send; | 103 size = limit - send; |
73 } | 104 } |
74 | 105 |
75 if (prev == cl->buf->pos) { | 106 if (prev == cl->buf->pos) { |
76 sfv->sfv_len += size; | 107 sfv->sfv_len += (size_t) size; |
77 | 108 |
78 } else { | 109 } else { |
79 if (!(sfv = ngx_array_push(&vec))) { | 110 if (!(sfv = ngx_array_push(&vec))) { |
80 return NGX_CHAIN_ERROR; | 111 return NGX_CHAIN_ERROR; |
81 } | 112 } |
82 | 113 |
83 sfv->sfv_fd = SFV_FD_SELF; | 114 sfv->sfv_fd = SFV_FD_SELF; |
84 sfv->sfv_flag = 0; | 115 sfv->sfv_flag = 0; |
85 sfv->sfv_off = (off_t) (uintptr_t) cl->buf->pos; | 116 sfv->sfv_off = (off_t) (uintptr_t) cl->buf->pos; |
86 sfv->sfv_len = size; | 117 sfv->sfv_len = (size_t) size; |
87 } | 118 } |
88 | 119 |
89 prev = cl->buf->pos + size; | 120 prev = cl->buf->pos + (size_t) size; |
90 send += size; | 121 send += size; |
91 | 122 |
92 } else { | 123 } else { |
93 prev = NULL; | 124 prev = NULL; |
94 | 125 |
95 size = (size_t) (cl->buf->file_last - cl->buf->file_pos); | 126 size = cl->buf->file_last - cl->buf->file_pos; |
96 | 127 |
97 if (send + size > limit) { | 128 if (send + size > limit) { |
98 size = limit - send; | 129 size = limit - send; |
99 | 130 |
100 aligned = (cl->buf->file_pos + size + ngx_pagesize - 1) | 131 aligned = (cl->buf->file_pos + size + ngx_pagesize - 1) |
104 size = aligned - cl->buf->file_pos; | 135 size = aligned - cl->buf->file_pos; |
105 } | 136 } |
106 } | 137 } |
107 | 138 |
108 if (fd == cl->buf->file->fd && fprev == cl->buf->file_pos) { | 139 if (fd == cl->buf->file->fd && fprev == cl->buf->file_pos) { |
109 sfv->sfv_len += size; | 140 sfv->sfv_len += (size_t) size; |
110 | 141 |
111 } else { | 142 } else { |
112 if (!(sfv = ngx_array_push(&vec))) { | 143 if (!(sfv = ngx_array_push(&vec))) { |
113 return NGX_CHAIN_ERROR; | 144 return NGX_CHAIN_ERROR; |
114 } | 145 } |
115 | 146 |
116 fd = cl->buf->file->fd; | 147 fd = cl->buf->file->fd; |
117 sfv->sfv_fd = fd; | 148 sfv->sfv_fd = fd; |
118 sfv->sfv_flag = 0; | 149 sfv->sfv_flag = 0; |
119 sfv->sfv_off = cl->buf->file_pos; | 150 sfv->sfv_off = cl->buf->file_pos; |
120 sfv->sfv_len = size; | 151 sfv->sfv_len = (size_t) size; |
121 } | 152 } |
122 | 153 |
123 fprev = cl->buf->file_pos + size; | 154 fprev = cl->buf->file_pos + size; |
124 send += size; | 155 send += size; |
125 } | 156 } |
134 if (err == NGX_EINTR) { | 165 if (err == NGX_EINTR) { |
135 eintr = 1; | 166 eintr = 1; |
136 } | 167 } |
137 | 168 |
138 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err, | 169 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err, |
139 "sendfilev() sent only %z bytes", sent); | 170 "sendfilev() sent only %uz bytes", sent); |
140 | 171 |
141 } else { | 172 } else { |
142 wev->error = 1; | 173 wev->error = 1; |
143 ngx_connection_error(c, err, "sendfilev() failed"); | 174 ngx_connection_error(c, err, "sendfilev() failed"); |
144 return NGX_CHAIN_ERROR; | 175 return NGX_CHAIN_ERROR; |
146 } | 177 } |
147 | 178 |
148 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, | 179 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0, |
149 "sendfilev: %z %z", n, sent); | 180 "sendfilev: %z %z", n, sent); |
150 | 181 |
151 if (send - sprev == sent) { | 182 if (send - prev_send == (off_t) sent) { |
152 complete = 1; | 183 complete = 1; |
153 } | 184 } |
154 | 185 |
155 c->sent += sent; | 186 c->sent += sent; |
156 | 187 |
164 break; | 195 break; |
165 } | 196 } |
166 | 197 |
167 size = ngx_buf_size(cl->buf); | 198 size = ngx_buf_size(cl->buf); |
168 | 199 |
169 if (sent >= size) { | 200 if ((off_t) sent >= size) { |
170 sent -= size; | 201 sent = (size_t) ((off_t) sent - size); |
171 | 202 |
172 if (ngx_buf_in_memory(cl->buf)) { | 203 if (ngx_buf_in_memory(cl->buf)) { |
173 cl->buf->pos = cl->buf->last; | 204 cl->buf->pos = cl->buf->last; |
174 } | 205 } |
175 | 206 |