nginxtra 1.6.3.9 → 1.8.0.9

data/vendor/nginx/src/os/unix/ngx_os.h

@@ -17,7 +17,8 @@
 
 
 typedef ssize_t (*ngx_recv_pt)(ngx_connection_t *c, u_char *buf, size_t size);
-typedef ssize_t (*ngx_recv_chain_pt)(ngx_connection_t *c, ngx_chain_t *in);
+typedef ssize_t (*ngx_recv_chain_pt)(ngx_connection_t *c, ngx_chain_t *in,
+    off_t limit);
 typedef ssize_t (*ngx_send_pt)(ngx_connection_t *c, u_char *buf, size_t size);
 typedef ngx_chain_t *(*ngx_send_chain_pt)(ngx_connection_t *c, ngx_chain_t *in,
     off_t limit);
@@ -41,7 +42,7 @@ ngx_int_t ngx_os_signal_process(ngx_cycle_t *cycle, char *sig, ngx_int_t pid);
 
 
 ssize_t ngx_unix_recv(ngx_connection_t *c, u_char *buf, size_t size);
-ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *entry);
+ssize_t ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *entry, off_t limit);
 ssize_t ngx_udp_unix_recv(ngx_connection_t *c, u_char *buf, size_t size);
 ssize_t ngx_unix_send(ngx_connection_t *c, u_char *buf, size_t size);
 ngx_chain_t *ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in,
@@ -49,13 +50,34 @@ ngx_chain_t *ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in,
 
 #if (NGX_HAVE_AIO)
 ssize_t ngx_aio_read(ngx_connection_t *c, u_char *buf, size_t size);
-ssize_t ngx_aio_read_chain(ngx_connection_t *c, ngx_chain_t *cl);
+ssize_t ngx_aio_read_chain(ngx_connection_t *c, ngx_chain_t *cl, off_t limit);
 ssize_t ngx_aio_write(ngx_connection_t *c, u_char *buf, size_t size);
 ngx_chain_t *ngx_aio_write_chain(ngx_connection_t *c, ngx_chain_t *in,
     off_t limit);
 #endif
 
 
+#if (IOV_MAX > 64)
+#define NGX_IOVS_PREALLOCATE  64
+#else
+#define NGX_IOVS_PREALLOCATE  IOV_MAX
+#endif
+
+
+typedef struct {
+    struct iovec  *iovs;
+    ngx_uint_t     count;
+    size_t         size;
+    ngx_uint_t     nalloc;
+} ngx_iovec_t;
+
+ngx_chain_t *ngx_output_chain_to_iovec(ngx_iovec_t *vec, ngx_chain_t *in,
+    size_t limit, ngx_log_t *log);
+
+
+ssize_t ngx_writev(ngx_connection_t *c, ngx_iovec_t *vec);
+
+
 extern ngx_os_io_t  ngx_os_io;
 extern ngx_int_t    ngx_ncpu;
 extern ngx_int_t    ngx_max_sockets;

data/vendor/nginx/src/os/unix/ngx_posix_init.c

@@ -40,7 +40,9 @@ ngx_os_init(ngx_log_t *log)
     }
 #endif
 
-    ngx_init_setproctitle(log);
+    if (ngx_init_setproctitle(log) != NGX_OK) {
+        return NGX_ERROR;
+    }
 
     ngx_pagesize = getpagesize();
     ngx_cacheline_size = NGX_CPU_CACHE_LINE;
@@ -82,7 +84,7 @@ ngx_os_init(ngx_log_t *log)
 void
 ngx_os_status(ngx_log_t *log)
 {
-    ngx_log_error(NGX_LOG_NOTICE, log, 0, NGINX_VER);
+    ngx_log_error(NGX_LOG_NOTICE, log, 0, NGINX_VER_BUILD);
 
 #ifdef NGX_COMPILER
     ngx_log_error(NGX_LOG_NOTICE, log, 0, "built by " NGX_COMPILER);

data/vendor/nginx/src/os/unix/ngx_process_cycle.c

@@ -23,10 +23,6 @@ static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data);
 static void ngx_worker_process_init(ngx_cycle_t *cycle, ngx_int_t worker);
 static void ngx_worker_process_exit(ngx_cycle_t *cycle);
 static void ngx_channel_handler(ngx_event_t *ev);
-#if (NGX_THREADS)
-static void ngx_wakeup_worker_threads(ngx_cycle_t *cycle);
-static ngx_thread_value_t ngx_worker_thread_cycle(void *data);
-#endif
 static void ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data);
 static void ngx_cache_manager_process_handler(ngx_event_t *ev);
 static void ngx_cache_loader_process_handler(ngx_event_t *ev);
@@ -34,7 +30,6 @@ static void ngx_cache_loader_process_handler(ngx_event_t *ev);
 
 ngx_uint_t    ngx_process;
 ngx_pid_t     ngx_pid;
-ngx_uint_t    ngx_threaded;
 
 sig_atomic_t  ngx_reap;
 sig_atomic_t  ngx_sigio;
@@ -56,12 +51,6 @@ ngx_uint_t    ngx_noaccepting;
 ngx_uint_t    ngx_restart;
 
 
-#if (NGX_THREADS)
-volatile ngx_thread_t  ngx_threads[NGX_MAX_THREADS];
-ngx_int_t              ngx_threads_n;
-#endif
-
-
 static u_char  master_process[] = "master process";
 
 
@@ -121,6 +110,10 @@ ngx_master_process_cycle(ngx_cycle_t *cycle)
     }
 
     title = ngx_pnalloc(cycle->pool, size);
+    if (title == NULL) {
+        /* fatal */
+        exit(2);
+    }
 
     p = ngx_cpymem(title, master_process, sizeof(master_process) - 1);
     for (i = 0; i < ngx_argc; i++) {
@@ -710,11 +703,13 @@ ngx_master_process_exit(ngx_cycle_t *cycle)
      * ngx_cycle->pool is already destroyed.
      */
 
-    ngx_exit_log_file.fd = ngx_cycle->log->file->fd;
 
-    ngx_exit_log = *ngx_cycle->log;
+    ngx_exit_log = *ngx_log_get_file_log(ngx_cycle->log);
+
+    ngx_exit_log_file.fd = ngx_exit_log.file->fd;
     ngx_exit_log.file = &ngx_exit_log_file;
     ngx_exit_log.next = NULL;
+    ngx_exit_log.writer = NULL;
 
     ngx_exit_cycle.log = &ngx_exit_log;
     ngx_exit_cycle.files = ngx_cycle->files;
@@ -741,52 +736,6 @@ ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
 
     ngx_setproctitle("worker process");
 
-#if (NGX_THREADS)
-    {
-    ngx_int_t         n;
-    ngx_err_t         err;
-    ngx_core_conf_t  *ccf;
-
-    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
-
-    if (ngx_threads_n) {
-        if (ngx_init_threads(ngx_threads_n, ccf->thread_stack_size, cycle)
-            == NGX_ERROR)
-        {
-            /* fatal */
-            exit(2);
-        }
-
-        err = ngx_thread_key_create(&ngx_core_tls_key);
-        if (err != 0) {
-            ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
-                          ngx_thread_key_create_n " failed");
-            /* fatal */
-            exit(2);
-        }
-
-        for (n = 0; n < ngx_threads_n; n++) {
-
-            ngx_threads[n].cv = ngx_cond_init(cycle->log);
-
-            if (ngx_threads[n].cv == NULL) {
-                /* fatal */
-                exit(2);
-            }
-
-            if (ngx_create_thread((ngx_tid_t *) &ngx_threads[n].tid,
-                                  ngx_worker_thread_cycle,
-                                  (void *) &ngx_threads[n], cycle->log)
-                != 0)
-            {
-                /* fatal */
-                exit(2);
-            }
-        }
-    }
-    }
-#endif
-
     for ( ;; ) {
 
         if (ngx_exiting) {
@@ -803,6 +752,8 @@ ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
                 }
             }
 
+            ngx_event_cancel_timers();
+
             if (ngx_event_timer_rbtree.root == ngx_event_timer_rbtree.sentinel)
             {
                 ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
@@ -1024,12 +975,6 @@ ngx_worker_process_exit(ngx_cycle_t *cycle)
     ngx_uint_t         i;
     ngx_connection_t  *c;
 
-#if (NGX_THREADS)
-    ngx_terminate = 1;
-
-    ngx_wakeup_worker_threads(cycle);
-#endif
-
     for (i = 0; ngx_modules[i]; i++) {
         if (ngx_modules[i]->exit_process) {
             ngx_modules[i]->exit_process(cycle);
@@ -1065,11 +1010,12 @@ ngx_worker_process_exit(ngx_cycle_t *cycle)
      * ngx_cycle->pool is already destroyed.
      */
 
-    ngx_exit_log_file.fd = ngx_cycle->log->file->fd;
+    ngx_exit_log = *ngx_log_get_file_log(ngx_cycle->log);
 
-    ngx_exit_log = *ngx_cycle->log;
+    ngx_exit_log_file.fd = ngx_exit_log.file->fd;
     ngx_exit_log.file = &ngx_exit_log_file;
     ngx_exit_log.next = NULL;
+    ngx_exit_log.writer = NULL;
 
     ngx_exit_cycle.log = &ngx_exit_log;
     ngx_exit_cycle.files = ngx_cycle->files;
@@ -1172,134 +1118,6 @@ ngx_channel_handler(ngx_event_t *ev)
 }
 
 
-#if (NGX_THREADS)
-
-static void
-ngx_wakeup_worker_threads(ngx_cycle_t *cycle)
-{
-    ngx_int_t   i;
-    ngx_uint_t  live;
-
-    for ( ;; ) {
-
-        live = 0;
-
-        for (i = 0; i < ngx_threads_n; i++) {
-            if (ngx_threads[i].state < NGX_THREAD_EXIT) {
-                if (ngx_cond_signal(ngx_threads[i].cv) == NGX_ERROR) {
-                    ngx_threads[i].state = NGX_THREAD_DONE;
-
-                } else {
-                    live = 1;
-                }
-            }
-
-            if (ngx_threads[i].state == NGX_THREAD_EXIT) {
-                ngx_thread_join(ngx_threads[i].tid, NULL);
-                ngx_threads[i].state = NGX_THREAD_DONE;
-            }
-        }
-
-        if (live == 0) {
-            ngx_log_debug0(NGX_LOG_DEBUG_CORE, cycle->log, 0,
-                           "all worker threads are joined");
-
-            /* STUB */
-            ngx_done_events(cycle);
-            ngx_mutex_destroy(ngx_event_timer_mutex);
-            ngx_mutex_destroy(ngx_posted_events_mutex);
-
-            return;
-        }
-
-        ngx_sched_yield();
-    }
-}
-
-
-static ngx_thread_value_t
-ngx_worker_thread_cycle(void *data)
-{
-    ngx_thread_t  *thr = data;
-
-    sigset_t          set;
-    ngx_err_t         err;
-    ngx_core_tls_t   *tls;
-    ngx_cycle_t      *cycle;
-
-    cycle = (ngx_cycle_t *) ngx_cycle;
-
-    sigemptyset(&set);
-    sigaddset(&set, ngx_signal_value(NGX_RECONFIGURE_SIGNAL));
-    sigaddset(&set, ngx_signal_value(NGX_REOPEN_SIGNAL));
-    sigaddset(&set, ngx_signal_value(NGX_CHANGEBIN_SIGNAL));
-
-    err = ngx_thread_sigmask(SIG_BLOCK, &set, NULL);
-    if (err) {
-        ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
-                      ngx_thread_sigmask_n " failed");
-        return (ngx_thread_value_t) 1;
-    }
-
-    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0,
-                   "thread " NGX_TID_T_FMT " started", ngx_thread_self());
-
-    ngx_setthrtitle("worker thread");
-
-    tls = ngx_calloc(sizeof(ngx_core_tls_t), cycle->log);
-    if (tls == NULL) {
-        return (ngx_thread_value_t) 1;
-    }
-
-    err = ngx_thread_set_tls(ngx_core_tls_key, tls);
-    if (err != 0) {
-        ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
-                      ngx_thread_set_tls_n " failed");
-        return (ngx_thread_value_t) 1;
-    }
-
-    ngx_mutex_lock(ngx_posted_events_mutex);
-
-    for ( ;; ) {
-        thr->state = NGX_THREAD_FREE;
-
-        if (ngx_cond_wait(thr->cv, ngx_posted_events_mutex) == NGX_ERROR) {
-            return (ngx_thread_value_t) 1;
-        }
-
-        if (ngx_terminate) {
-            thr->state = NGX_THREAD_EXIT;
-
-            ngx_mutex_unlock(ngx_posted_events_mutex);
-
-            ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0,
-                           "thread " NGX_TID_T_FMT " is done",
-                           ngx_thread_self());
-
-            return (ngx_thread_value_t) 0;
-        }
-
-        thr->state = NGX_THREAD_BUSY;
-
-        if (ngx_event_thread_process_posted(cycle) == NGX_ERROR) {
-            return (ngx_thread_value_t) 1;
-        }
-
-        if (ngx_event_thread_process_posted(cycle) == NGX_ERROR) {
-            return (ngx_thread_value_t) 1;
-        }
-
-        if (ngx_process_changes) {
-            if (ngx_process_changes(cycle, 1) == NGX_ERROR) {
-                return (ngx_thread_value_t) 1;
-            }
-        }
-    }
-}
-
-#endif
-
-
 static void
 ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data)
 {

data/vendor/nginx/src/os/unix/ngx_process_cycle.h

@@ -43,7 +43,6 @@ extern ngx_pid_t       ngx_pid;
 extern ngx_pid_t       ngx_new_binary;
 extern ngx_uint_t      ngx_inherited;
 extern ngx_uint_t      ngx_daemonized;
-extern ngx_uint_t      ngx_threaded;
 extern ngx_uint_t      ngx_exiting;
 
 extern sig_atomic_t    ngx_reap;

data/vendor/nginx/src/os/unix/ngx_readv_chain.c

@@ -10,23 +10,20 @@
 #include <ngx_event.h>
 
 
-#define NGX_IOVS  16
-
-
-#if (NGX_HAVE_KQUEUE)
-
 ssize_t
-ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
+ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain, off_t limit)
 {
     u_char        *prev;
     ssize_t        n, size;
     ngx_err_t      err;
     ngx_array_t    vec;
     ngx_event_t   *rev;
-    struct iovec  *iov, iovs[NGX_IOVS];
+    struct iovec  *iov, iovs[NGX_IOVS_PREALLOCATE];
 
     rev = c->read;
 
+#if (NGX_HAVE_KQUEUE)
+
     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
                        "readv: eof:%d, avail:%d, err:%d",
@@ -54,6 +51,8 @@ ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
         }
     }
 
+#endif
+
     prev = NULL;
     iov = NULL;
     size = 0;
@@ -61,14 +60,26 @@ ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
     vec.elts = iovs;
     vec.nelts = 0;
     vec.size = sizeof(struct iovec);
-    vec.nalloc = NGX_IOVS;
+    vec.nalloc = NGX_IOVS_PREALLOCATE;
     vec.pool = c->pool;
 
     /* coalesce the neighbouring bufs */
 
     while (chain) {
+        n = chain->buf->end - chain->buf->last;
+
+        if (limit) {
+            if (size >= limit) {
+                break;
+            }
+
+            if (size + n > limit) {
+                n = (ssize_t) (limit - size);
+            }
+        }
+
         if (prev == chain->buf->last) {
-            iov->iov_len += chain->buf->end - chain->buf->last;
+            iov->iov_len += n;
 
         } else {
             if (vec.nelts >= IOV_MAX) {
@@ -81,10 +92,10 @@ ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
             }
 
             iov->iov_base = (void *) chain->buf->last;
-            iov->iov_len = chain->buf->end - chain->buf->last;
+            iov->iov_len = n;
         }
 
-        size += chain->buf->end - chain->buf->last;
+        size += n;
         prev = chain->buf->end;
         chain = chain->next;
     }
@@ -92,12 +103,13 @@ ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
                    "readv: %d, last:%d", vec.nelts, iov->iov_len);
 
-    rev = c->read;
-
     do {
         n = readv(c->fd, (struct iovec *) vec.elts, vec.nelts);
 
         if (n >= 0) {
+
+#if (NGX_HAVE_KQUEUE)
+
             if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
                 rev->available -= n;
 
@@ -137,6 +149,8 @@ ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
                 return n;
             }
 
+#endif /* NGX_HAVE_KQUEUE */
+
             if (n < size && !(ngx_event_flags & NGX_USE_GREEDY_EVENT)) {
                 rev->ready = 0;
             }
@@ -170,98 +184,3 @@ ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
 
     return n;
 }
-
-#else /* ! NGX_HAVE_KQUEUE */
-
-ssize_t
-ngx_readv_chain(ngx_connection_t *c, ngx_chain_t *chain)
-{
-    u_char        *prev;
-    ssize_t        n, size;
-    ngx_err_t      err;
-    ngx_array_t    vec;
-    ngx_event_t   *rev;
-    struct iovec  *iov, iovs[NGX_IOVS];
-
-    prev = NULL;
-    iov = NULL;
-    size = 0;
-
-    vec.elts = iovs;
-    vec.nelts = 0;
-    vec.size = sizeof(struct iovec);
-    vec.nalloc = NGX_IOVS;
-    vec.pool = c->pool;
-
-    /* coalesce the neighbouring bufs */
-
-    while (chain) {
-        if (prev == chain->buf->last) {
-            iov->iov_len += chain->buf->end - chain->buf->last;
-
-        } else {
-            if (vec.nelts >= IOV_MAX) {
-                break;
-            }
-
-            iov = ngx_array_push(&vec);
-            if (iov == NULL) {
-                return NGX_ERROR;
-            }
-
-            iov->iov_base = (void *) chain->buf->last;
-            iov->iov_len = chain->buf->end - chain->buf->last;
-        }
-
-        size += chain->buf->end - chain->buf->last;
-        prev = chain->buf->end;
-        chain = chain->next;
-    }
-
-    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
-                   "readv: %d:%d", vec.nelts, iov->iov_len);
-
-    rev = c->read;
-
-    do {
-        n = readv(c->fd, (struct iovec *) vec.elts, vec.nelts);
-
-        if (n == 0) {
-            rev->ready = 0;
-            rev->eof = 1;
-
-            return n;
-
-        } else if (n > 0) {
-
-            if (n < size && !(ngx_event_flags & NGX_USE_GREEDY_EVENT)) {
-                rev->ready = 0;
-            }
-
-            return n;
-        }
-
-        err = ngx_socket_errno;
-
-        if (err == NGX_EAGAIN || err == NGX_EINTR) {
-            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
-                           "readv() not ready");
-            n = NGX_AGAIN;
-
-        } else {
-            n = ngx_connection_error(c, err, "readv() failed");
-            break;
-        }
-
-    } while (err == NGX_EINTR);
-
-    rev->ready = 0;
-
-    if (n == NGX_ERROR) {
-        c->read->error = 1;
-    }
-
-    return n;
-}
-
-#endif /* NGX_HAVE_KQUEUE */