Return to ngx_aio_write_chain.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / os / unix

Annotation of embedaddon/nginx/src/os/unix/ngx_aio_write_chain.c, revision 1.1

1.1     ! misho       1: 
        !             2: /*
        !             3:  * Copyright (C) Igor Sysoev
        !             4:  * Copyright (C) Nginx, Inc.
        !             5:  */
        !             6: 
        !             7: 
        !             8: #include <ngx_config.h>
        !             9: #include <ngx_core.h>
        !            10: #include <ngx_event.h>
        !            11: 
        !            12: 
        !            13: ngx_chain_t *
        !            14: ngx_aio_write_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
        !            15: {
        !            16:     u_char       *buf, *prev;
        !            17:     off_t         send, sent;
        !            18:     size_t        len;
        !            19:     ssize_t       n, size;
        !            20:     ngx_chain_t  *cl;
        !            21: 
        !            22:     /* the maximum limit size is the maximum size_t value - the page size */
        !            23: 
        !            24:     if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
        !            25:         limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
        !            26:     }
        !            27: 
        !            28:     send = 0;
        !            29:     sent = 0;
        !            30:     cl = in;
        !            31: 
        !            32:     while (cl) {
        !            33: 
        !            34:         if (cl->buf->pos == cl->buf->last) {
        !            35:             cl = cl->next;
        !            36:             continue;
        !            37:         }
        !            38: 
        !            39:         /* we can post the single aio operation only */
        !            40: 
        !            41:         if (!c->write->ready) {
        !            42:             return cl;
        !            43:         }
        !            44: 
        !            45:         buf = cl->buf->pos;
        !            46:         prev = buf;
        !            47:         len = 0;
        !            48: 
        !            49:         /* coalesce the neighbouring bufs */
        !            50: 
        !            51:         while (cl && prev == cl->buf->pos && send < limit) {
        !            52:             if (ngx_buf_special(cl->buf)) {
        !            53:                 continue;
        !            54:             }
        !            55: 
        !            56:             size = cl->buf->last - cl->buf->pos;
        !            57: 
        !            58:             if (send + size > limit) {
        !            59:                 size = limit - send;
        !            60:             }
        !            61: 
        !            62:             len += size;
        !            63:             prev = cl->buf->pos + size;
        !            64:             send += size;
        !            65:             cl = cl->next;
        !            66:         }
        !            67: 
        !            68:         n = ngx_aio_write(c, buf, len);
        !            69: 
        !            70:         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "aio_write: %z", n);
        !            71: 
        !            72:         if (n == NGX_ERROR) {
        !            73:             return NGX_CHAIN_ERROR;
        !            74:         }
        !            75: 
        !            76:         if (n > 0) {
        !            77:             sent += n;
        !            78:             c->sent += n;
        !            79:         }
        !            80: 
        !            81:         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
        !            82:                        "aio_write sent: %O", c->sent);
        !            83: 
        !            84:         for (cl = in; cl; cl = cl->next) {
        !            85: 
        !            86:             if (sent >= cl->buf->last - cl->buf->pos) {
        !            87:                 sent -= cl->buf->last - cl->buf->pos;
        !            88:                 cl->buf->pos = cl->buf->last;
        !            89: 
        !            90:                 continue;
        !            91:             }
        !            92: 
        !            93:             cl->buf->pos += sent;
        !            94: 
        !            95:             break;
        !            96:         }
        !            97:     }
        !            98: 
        !            99:     return cl;
        !           100: }