Mercurial > hg > nginx

comparison src/event/ngx_event_pipe.c @ 343:6bdf858bff8c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.3-2004-05-28-19:49:23 import; rename ngx_hunk_t to ngx_buf_t
author Igor Sysoev <igor@sysoev.ru>
date Fri, 28 May 2004 15:49:23 +0000
parents bcbe876f4262
children e366ba5db8f8
comparison
equal deleted inserted replaced
342:0ee0642af5f1 343:6bdf858bff8c
3 #include <ngx_core.h> 3 #include <ngx_core.h>
4 #include <ngx_event.h> 4 #include <ngx_event.h>
5 #include <ngx_event_pipe.h> 5 #include <ngx_event_pipe.h>
6 6
7 7
8 static int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p); 8 static ngx_int_t ngx_event_pipe_read_upstream(ngx_event_pipe_t *p);
9 static int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p); 9 static ngx_int_t ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p);
10 10
11 static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p); 11 static ngx_int_t ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p);
12 ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_hunk_t *hunk); 12 ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_buf_t *buf);
13 ngx_inline static void ngx_event_pipe_free_shadow_raw_hunk(ngx_chain_t **free, 13 ngx_inline static void ngx_event_pipe_free_shadow_raw_buf(ngx_chain_t **free,
14 ngx_hunk_t *h); 14 ngx_buf_t *buf);
15 ngx_inline static void ngx_event_pipe_add_free_hunk(ngx_chain_t **chain, 15 ngx_inline static void ngx_event_pipe_add_free_buf(ngx_chain_t **chain,
16 ngx_chain_t *cl); 16 ngx_chain_t *cl);
17 static int ngx_event_pipe_drain_chains(ngx_event_pipe_t *p); 17 static ngx_int_t ngx_event_pipe_drain_chains(ngx_event_pipe_t *p);
18 18
19 19
20 int ngx_event_pipe(ngx_event_pipe_t *p, int do_write) 20 ngx_int_t ngx_event_pipe(ngx_event_pipe_t *p, int do_write)
21 { 21 {
22 u_int flags; 22 u_int flags;
23 ngx_event_t *rev, *wev; 23 ngx_event_t *rev, *wev;
24 24
25 for ( ;; ) { 25 for ( ;; ) {
71 71
72 return NGX_OK; 72 return NGX_OK;
73 } 73 }
74 74
75 75
76 int ngx_event_pipe_read_upstream(ngx_event_pipe_t *p) 76 ngx_int_t ngx_event_pipe_read_upstream(ngx_event_pipe_t *p)
77 { 77 {
78 int n, rc, size; 78 int n, rc, size;
79 ngx_hunk_t *h; 79 ngx_buf_t *b;
80 ngx_chain_t *chain, *cl, *tl; 80 ngx_chain_t *chain, *cl, *tl;
81 81
82 if (p->upstream_eof || p->upstream_error || p->upstream_done) { 82 if (p->upstream_eof || p->upstream_error || p->upstream_done) {
83 return NGX_OK; 83 return NGX_OK;
84 } 84 }
90 90
91 if (p->upstream_eof || p->upstream_error || p->upstream_done) { 91 if (p->upstream_eof || p->upstream_error || p->upstream_done) {
92 break; 92 break;
93 } 93 }
94 94
95 if (p->preread_hunks == NULL && !p->upstream->read->ready) { 95 if (p->preread_bufs == NULL && !p->upstream->read->ready) {
96 break; 96 break;
97 } 97 }
98 98
99 if (p->preread_hunks) { 99 if (p->preread_bufs) {
100 100
101 /* use the pre-read hunks if they exist */ 101 /* use the pre-read bufs if they exist */
102 102
103 chain = p->preread_hunks; 103 chain = p->preread_bufs;
104 p->preread_hunks = NULL; 104 p->preread_bufs = NULL;
105 n = p->preread_size; 105 n = p->preread_size;
106 106
107 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, 107 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
108 "pipe preread: %d", n); 108 "pipe preread: %d", n);
109 109
113 113
114 } else { 114 } else {
115 115
116 /* 116 /*
117 * kqueue notifies about the end of file or a pending error. 117 * kqueue notifies about the end of file or a pending error.
118 * This test allows not to allocate a hunk on these conditions 118 * This test allows not to allocate a buf on these conditions
119 * and not to call ngx_recv_chain(). 119 * and not to call ngx_recv_chain().
120 */ 120 */
121 121
122 if (p->upstream->read->available == 0 122 if (p->upstream->read->available == 0
123 && (p->upstream->read->kq_eof || p->upstream->read->aio_eof)) 123 && (p->upstream->read->kq_eof || p->upstream->read->aio_eof))
140 #endif 140 #endif
141 141
142 break; 142 break;
143 } 143 }
144 144
145 if (p->free_raw_hunks) { 145 if (p->free_raw_bufs) {
146 146
147 /* use the free hunks if they exist */ 147 /* use the free bufs if they exist */
148 148
149 chain = p->free_raw_hunks; 149 chain = p->free_raw_bufs;
150 if (p->single_buf) { 150 if (p->single_buf) {
151 p->free_raw_hunks = p->free_raw_hunks->next; 151 p->free_raw_bufs = p->free_raw_bufs->next;
152 chain->next = NULL; 152 chain->next = NULL;
153 } else { 153 } else {
154 p->free_raw_hunks = NULL; 154 p->free_raw_bufs = NULL;
155 } 155 }
156 156
157 } else if (p->hunks < p->bufs.num) { 157 } else if (p->allocated < p->bufs.num) {
158 158
159 /* allocate a new hunk if it's still allowed */ 159 /* allocate a new buf if it's still allowed */
160 160
161 ngx_test_null(h, ngx_create_temp_hunk(p->pool, p->bufs.size), 161 if (!(b = ngx_create_temp_buf(p->pool, p->bufs.size))) {
162 NGX_ABORT); 162 return NGX_ABORT;
163 p->hunks++; 163 }
164 164
165 ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT); 165 p->allocated++;
166
167 ngx_alloc_link_and_set_buf(tl, b, p->pool, NGX_ABORT);
166 chain = tl; 168 chain = tl;
167 169
168 } else if (!p->cachable && p->downstream->write->ready) { 170 } else if (!p->cachable && p->downstream->write->ready) {
169 171
170 /* 172 /*
171 * if the hunks are not needed to be saved in a cache and 173 * if the bufs are not needed to be saved in a cache and
172 * a downstream is ready then write the hunks to a downstream 174 * a downstream is ready then write the bufs to a downstream
173 */ 175 */
174 176
175 p->upstream_blocked = 1; 177 p->upstream_blocked = 1;
176 178
177 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, 179 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
182 } else if (p->cachable 184 } else if (p->cachable
183 || p->temp_file->offset < p->max_temp_file_size) 185 || p->temp_file->offset < p->max_temp_file_size)
184 { 186 {
185 187
186 /* 188 /*
187 * if it's allowed then save some hunks from r->in 189 * if it's allowed then save some bufs from r->in
188 * to a temporary file, and add them to a r->out chain 190 * to a temporary file, and add them to a r->out chain
189 */ 191 */
190 192
191 rc = ngx_event_pipe_write_chain_to_temp_file(p); 193 rc = ngx_event_pipe_write_chain_to_temp_file(p);
192 194
208 210
209 if (rc != NGX_OK) { 211 if (rc != NGX_OK) {
210 return rc; 212 return rc;
211 } 213 }
212 214
213 chain = p->free_raw_hunks; 215 chain = p->free_raw_bufs;
214 if (p->single_buf) { 216 if (p->single_buf) {
215 p->free_raw_hunks = p->free_raw_hunks->next; 217 p->free_raw_bufs = p->free_raw_bufs->next;
216 chain->next = NULL; 218 chain->next = NULL;
217 } else { 219 } else {
218 p->free_raw_hunks = NULL; 220 p->free_raw_bufs = NULL;
219 } 221 }
220 222
221 } else { 223 } else {
222 224
223 /* if there're no hunks to read in then disable a level event */ 225 /* if there're no bufs to read in then disable a level event */
224 226
225 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, 227 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
226 "no pipe hunks to read in"); 228 "no pipe hunks to read in");
227 229
228 break; 230 break;
231 n = ngx_recv_chain(p->upstream, chain); 233 n = ngx_recv_chain(p->upstream, chain);
232 234
233 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, 235 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
234 "pipe recv chain: %d", n); 236 "pipe recv chain: %d", n);
235 237
236 if (p->free_raw_hunks) { 238 if (p->free_raw_bufs) {
237 chain->next = p->free_raw_hunks; 239 chain->next = p->free_raw_bufs;
238 } 240 }
239 p->free_raw_hunks = chain; 241 p->free_raw_bufs = chain;
240 242
241 if (n == NGX_ERROR) { 243 if (n == NGX_ERROR) {
242 p->upstream_error = 1; 244 p->upstream_error = 1;
243 return NGX_ERROR; 245 return NGX_ERROR;
244 } 246 }
245 247
246 if (n == NGX_AGAIN) { 248 if (n == NGX_AGAIN) {
247 if (p->single_buf) { 249 if (p->single_buf) {
248 ngx_event_pipe_remove_shadow_links(chain->hunk); 250 ngx_event_pipe_remove_shadow_links(chain->buf);
249 } 251 }
250 252
251 break; 253 break;
252 } 254 }
253 255
262 p->read_length += n; 264 p->read_length += n;
263 cl = chain; 265 cl = chain;
264 266
265 while (cl && n > 0) { 267 while (cl && n > 0) {
266 268
267 ngx_event_pipe_remove_shadow_links(cl->hunk); 269 ngx_event_pipe_remove_shadow_links(cl->buf);
268 270
269 size = cl->hunk->end - cl->hunk->last; 271 size = cl->buf->end - cl->buf->last;
270 272
271 if (n >= size) { 273 if (n >= size) {
272 cl->hunk->last = cl->hunk->end; 274 cl->buf->last = cl->buf->end;
273 275
274 /* STUB */ cl->hunk->num = p->num++; 276 /* STUB */ cl->buf->num = p->num++;
275 277
276 if (p->input_filter(p, cl->hunk) == NGX_ERROR) { 278 if (p->input_filter(p, cl->buf) == NGX_ERROR) {
277 return NGX_ABORT; 279 return NGX_ABORT;
278 } 280 }
279 281
280 n -= size; 282 n -= size;
281 cl = cl->next; 283 cl = cl->next;
282 284
283 } else { 285 } else {
284 cl->hunk->last += n; 286 cl->buf->last += n;
285 n = 0; 287 n = 0;
286 } 288 }
287 } 289 }
288 290
289 p->free_raw_hunks = cl; 291 p->free_raw_bufs = cl;
290 } 292 }
291 293
292 #if (NGX_DEBUG0) 294 #if (NGX_DEBUG)
293 295
294 if (p->in || p->busy || p->free_raw_hunks) { 296 if (p->in || p->busy || p->free_raw_bufs) {
295 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, "pipe buf"); 297 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, "pipe buf");
296 } 298 }
297 299
298 for (cl = p->in; cl; cl = cl->next) { 300 for (cl = p->in; cl; cl = cl->next) {
299 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0, 301 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
300 "pipe buf in " PTR_FMT ", pos " PTR_FMT ", size: %d", 302 "pipe buf in " PTR_FMT ", pos " PTR_FMT ", size: %d",
301 cl->hunk->start, cl->hunk->pos, 303 cl->buf->start, cl->buf->pos,
302 cl->hunk->last - cl->hunk->pos); 304 cl->buf->last - cl->buf->pos);
303 } 305 }
304 306
305 for (cl = p->busy; cl; cl = cl->next) { 307 for (cl = p->busy; cl; cl = cl->next) {
306 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0, 308 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
307 "pipe buf busy " PTR_FMT ", pos " PTR_FMT ", size: %d", 309 "pipe buf busy " PTR_FMT ", pos " PTR_FMT ", size: %d",
308 cl->hunk->start, cl->hunk->pos, 310 cl->buf->start, cl->buf->pos,
309 cl->hunk->last - cl->hunk->pos); 311 cl->buf->last - cl->buf->pos);
310 } 312 }
311 313
312 for (cl = p->free_raw_hunks; cl; cl = cl->next) { 314 for (cl = p->free_raw_bufs; cl; cl = cl->next) {
313 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0, 315 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
314 "pipe buf free " PTR_FMT ", last " PTR_FMT ", size: %d", 316 "pipe buf free " PTR_FMT ", last " PTR_FMT ", size: %d",
315 cl->hunk->start, cl->hunk->last, 317 cl->buf->start, cl->buf->last,
316 cl->hunk->end - cl->hunk->last); 318 cl->buf->end - cl->buf->last);
317 } 319 }
318 320
319 #endif 321 #endif
320 322
321 if ((p->upstream_eof || p->upstream_error) && p->free_raw_hunks) { 323 if ((p->upstream_eof || p->upstream_error) && p->free_raw_bufs) {
322 324
323 /* STUB */ p->free_raw_hunks->hunk->num = p->num++; 325 /* STUB */ p->free_raw_bufs->buf->num = p->num++;
324 326
325 if (p->input_filter(p, p->free_raw_hunks->hunk) == NGX_ERROR) { 327 if (p->input_filter(p, p->free_raw_bufs->buf) == NGX_ERROR) {
326 return NGX_ABORT; 328 return NGX_ABORT;
327 } 329 }
328 330
329 p->free_raw_hunks = p->free_raw_hunks->next; 331 p->free_raw_bufs = p->free_raw_bufs->next;
330 332
331 if (p->free_bufs) { 333 if (p->free_bufs) {
332 for (cl = p->free_raw_hunks; cl; cl = cl->next) { 334 for (cl = p->free_raw_bufs; cl; cl = cl->next) {
333 ngx_pfree(p->pool, cl->hunk->start); 335 ngx_pfree(p->pool, cl->buf->start);
334 } 336 }
335 } 337 }
336 } 338 }
337 339
338 if (p->cachable && p->in) { 340 if (p->cachable && p->in) {
343 345
344 return NGX_OK; 346 return NGX_OK;
345 } 347 }
346 348
347 349
348 int ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p) 350 ngx_int_t ngx_event_pipe_write_to_downstream(ngx_event_pipe_t *p)
349 { 351 {
350 size_t bsize; 352 size_t bsize;
351 ngx_uint_t flush; 353 ngx_uint_t flush;
352 ngx_hunk_t *h; 354 ngx_buf_t *b;
353 ngx_chain_t *out, **ll, *cl, *tl; 355 ngx_chain_t *out, **ll, *cl, *tl;
354 356
355 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, 357 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
356 "pipe write downstream: %d", p->downstream->write->ready); 358 "pipe write downstream: %d", p->downstream->write->ready);
357 359
389 } 391 }
390 392
391 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0, 393 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, p->log, 0,
392 "pipe write downstream done"); 394 "pipe write downstream done");
393 395
394 /* TODO: free unused hunks */ 396 /* TODO: free unused bufs */
395 397
396 p->downstream_done = 1; 398 p->downstream_done = 1;
397 break; 399 break;
398 } 400 }
399 401
400 if (!p->downstream->write->ready) { 402 if (!p->downstream->write->ready) {
401 break; 403 break;
402 } 404 }
403 405
404 /* bsize is the size of the busy hunks */ 406 /* bsize is the size of the busy bufs */
405 407
406 bsize = 0; 408 bsize = 0;
407 409
408 for (cl = p->busy; cl; cl = cl->next) { 410 for (cl = p->busy; cl; cl = cl->next) {
409 bsize += cl->hunk->end - cl->hunk->start; 411 bsize += cl->buf->end - cl->buf->start;
410 } 412 }
411 413
412 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, 414 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
413 "pipe write busy: " SIZE_T_FMT, bsize); 415 "pipe write busy: " SIZE_T_FMT, bsize);
414 416
418 420
419 for ( ;; ) { 421 for ( ;; ) {
420 if (p->out) { 422 if (p->out) {
421 cl = p->out; 423 cl = p->out;
422 424
423 if (bsize + ngx_hunk_size(cl->hunk) > p->busy_size) { 425 if (bsize + ngx_buf_size(cl->buf) > p->busy_size) {
424 flush = 1; 426 flush = 1;
425 break; 427 break;
426 } 428 }
427 429
428 p->out = p->out->next; 430 p->out = p->out->next;
429 ngx_event_pipe_free_shadow_raw_hunk(&p->free_raw_hunks, 431 ngx_event_pipe_free_shadow_raw_buf(&p->free_raw_bufs,
430 cl->hunk); 432 cl->buf);
431 433
432 } else if (!p->cachable && p->in) { 434 } else if (!p->cachable && p->in) {
433 cl = p->in; 435 cl = p->in;
434 436
435 if (bsize + ngx_hunk_size(cl->hunk) > p->busy_size) { 437 if (bsize + ngx_buf_size(cl->buf) > p->busy_size) {
436 flush = 1; 438 flush = 1;
437 break; 439 break;
438 } 440 }
439 441
440 p->in = p->in->next; 442 p->in = p->in->next;
441 443
442 } else { 444 } else {
443 break; 445 break;
444 } 446 }
445 447
446 bsize += ngx_hunk_size(cl->hunk); 448 bsize += ngx_buf_size(cl->buf);
447 cl->next = NULL; 449 cl->next = NULL;
448 ngx_chain_add_link(out, ll, cl); 450 ngx_chain_add_link(out, ll, cl);
449 } 451 }
450 452
451 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, p->log, 0, 453 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, p->log, 0,
462 464
463 ngx_chain_update_chains(&p->free, &p->busy, &out, p->tag); 465 ngx_chain_update_chains(&p->free, &p->busy, &out, p->tag);
464 466
465 for (cl = p->free; cl; cl = cl->next) { 467 for (cl = p->free; cl; cl = cl->next) {
466 468
467 if (cl->hunk->type & NGX_HUNK_TEMP_FILE) { 469 if (cl->buf->temp_file) {
468 if (p->cachable || !p->cyclic_temp_file) { 470 if (p->cachable || !p->cyclic_temp_file) {
469 continue; 471 continue;
470 } 472 }
471 473
472 /* reset p->temp_offset if all hunks had been sent */ 474 /* reset p->temp_offset if all bufs had been sent */
473 475
474 if (cl->hunk->file_last == p->temp_file->offset) { 476 if (cl->buf->file_last == p->temp_file->offset) {
475 p->temp_file->offset = 0; 477 p->temp_file->offset = 0;
476 } 478 }
477 } 479 }
478 480
479 /* TODO: free hunk if p->free_bufs && upstream done */ 481 /* TODO: free buf if p->free_bufs && upstream done */
480 482
481 /* add the free shadow raw hunk to p->free_raw_hunks */ 483 /* add the free shadow raw buf to p->free_raw_bufs */
482 484
483 if (cl->hunk->type & NGX_HUNK_LAST_SHADOW) { 485 if (cl->buf->last_shadow) {
484 h = cl->hunk->shadow; 486 b = cl->buf->shadow;
485 h->pos = h->last = h->start; 487 b->pos = b->last = b->start;
486 h->shadow = NULL; 488 b->shadow = NULL;
487 ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT); 489 ngx_alloc_link_and_set_buf(tl, b, p->pool, NGX_ABORT);
488 ngx_event_pipe_add_free_hunk(&p->free_raw_hunks, tl); 490 ngx_event_pipe_add_free_buf(&p->free_raw_bufs, tl);
489 491
490 cl->hunk->type &= ~NGX_HUNK_LAST_SHADOW; 492 cl->buf->last_shadow = 0;
491 } 493 }
492 cl->hunk->shadow = NULL; 494
493 495 cl->buf->shadow = NULL;
494 #if 0
495 if (p->cyclic_temp_file && (cl->hunk->type & NGX_HUNK_TEMP_FILE)) {
496
497 /* reset p->temp_offset if all hunks had been sent */
498
499 if (cl->hunk->file_last == p->temp_file->offset) {
500 p->temp_file->offset = 0;
501 }
502 }
503 #endif
504 } 496 }
505 } 497 }
506 498
507 return NGX_OK; 499 return NGX_OK;
508 } 500 }
509 501
510 502
511 static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p) 503 static ngx_int_t ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
512 { 504 {
513 int size, hsize; 505 size_t size, bsize;
514 ngx_hunk_t *h; 506 ngx_buf_t *b;
515 ngx_chain_t *cl, *tl, *next, *out, **ll, **last_free, fl; 507 ngx_chain_t *cl, *tl, *next, *out, **ll, **last_free, fl;
516 508
517 if (p->hunk_to_file) { 509 if (p->buf_to_file) {
518 fl.hunk = p->hunk_to_file; 510 fl.buf = p->buf_to_file;
519 fl.next = p->in; 511 fl.next = p->in;
520 out = &fl; 512 out = &fl;
521 513
522 } else { 514 } else {
523 out = p->in; 515 out = p->in;
531 523
532 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, 524 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0,
533 "pipe offset: %d", p->temp_file->offset); 525 "pipe offset: %d", p->temp_file->offset);
534 526
535 do { 527 do {
536 hsize = cl->hunk->last - cl->hunk->pos; 528 bsize = cl->buf->last - cl->buf->pos;
537 529
538 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0, 530 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, p->log, 0,
539 "pipe buf " PTR_FMT ", pos " PTR_FMT ", size: %d", 531 "pipe buf " PTR_FMT ", pos " PTR_FMT ", size: %d",
540 cl->hunk->start, cl->hunk->pos, hsize); 532 cl->buf->start, cl->buf->pos, bsize);
541 533
542 if ((size + hsize > p->temp_file_write_size) 534 if ((size + bsize > p->temp_file_write_size)
543 || (p->temp_file->offset + size + hsize > p->max_temp_file_size)) 535 || (p->temp_file->offset + size + bsize > p->max_temp_file_size))
544 { 536 {
545 break; 537 break;
546 } 538 }
547 539
548 size += hsize; 540 size += bsize;
549 ll = &cl->next; 541 ll = &cl->next;
550 cl = cl->next; 542 cl = cl->next;
551 543
552 } while (cl); 544 } while (cl);
553 545
569 561
570 if (ngx_write_chain_to_temp_file(p->temp_file, out) == NGX_ERROR) { 562 if (ngx_write_chain_to_temp_file(p->temp_file, out) == NGX_ERROR) {
571 return NGX_ABORT; 563 return NGX_ABORT;
572 } 564 }
573 565
574 for (last_free = &p->free_raw_hunks; 566 for (last_free = &p->free_raw_bufs;
575 *last_free != NULL; 567 *last_free != NULL;
576 last_free = &(*last_free)->next) 568 last_free = &(*last_free)->next)
577 { 569 {
578 /* void */ 570 /* void */
579 } 571 }
580 572
581 if (p->hunk_to_file) { 573 if (p->buf_to_file) {
582 p->temp_file->offset = p->hunk_to_file->last - p->hunk_to_file->pos; 574 p->temp_file->offset = p->buf_to_file->last - p->buf_to_file->pos;
583 p->hunk_to_file = NULL; 575 p->buf_to_file = NULL;
584 out = out->next; 576 out = out->next;
585 } 577 }
586 578
587 for (cl = out; cl; cl = next) { 579 for (cl = out; cl; cl = next) {
588 next = cl->next; 580 next = cl->next;
589 cl->next = NULL; 581 cl->next = NULL;
590 582
591 h = cl->hunk; 583 b = cl->buf;
592 h->file = &p->temp_file->file; 584 b->file = &p->temp_file->file;
593 h->file_pos = p->temp_file->offset; 585 b->file_pos = p->temp_file->offset;
594 p->temp_file->offset += h->last - h->pos; 586 p->temp_file->offset += b->last - b->pos;
595 h->file_last = p->temp_file->offset; 587 b->file_last = p->temp_file->offset;
596 588
597 h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE; 589 b->in_file = 1;
598 590 b->temp_file = 1;
599 #if 0
600 if (p->cachable) {
601 h->type |= NGX_HUNK_FILE;
602 } else {
603 h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE;
604 }
605 #endif
606 591
607 ngx_chain_add_link(p->out, p->last_out, cl); 592 ngx_chain_add_link(p->out, p->last_out, cl);
608 593
609 if (h->type & NGX_HUNK_LAST_SHADOW) { 594 if (b->last_shadow) {
610 h->shadow->last = h->shadow->pos = h->shadow->start; 595 b->shadow->last = b->shadow->pos = b->shadow->start;
611 ngx_alloc_link_and_set_hunk(tl, h->shadow, p->pool, NGX_ABORT); 596 ngx_alloc_link_and_set_buf(tl, b->shadow, p->pool, NGX_ABORT);
612 *last_free = tl; 597 *last_free = tl;
613 last_free = &tl->next; 598 last_free = &tl->next;
614 } 599 }
615 } 600 }
616 601
618 } 603 }
619 604
620 605
621 /* the copy input filter */ 606 /* the copy input filter */
622 607
623 int ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_hunk_t *hunk) 608 ngx_int_t ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf)
624 { 609 {
625 ngx_hunk_t *h; 610 ngx_buf_t *b;
626 ngx_chain_t *cl; 611 ngx_chain_t *cl;
627 612
628 if (hunk->pos == hunk->last) { 613 if (buf->pos == buf->last) {
629 return NGX_OK; 614 return NGX_OK;
630 } 615 }
631 616
632 if (p->free) { 617 if (p->free) {
633 h = p->free->hunk; 618 b = p->free->buf;
634 p->free = p->free->next; 619 p->free = p->free->next;
635 620
636 } else { 621 } else {
637 ngx_test_null(h, ngx_alloc_hunk(p->pool), NGX_ERROR); 622 if (!(b = ngx_alloc_buf(p->pool))) {
638 } 623 return NGX_ERROR;
639 624 }
640 ngx_memcpy(h, hunk, sizeof(ngx_hunk_t)); 625 }
641 h->shadow = hunk; 626
642 h->tag = p->tag; 627 ngx_memcpy(b, buf, sizeof(ngx_buf_t));
643 h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED; 628 b->shadow = buf;
644 hunk->shadow = h; 629 b->tag = p->tag;
645 630 b->last_shadow = 1;
646 ngx_alloc_link_and_set_hunk(cl, h, p->pool, NGX_ERROR); 631 b->recycled = 1;
647 632 buf->shadow = b;
648 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, "hunk #%d", h->num); 633
634 ngx_alloc_link_and_set_buf(cl, b, p->pool, NGX_ERROR);
635
636 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, "buf #%d", b->num);
649 637
650 ngx_chain_add_link(p->in, p->last_in, cl); 638 ngx_chain_add_link(p->in, p->last_in, cl);
651 639
652 return NGX_OK; 640 return NGX_OK;
653 } 641 }
654 642
655 643
656 ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_hunk_t *hunk) 644 ngx_inline static void ngx_event_pipe_remove_shadow_links(ngx_buf_t *buf)
657 { 645 {
658 ngx_hunk_t *h, *next; 646 ngx_buf_t *b, *next;
659 647
660 if (hunk->shadow == NULL) { 648 if (buf->shadow == NULL) {
661 return; 649 return;
662 } 650 }
663 651
664 h = hunk->shadow; 652 b = buf->shadow;
665 653
666 while (!(h->type & NGX_HUNK_LAST_SHADOW)) { 654 while (!b->last_shadow) {
667 next = h->shadow; 655 next = b->shadow;
668 h->type &= ~(NGX_HUNK_TEMP|NGX_HUNK_IN_MEMORY|NGX_HUNK_RECYCLED); 656 #if 0
669 h->shadow = NULL; 657 b->type &= ~(NGX_HUNK_TEMP|NGX_HUNK_IN_MEMORY|NGX_HUNK_RECYCLED);
670 h = next; 658 #endif
671 } 659 b->temporary = 0;
672 660 b->recycled = 0;
673 h->type &= ~(NGX_HUNK_TEMP 661 b->shadow = NULL;
662 b = next;
663 }
664
665 #if 0
666 b->type &= ~(NGX_HUNK_TEMP
674 |NGX_HUNK_IN_MEMORY 667 |NGX_HUNK_IN_MEMORY
675 |NGX_HUNK_RECYCLED 668 |NGX_HUNK_RECYCLED
676 |NGX_HUNK_LAST_SHADOW); 669 |NGX_HUNK_LAST_SHADOW);
677 h->shadow = NULL; 670 #endif
678 671
679 hunk->shadow = NULL; 672 b->temporary = 0;
680 } 673 b->recycled = 0;
681 674 b->last_shadow = 0;
682 675
683 ngx_inline static void ngx_event_pipe_free_shadow_raw_hunk(ngx_chain_t **free, 676 b->shadow = NULL;
684 ngx_hunk_t *h) 677
685 { 678 buf->shadow = NULL;
686 ngx_hunk_t *s; 679 }
680
681
682 ngx_inline static void ngx_event_pipe_free_shadow_raw_buf(ngx_chain_t **free,
683 ngx_buf_t *buf)
684 {
685 ngx_buf_t *s;
687 ngx_chain_t *cl, **ll; 686 ngx_chain_t *cl, **ll;
688 687
689 if (h->shadow == NULL) { 688 if (buf->shadow == NULL) {
690 return; 689 return;
691 } 690 }
692 691
693 for (s = h->shadow; !(s->type & NGX_HUNK_LAST_SHADOW); s = s->shadow) { 692 for (s = buf->shadow; !s->last_shadow; s = s->shadow) { /* void */ }
694 /* void */
695 }
696 693
697 ll = free; 694 ll = free;
698 695
699 for (cl = *free ; cl; cl = cl->next) { 696 for (cl = *free ; cl; cl = cl->next) {
700 if (cl->hunk == s) { 697 if (cl->buf == s) {
701 *ll = cl->next; 698 *ll = cl->next;
702 break; 699 break;
703 } 700 }
704 701
705 if (cl->hunk->shadow) { 702 if (cl->buf->shadow) {
706 break; 703 break;
707 } 704 }
708 705
709 ll = &cl->next; 706 ll = &cl->next;
710 } 707 }
711 } 708 }
712 709
713 710
714 ngx_inline static void ngx_event_pipe_add_free_hunk(ngx_chain_t **chain, 711 ngx_inline static void ngx_event_pipe_add_free_buf(ngx_chain_t **chain,
715 ngx_chain_t *cl) 712 ngx_chain_t *cl)
716 { 713 {
717 if (*chain == NULL) { 714 if (*chain == NULL) {
718 *chain = cl; 715 *chain = cl;
719 return; 716 return;
720 } 717 }
721 718
722 if ((*chain)->hunk->pos != (*chain)->hunk->last) { 719 if ((*chain)->buf->pos != (*chain)->buf->last) {
723 cl->next = (*chain)->next; 720 cl->next = (*chain)->next;
724 (*chain)->next = cl; 721 (*chain)->next = cl;
725 722
726 } else { 723 } else {
727 cl->next = (*chain); 724 cl->next = (*chain);
728 (*chain) = cl; 725 (*chain) = cl;
729 } 726 }
730 } 727 }
731 728
732 729
733 static int ngx_event_pipe_drain_chains(ngx_event_pipe_t *p) 730 static ngx_int_t ngx_event_pipe_drain_chains(ngx_event_pipe_t *p)
734 { 731 {
735 ngx_hunk_t *h; 732 ngx_buf_t *b;
736 ngx_chain_t *cl, *tl; 733 ngx_chain_t *cl, *tl;
737 734
738 for ( ;; ) { 735 for ( ;; ) {
739 if (p->busy) { 736 if (p->busy) {
740 cl = p->busy; 737 cl = p->busy;
751 } else { 748 } else {
752 return NGX_OK; 749 return NGX_OK;
753 } 750 }
754 751
755 while (cl) { 752 while (cl) {
756 if (cl->hunk->type & NGX_HUNK_LAST_SHADOW) { 753 if (cl->buf->last_shadow) {
757 h = cl->hunk->shadow; 754 b = cl->buf->shadow;
758 h->pos = h->last = h->start; 755 b->pos = b->last = b->start;
759 h->shadow = NULL; 756 b->shadow = NULL;
760 ngx_alloc_link_and_set_hunk(tl, h, p->pool, NGX_ABORT); 757 ngx_alloc_link_and_set_buf(tl, b, p->pool, NGX_ABORT);
761 ngx_event_pipe_add_free_hunk(&p->free_raw_hunks, tl); 758 ngx_event_pipe_add_free_buf(&p->free_raw_bufs, tl);
762 759
763 cl->hunk->type &= ~NGX_HUNK_LAST_SHADOW; 760 cl->buf->last_shadow = 0;
764 } 761 }
765 762
766 cl->hunk->shadow = NULL; 763 cl->buf->shadow = NULL;
767 tl = cl->next; 764 tl = cl->next;
768 cl->next = p->free; 765 cl->next = p->free;
769 p->free = cl; 766 p->free = cl;
770 cl = tl; 767 cl = tl;
771 } 768 }