nginxtra 1.8.1.12 → 1.10.1.12

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

@@ -15,10 +15,10 @@
 
 
 typedef struct {
-     ngx_uint_t  command;
-     ngx_pid_t   pid;
-     ngx_int_t   slot;
-     ngx_fd_t    fd;
+    ngx_uint_t  command;
+    ngx_pid_t   pid;
+    ngx_int_t   slot;
+    ngx_fd_t    fd;
 } ngx_channel_t;
 
 

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

@@ -48,6 +48,8 @@
 #include <sys/sysctl.h>
 #include <xlocale.h>
 
+#include <dlfcn.h>
+
 
 #ifndef IOV_MAX
 #define IOV_MAX   64

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

@@ -23,6 +23,7 @@ static ngx_os_io_t ngx_darwin_io = {
     ngx_readv_chain,
     ngx_udp_unix_recv,
     ngx_unix_send,
+    ngx_udp_unix_send,
 #if (NGX_HAVE_SENDFILE)
     ngx_darwin_sendfile_chain,
     NGX_IO_SENDFILE

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

@@ -0,0 +1,28 @@
+
+/*
+ * Copyright (C) Maxim Dounin
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+#if (NGX_HAVE_DLOPEN)
+
+char *
+ngx_dlerror(void)
+{
+    char  *err;
+
+    err = (char *) dlerror();
+
+    if (err == NULL) {
+        return "";
+    }
+
+    return err;
+}
+
+#endif

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

@@ -0,0 +1,31 @@
+
+/*
+ * Copyright (C) Maxim Dounin
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#ifndef _NGX_DLOPEN_H_INCLUDED_
+#define _NGX_DLOPEN_H_INCLUDED_
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+#define ngx_dlopen(path)           dlopen((char *) path, RTLD_NOW | RTLD_GLOBAL)
+#define ngx_dlopen_n               "dlopen()"
+
+#define ngx_dlsym(handle, symbol)  dlsym(handle, symbol)
+#define ngx_dlsym_n                "dlsym()"
+
+#define ngx_dlclose(handle)        dlclose(handle)
+#define ngx_dlclose_n              "dlclose()"
+
+
+#if (NGX_HAVE_DLOPEN)
+char *ngx_dlerror(void);
+#endif
+
+
+#endif /* _NGX_DLOPEN_H_INCLUDED_ */

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

@@ -25,6 +25,7 @@ typedef int               ngx_err_t;
 #define NGX_EACCES        EACCES
 #define NGX_EBUSY         EBUSY
 #define NGX_EEXIST        EEXIST
+#define NGX_EEXIST_FILE   EEXIST
 #define NGX_EXDEV         EXDEV
 #define NGX_ENOTDIR       ENOTDIR
 #define NGX_EISDIR        EISDIR

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

@@ -84,7 +84,7 @@ ngx_file_aio_read(ngx_file_t *file, u_char *buf, size_t size, off_t offset,
     }
 
     ngx_log_debug4(NGX_LOG_DEBUG_CORE, file->log, 0,
-                   "aio complete:%d @%O:%z %V",
+                   "aio complete:%d @%O:%uz %V",
                    ev->complete, offset, size, &file->name);
 
     if (ev->complete) {

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

@@ -12,8 +12,13 @@
 #if (NGX_THREADS)
 #include <ngx_thread_pool.h>
 static void ngx_thread_read_handler(void *data, ngx_log_t *log);
+static void ngx_thread_write_chain_to_file_handler(void *data, ngx_log_t *log);
 #endif
 
+static ngx_chain_t *ngx_chain_to_iovec(ngx_iovec_t *vec, ngx_chain_t *cl);
+static ssize_t ngx_writev_file(ngx_file_t *file, ngx_iovec_t *vec,
+    off_t offset);
+
 
 #if (NGX_HAVE_FILE_AIO)
 
@@ -73,38 +78,39 @@ ngx_read_file(ngx_file_t *file, u_char *buf, size_t size, off_t offset)
 #if (NGX_THREADS)
 
 typedef struct {
-    ngx_fd_t     fd;
-    u_char      *buf;
-    size_t       size;
-    off_t        offset;
+    ngx_fd_t       fd;
+    ngx_uint_t     write;   /* unsigned  write:1; */
+
+    u_char        *buf;
+    size_t         size;
+    ngx_chain_t   *chain;
+    off_t          offset;
 
-    size_t       read;
-    ngx_err_t    err;
-} ngx_thread_read_ctx_t;
+    size_t         nbytes;
+    ngx_err_t      err;
+} ngx_thread_file_ctx_t;
 
 
 ssize_t
-ngx_thread_read(ngx_thread_task_t **taskp, ngx_file_t *file, u_char *buf,
-    size_t size, off_t offset, ngx_pool_t *pool)
+ngx_thread_read(ngx_file_t *file, u_char *buf, size_t size, off_t offset,
+    ngx_pool_t *pool)
 {
     ngx_thread_task_t      *task;
-    ngx_thread_read_ctx_t  *ctx;
+    ngx_thread_file_ctx_t  *ctx;
 
     ngx_log_debug4(NGX_LOG_DEBUG_CORE, file->log, 0,
                    "thread read: %d, %p, %uz, %O",
                    file->fd, buf, size, offset);
 
-    task = *taskp;
+    task = file->thread_task;
 
     if (task == NULL) {
-        task = ngx_thread_task_alloc(pool, sizeof(ngx_thread_read_ctx_t));
+        task = ngx_thread_task_alloc(pool, sizeof(ngx_thread_file_ctx_t));
         if (task == NULL) {
             return NGX_ERROR;
         }
 
-        task->handler = ngx_thread_read_handler;
-
-        *taskp = task;
+        file->thread_task = task;
     }
 
     ctx = task->ctx;
@@ -112,15 +118,25 @@ ngx_thread_read(ngx_thread_task_t **taskp, ngx_file_t *file, u_char *buf,
     if (task->event.complete) {
         task->event.complete = 0;
 
+        if (ctx->write) {
+            ngx_log_error(NGX_LOG_ALERT, file->log, 0,
+                          "invalid thread call, read instead of write");
+            return NGX_ERROR;
+        }
+
         if (ctx->err) {
             ngx_log_error(NGX_LOG_CRIT, file->log, ctx->err,
                           "pread() \"%s\" failed", file->name.data);
             return NGX_ERROR;
         }
 
-        return ctx->read;
+        return ctx->nbytes;
     }
 
+    task->handler = ngx_thread_read_handler;
+
+    ctx->write = 0;
+
     ctx->fd = file->fd;
     ctx->buf = buf;
     ctx->size = size;
@@ -139,7 +155,7 @@ ngx_thread_read(ngx_thread_task_t **taskp, ngx_file_t *file, u_char *buf,
 static void
 ngx_thread_read_handler(void *data, ngx_log_t *log)
 {
-    ngx_thread_read_ctx_t *ctx = data;
+    ngx_thread_file_ctx_t *ctx = data;
 
     ssize_t  n;
 
@@ -151,7 +167,7 @@ ngx_thread_read_handler(void *data, ngx_log_t *log)
         ctx->err = ngx_errno;
 
     } else {
-        ctx->read = n;
+        ctx->nbytes = n;
         ctx->err = 0;
     }
 
@@ -160,7 +176,7 @@ ngx_thread_read_handler(void *data, ngx_log_t *log)
 #endif
 
     ngx_log_debug4(NGX_LOG_DEBUG_CORE, log, 0,
-                   "pread: %z (err: %i) of %uz @%O",
+                   "pread: %z (err: %d) of %uz @%O",
                    n, ctx->err, ctx->size, ctx->offset);
 }
 
@@ -176,7 +192,8 @@ ngx_thread_read_handler(void *data, ngx_log_t *log)
 ssize_t
 ngx_write_file(ngx_file_t *file, u_char *buf, size_t size, off_t offset)
 {
-    ssize_t  n, written;
+    ssize_t    n, written;
+    ngx_err_t  err;
 
     ngx_log_debug4(NGX_LOG_DEBUG_CORE, file->log, 0,
                    "write: %d, %p, %uz, %O", file->fd, buf, size, offset);
@@ -189,7 +206,15 @@ ngx_write_file(ngx_file_t *file, u_char *buf, size_t size, off_t offset)
         n = pwrite(file->fd, buf + written, size, offset);
 
         if (n == -1) {
-            ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
+            err = ngx_errno;
+
+            if (err == NGX_EINTR) {
+                ngx_log_debug0(NGX_LOG_DEBUG_CORE, file->log, err,
+                               "pwrite() was interrupted");
+                continue;
+            }
+
+            ngx_log_error(NGX_LOG_CRIT, file->log, err,
                           "pwrite() \"%s\" failed", file->name.data);
             return NGX_ERROR;
         }
@@ -221,11 +246,20 @@ ngx_write_file(ngx_file_t *file, u_char *buf, size_t size, off_t offset)
         n = write(file->fd, buf + written, size);
 
         if (n == -1) {
-            ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
+            err = ngx_errno;
+
+            if (err == NGX_EINTR) {
+                ngx_log_debug0(NGX_LOG_DEBUG_CORE, file->log, err,
+                               "write() was interrupted");
+                continue;
+            }
+
+            ngx_log_error(NGX_LOG_CRIT, file->log, err,
                           "write() \"%s\" failed", file->name.data);
             return NGX_ERROR;
         }
 
+        file->sys_offset += n;
         file->offset += n;
         written += n;
 
@@ -255,17 +289,13 @@ ngx_open_tempfile(u_char *name, ngx_uint_t persistent, ngx_uint_t access)
 }
 
 
-#define NGX_IOVS  8
-
 ssize_t
 ngx_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl, off_t offset,
     ngx_pool_t *pool)
 {
-    u_char        *prev;
-    size_t         size;
     ssize_t        total, n;
-    ngx_array_t    vec;
-    struct iovec  *iov, iovs[NGX_IOVS];
+    ngx_iovec_t    vec;
+    struct iovec   iovs[NGX_IOVS_PREALLOCATE];
 
     /* use pwrite() if there is the only buf in a chain */
 
@@ -277,92 +307,295 @@ ngx_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl, off_t offset,
 
     total = 0;
 
-    vec.elts = iovs;
-    vec.size = sizeof(struct iovec);
-    vec.nalloc = NGX_IOVS;
-    vec.pool = pool;
+    vec.iovs = iovs;
+    vec.nalloc = NGX_IOVS_PREALLOCATE;
 
     do {
-        prev = NULL;
-        iov = NULL;
-        size = 0;
-
-        vec.nelts = 0;
-
         /* create the iovec and coalesce the neighbouring bufs */
+        cl = ngx_chain_to_iovec(&vec, cl);
 
-        while (cl && vec.nelts < IOV_MAX) {
-            if (prev == cl->buf->pos) {
-                iov->iov_len += cl->buf->last - cl->buf->pos;
+        /* use pwrite() if there is the only iovec buffer */
 
-            } else {
-                iov = ngx_array_push(&vec);
-                if (iov == NULL) {
-                    return NGX_ERROR;
-                }
+        if (vec.count == 1) {
+            n = ngx_write_file(file, (u_char *) iovs[0].iov_base,
+                               iovs[0].iov_len, offset);
 
-                iov->iov_base = (void *) cl->buf->pos;
-                iov->iov_len = cl->buf->last - cl->buf->pos;
+            if (n == NGX_ERROR) {
+                return n;
             }
 
-            size += cl->buf->last - cl->buf->pos;
-            prev = cl->buf->last;
-            cl = cl->next;
+            return total + n;
         }
 
-        /* use pwrite() if there is the only iovec buffer */
+        n = ngx_writev_file(file, &vec, offset);
 
-        if (vec.nelts == 1) {
-            iov = vec.elts;
+        if (n == NGX_ERROR) {
+            return n;
+        }
 
-            n = ngx_write_file(file, (u_char *) iov[0].iov_base,
-                               iov[0].iov_len, offset);
+        offset += n;
+        total += n;
 
-            if (n == NGX_ERROR) {
-                return n;
-            }
+    } while (cl);
 
-            return total + n;
+    return total;
+}
+
+
+static ngx_chain_t *
+ngx_chain_to_iovec(ngx_iovec_t *vec, ngx_chain_t *cl)
+{
+    size_t         total, size;
+    u_char        *prev;
+    ngx_uint_t     n;
+    struct iovec  *iov;
+
+    iov = NULL;
+    prev = NULL;
+    total = 0;
+    n = 0;
+
+    for ( /* void */ ; cl; cl = cl->next) {
+
+        if (ngx_buf_special(cl->buf)) {
+            continue;
         }
 
-        if (file->sys_offset != offset) {
-            if (lseek(file->fd, offset, SEEK_SET) == -1) {
-                ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
-                              "lseek() \"%s\" failed", file->name.data);
-                return NGX_ERROR;
+        size = cl->buf->last - cl->buf->pos;
+
+        if (prev == cl->buf->pos) {
+            iov->iov_len += size;
+
+        } else {
+            if (n == vec->nalloc) {
+                break;
             }
 
-            file->sys_offset = offset;
+            iov = &vec->iovs[n++];
+
+            iov->iov_base = (void *) cl->buf->pos;
+            iov->iov_len = size;
         }
 
-        n = writev(file->fd, vec.elts, vec.nelts);
+        prev = cl->buf->pos + size;
+        total += size;
+    }
 
-        if (n == -1) {
+    vec->count = n;
+    vec->size = total;
+
+    return cl;
+}
+
+
+static ssize_t
+ngx_writev_file(ngx_file_t *file, ngx_iovec_t *vec, off_t offset)
+{
+    ssize_t    n;
+    ngx_err_t  err;
+
+    ngx_log_debug3(NGX_LOG_DEBUG_CORE, file->log, 0,
+                   "writev: %d, %uz, %O", file->fd, vec->size, offset);
+
+#if (NGX_HAVE_PWRITEV)
+
+eintr:
+
+    n = pwritev(file->fd, vec->iovs, vec->count, offset);
+
+    if (n == -1) {
+        err = ngx_errno;
+
+        if (err == NGX_EINTR) {
+            ngx_log_debug0(NGX_LOG_DEBUG_CORE, file->log, err,
+                           "pwritev() was interrupted");
+            goto eintr;
+        }
+
+        ngx_log_error(NGX_LOG_CRIT, file->log, err,
+                      "pwritev() \"%s\" failed", file->name.data);
+        return NGX_ERROR;
+    }
+
+    if ((size_t) n != vec->size) {
+        ngx_log_error(NGX_LOG_CRIT, file->log, 0,
+                      "pwritev() \"%s\" has written only %z of %uz",
+                      file->name.data, n, vec->size);
+        return NGX_ERROR;
+    }
+
+#else
+
+    if (file->sys_offset != offset) {
+        if (lseek(file->fd, offset, SEEK_SET) == -1) {
             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
-                          "writev() \"%s\" failed", file->name.data);
+                          "lseek() \"%s\" failed", file->name.data);
             return NGX_ERROR;
         }
 
-        if ((size_t) n != size) {
-            ngx_log_error(NGX_LOG_CRIT, file->log, 0,
-                          "writev() \"%s\" has written only %z of %uz",
-                          file->name.data, n, size);
+        file->sys_offset = offset;
+    }
+
+eintr:
+
+    n = writev(file->fd, vec->iovs, vec->count);
+
+    if (n == -1) {
+        err = ngx_errno;
+
+        if (err == NGX_EINTR) {
+            ngx_log_debug0(NGX_LOG_DEBUG_CORE, file->log, err,
+                           "writev() was interrupted");
+            goto eintr;
+        }
+
+        ngx_log_error(NGX_LOG_CRIT, file->log, err,
+                      "writev() \"%s\" failed", file->name.data);
+        return NGX_ERROR;
+    }
+
+    if ((size_t) n != vec->size) {
+        ngx_log_error(NGX_LOG_CRIT, file->log, 0,
+                      "writev() \"%s\" has written only %z of %uz",
+                      file->name.data, n, vec->size);
+        return NGX_ERROR;
+    }
+
+    file->sys_offset += n;
+
+#endif
+
+    file->offset += n;
+
+    return n;
+}
+
+
+#if (NGX_THREADS)
+
+ssize_t
+ngx_thread_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl, off_t offset,
+    ngx_pool_t *pool)
+{
+    ngx_thread_task_t      *task;
+    ngx_thread_file_ctx_t  *ctx;
+
+    ngx_log_debug3(NGX_LOG_DEBUG_CORE, file->log, 0,
+                   "thread write chain: %d, %p, %O",
+                   file->fd, cl, offset);
+
+    task = file->thread_task;
+
+    if (task == NULL) {
+        task = ngx_thread_task_alloc(pool,
+                                     sizeof(ngx_thread_file_ctx_t));
+        if (task == NULL) {
             return NGX_ERROR;
         }
 
-        ngx_log_debug2(NGX_LOG_DEBUG_CORE, file->log, 0,
-                       "writev: %d, %z", file->fd, n);
+        file->thread_task = task;
+    }
 
-        file->sys_offset += n;
-        file->offset += n;
-        offset += n;
-        total += n;
+    ctx = task->ctx;
+
+    if (task->event.complete) {
+        task->event.complete = 0;
+
+        if (!ctx->write) {
+            ngx_log_error(NGX_LOG_ALERT, file->log, 0,
+                          "invalid thread call, write instead of read");
+            return NGX_ERROR;
+        }
+
+        if (ctx->err || ctx->nbytes == 0) {
+            ngx_log_error(NGX_LOG_CRIT, file->log, ctx->err,
+                          "pwritev() \"%s\" failed", file->name.data);
+            return NGX_ERROR;
+        }
+
+        file->offset += ctx->nbytes;
+        return ctx->nbytes;
+    }
+
+    task->handler = ngx_thread_write_chain_to_file_handler;
+
+    ctx->write = 1;
+
+    ctx->fd = file->fd;
+    ctx->chain = cl;
+    ctx->offset = offset;
+
+    if (file->thread_handler(task, file) != NGX_OK) {
+        return NGX_ERROR;
+    }
+
+    return NGX_AGAIN;
+}
+
+
+static void
+ngx_thread_write_chain_to_file_handler(void *data, ngx_log_t *log)
+{
+    ngx_thread_file_ctx_t *ctx = data;
+
+#if (NGX_HAVE_PWRITEV)
+
+    off_t          offset;
+    ssize_t        n;
+    ngx_err_t      err;
+    ngx_chain_t   *cl;
+    ngx_iovec_t    vec;
+    struct iovec   iovs[NGX_IOVS_PREALLOCATE];
+
+    vec.iovs = iovs;
+    vec.nalloc = NGX_IOVS_PREALLOCATE;
+
+    cl = ctx->chain;
+    offset = ctx->offset;
+
+    ctx->nbytes = 0;
+    ctx->err = 0;
 
+    do {
+        /* create the iovec and coalesce the neighbouring bufs */
+        cl = ngx_chain_to_iovec(&vec, cl);
+
+eintr:
+
+        n = pwritev(ctx->fd, iovs, vec.count, offset);
+
+        if (n == -1) {
+            err = ngx_errno;
+
+            if (err == NGX_EINTR) {
+                ngx_log_debug0(NGX_LOG_DEBUG_CORE, log, err,
+                               "pwritev() was interrupted");
+                goto eintr;
+            }
+
+            ctx->err = err;
+            return;
+        }
+
+        if ((size_t) n != vec.size) {
+            ctx->nbytes = 0;
+            return;
+        }
+
+        ctx->nbytes += n;
+        offset += n;
     } while (cl);
 
-    return total;
+#else
+
+    ctx->err = NGX_ENOSYS;
+    return;
+
+#endif
 }
 
+#endif /* NGX_THREADS */
+
 
 ngx_int_t
 ngx_set_file_time(u_char *name, ngx_fd_t fd, time_t s)