Mercurial > hg > nginx

comparison src/event/ngx_event_pipe.c @ 154:eac26585476e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.1-2003-10-22-11:05:29 import
author Igor Sysoev <igor@sysoev.ru>
date Wed, 22 Oct 2003 07:05:29 +0000
parents c71aeb75c071
children 46eb23d9471d
comparison
equal deleted inserted replaced
153:c71aeb75c071 154:eac26585476e
25 return NGX_ABORT; 25 return NGX_ABORT;
26 } 26 }
27 } 27 }
28 28
29 p->read = 0; 29 p->read = 0;
30 p->upstream_blocked = 0;
30 31
31 if (ngx_event_pipe_read_upstream(p) == NGX_ABORT) { 32 if (ngx_event_pipe_read_upstream(p) == NGX_ABORT) {
32 return NGX_ABORT; 33 return NGX_ABORT;
33 } 34 }
34 35
35 if (!p->read) { 36 if (!p->read && !p->upstream_blocked) {
36 break; 37 break;
37 } 38 }
38 39
39 do_write = 1; 40 do_write = 1;
40 } 41 }
137 138
138 /* 139 /*
139 * if the hunks are not needed to be saved in a cache and 140 * if the hunks are not needed to be saved in a cache and
140 * a downstream is ready then write the hunks to a downstream 141 * a downstream is ready then write the hunks to a downstream
141 */ 142 */
143
144 p->upstream_blocked = 1;
142 145
143 ngx_log_debug(p->log, "downstream ready"); 146 ngx_log_debug(p->log, "downstream ready");
144 147
145 break; 148 break;
146 149
182 ngx_log_debug(p->log, "no hunks to read in"); 185 ngx_log_debug(p->log, "no hunks to read in");
183 186
184 break; 187 break;
185 } 188 }
186 189
190 ngx_log_debug(p->log, "HUNK_FREE: %d" _ chain->hunk->num);
191
187 n = ngx_recv_chain(p->upstream, chain); 192 n = ngx_recv_chain(p->upstream, chain);
188 193
189 ngx_log_debug(p->log, "recv_chain: %d" _ n); 194 ngx_log_debug(p->log, "recv_chain: %d" _ n);
190 195
191 p->free_raw_hunks = chain; 196 p->free_raw_hunks = chain;
216 size = ce->hunk->end - ce->hunk->last; 221 size = ce->hunk->end - ce->hunk->last;
217 222
218 if (n >= size) { 223 if (n >= size) {
219 ce->hunk->last = ce->hunk->end; 224 ce->hunk->last = ce->hunk->end;
220 225
226 /* STUB */ ce->hunk->num = p->num++;
227
221 if (p->input_filter(p, ce->hunk) == NGX_ERROR) { 228 if (p->input_filter(p, ce->hunk) == NGX_ERROR) {
222 return NGX_ABORT; 229 return NGX_ABORT;
223 } 230 }
224 231
225 n -= size; 232 n -= size;
233 240
234 p->free_raw_hunks = ce; 241 p->free_raw_hunks = ce;
235 } 242 }
236 243
237 if ((p->upstream_eof || p->upstream_error) && p->free_raw_hunks) { 244 if ((p->upstream_eof || p->upstream_error) && p->free_raw_hunks) {
245 /* STUB */ p->free_raw_hunks->hunk->num = p->num++;
238 if (p->input_filter(p, p->free_raw_hunks->hunk) == NGX_ERROR) { 246 if (p->input_filter(p, p->free_raw_hunks->hunk) == NGX_ERROR) {
239 return NGX_ABORT; 247 return NGX_ABORT;
240 } 248 }
241 249
242 /* TODO: p->free_raw_hunk->next can be free()ed */ 250 /* TODO: p->free_raw_hunk->next can be free()ed */
300 } 308 }
301 309
302 p->out = p->out->next; 310 p->out = p->out->next;
303 ngx_remove_shadow_free_raw_hunk(&p->free_raw_hunks, ce->hunk); 311 ngx_remove_shadow_free_raw_hunk(&p->free_raw_hunks, ce->hunk);
304 312
313 ngx_log_debug(p->log, "HUNK OUT: %d %x" _ ce->hunk->num _ ce->hunk->type);
314
305 } else if (!p->cachable && p->in) { 315 } else if (!p->cachable && p->in) {
306 ce = p->in; 316 ce = p->in;
307 317
308 if (!(p->upstream_eof || p->upstream_error || p->upstream_done) 318 if (!(p->upstream_eof || p->upstream_error || p->upstream_done)
309 && (busy_len + ngx_hunk_size(ce->hunk) > p->max_busy_len)) 319 && (busy_len + ngx_hunk_size(ce->hunk) > p->max_busy_len))
311 break; 321 break;
312 } 322 }
313 323
314 p->in = p->in->next; 324 p->in = p->in->next;
315 325
326 ngx_log_debug(p->log, "HUNK IN: %d" _ ce->hunk->num);
327
316 } else { 328 } else {
317 break; 329 break;
318 } 330 }
319 331
320 busy_len += ngx_hunk_size(ce->hunk); 332 busy_len += ngx_hunk_size(ce->hunk);
321 ce->next = NULL; 333 ce->next = NULL;
322 ngx_chain_add_ce(out, le, ce); 334 ngx_chain_add_ce(out, le, ce);
323 } 335 }
324 336
325 if (out == NULL) { 337 if (out == NULL) {
326 break; 338 ngx_log_debug(p->log, "no hunks to write BUSY: %d" _ busy_len);
339
340 if (!p->upstream_blocked || busy_len == 0) {
341 break;
342 }
343
344 /* if the upstream is blocked then write the busy hunks */
327 } 345 }
328 346
329 if (p->output_filter(p->output_ctx, out) == NGX_ERROR) { 347 if (p->output_filter(p->output_ctx, out) == NGX_ERROR) {
330 p->downstream_error = 1; 348 p->downstream_error = 1;
349
350 /* handle the downstream error at the begin of the cycle. */
351
331 continue; 352 continue;
332 } 353 }
333 354
334 ngx_chain_update_chains(&p->free, &p->busy, &out); 355 ngx_chain_update_chains(&p->free, &p->busy, &out, p->tag);
335
336 /* add the free shadow raw hunks to p->free_raw_hunks */
337 356
338 for (ce = p->free; ce; ce = ce->next) { 357 for (ce = p->free; ce; ce = ce->next) {
358
359 /* add the free shadow raw hunk to p->free_raw_hunks */
360
339 if (ce->hunk->type & NGX_HUNK_LAST_SHADOW) { 361 if (ce->hunk->type & NGX_HUNK_LAST_SHADOW) {
340 h = ce->hunk->shadow; 362 h = ce->hunk->shadow;
341 /* THINK NEEDED ??? */ h->pos = h->last = h->start; 363 h->pos = h->last = h->start;
342 h->shadow = NULL; 364 h->shadow = NULL;
343 ngx_alloc_ce_and_set_hunk(te, h, p->pool, NGX_ABORT); 365 ngx_alloc_ce_and_set_hunk(te, h, p->pool, NGX_ABORT);
344 ngx_add_after_partially_filled_hunk(&p->free_raw_hunks, te); 366 ngx_add_after_partially_filled_hunk(&p->free_raw_hunks, te);
345 367
346 ce->hunk->type &= ~NGX_HUNK_LAST_SHADOW; 368 ce->hunk->type &= ~NGX_HUNK_LAST_SHADOW;
347 } 369 }
348 ce->hunk->shadow = NULL; 370 ce->hunk->shadow = NULL;
371
372 if (p->cyclic_temp_file && (ce->hunk->type & NGX_HUNK_TEMP_FILE)) {
373
374 /* reset p->temp_offset if all hunks had been sent */
375
376 if (ce->hunk->file_last == p->temp_offset) {
377 p->temp_offset = 0;
378 }
379 }
349 } 380 }
350 } 381 }
351 382
352 return NGX_OK; 383 return NGX_OK;
353 } 384 }
354 385
355 386
356 static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p) 387 static int ngx_event_pipe_write_chain_to_temp_file(ngx_event_pipe_t *p)
357 { 388 {
358 int rc, size, hunk_size; 389 int rc, size, hsize;
359 ngx_hunk_t *h; 390 ngx_hunk_t *h;
360 ngx_chain_t *ce, *te, *next, *out, **le, **last_free; 391 ngx_chain_t *ce, *te, *next, *out, **le, **last_free;
361 392
362 ngx_log_debug(p->log, "write to file"); 393 ngx_log_debug(p->log, "write to file");
363 394
387 le = NULL; 418 le = NULL;
388 419
389 ngx_log_debug(p->log, "offset: %d" _ p->temp_offset); 420 ngx_log_debug(p->log, "offset: %d" _ p->temp_offset);
390 421
391 do { 422 do {
392 hunk_size = ce->hunk->last - ce->hunk->pos; 423 hsize = ce->hunk->last - ce->hunk->pos;
393 424
394 ngx_log_debug(p->log, "hunk size: %d" _ hunk_size); 425 ngx_log_debug(p->log, "hunk size: %d" _ hsize);
395 426
396 if ((size + hunk_size > p->temp_file_write_size) 427 if ((size + hsize > p->temp_file_write_size)
397 || (p->temp_offset + hunk_size > p->max_temp_file_size)) 428 || (p->temp_offset + size + hsize > p->max_temp_file_size))
398 { 429 {
399 break; 430 break;
400 } 431 }
401 432
402 size += hunk_size; 433 size += hsize;
403 le = &ce->next; 434 le = &ce->next;
404 ce = ce->next; 435 ce = ce->next;
405 436
406 } while (ce); 437 } while (ce);
407 438
436 for (ce = out; ce; ce = next) { 467 for (ce = out; ce; ce = next) {
437 next = ce->next; 468 next = ce->next;
438 ce->next = NULL; 469 ce->next = NULL;
439 470
440 h = ce->hunk; 471 h = ce->hunk;
441 h->type |= NGX_HUNK_FILE;
442 h->file = p->temp_file; 472 h->file = p->temp_file;
443 h->file_pos = p->temp_offset; 473 h->file_pos = p->temp_offset;
444 p->temp_offset += h->last - h->pos; 474 p->temp_offset += h->last - h->pos;
445 h->file_last = p->temp_offset; 475 h->file_last = p->temp_offset;
476
477 if (p->cachable) {
478 h->type |= NGX_HUNK_FILE;
479 } else {
480 h->type |= NGX_HUNK_FILE|NGX_HUNK_TEMP_FILE;
481 }
446 482
447 ngx_chain_add_ce(p->out, p->last_out, ce); 483 ngx_chain_add_ce(p->out, p->last_out, ce);
448 484
449 if (h->type & NGX_HUNK_LAST_SHADOW) { 485 if (h->type & NGX_HUNK_LAST_SHADOW) {
450 h->shadow->last = h->shadow->pos = h->shadow->start; 486 h->shadow->last = h->shadow->pos = h->shadow->start;
477 ngx_test_null(h, ngx_alloc_hunk(p->pool), NGX_ERROR); 513 ngx_test_null(h, ngx_alloc_hunk(p->pool), NGX_ERROR);
478 } 514 }
479 515
480 ngx_memcpy(h, hunk, sizeof(ngx_hunk_t)); 516 ngx_memcpy(h, hunk, sizeof(ngx_hunk_t));
481 h->shadow = hunk; 517 h->shadow = hunk;
518 h->tag = p->tag;
482 h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED; 519 h->type |= NGX_HUNK_LAST_SHADOW|NGX_HUNK_RECYCLED;
483 hunk->shadow = h; 520 hunk->shadow = h;
484 521
485 ngx_alloc_ce_and_set_hunk(ce, h, p->pool, NGX_ERROR); 522 ngx_alloc_ce_and_set_hunk(ce, h, p->pool, NGX_ERROR);
523 ngx_log_debug(p->log, "HUNK %d" _ h->num);
486 ngx_chain_add_ce(p->in, p->last_in, ce); 524 ngx_chain_add_ce(p->in, p->last_in, ce);
487 525
488 return NGX_OK; 526 return NGX_OK;
489 } 527 }
490 528