nginxtra 1.6.3.9 → 1.8.0.9

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

@@ -0,0 +1,174 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+/*
+ * All modern pthread mutex implementations try to acquire a lock
+ * atomically in userland before going to sleep in kernel.  Some
+ * spins before the sleeping.
+ *
+ * In Solaris since version 8 all mutex types spin before sleeping.
+ * The default spin count is 1000.  It can be overridden using
+ * _THREAD_ADAPTIVE_SPIN=100 environment variable.
+ *
+ * In MacOSX all mutex types spin to acquire a lock protecting a mutex's
+ * internals.  If the mutex is busy, thread calls Mach semaphore_wait().
+ *
+ *
+ * PTHREAD_MUTEX_NORMAL lacks deadlock detection and is the fastest
+ * mutex type.
+ *
+ *   Linux:    No spinning.  The internal name PTHREAD_MUTEX_TIMED_NP
+ *             remains from the times when pthread_mutex_timedlock() was
+ *             non-standard extension.  Alias name: PTHREAD_MUTEX_FAST_NP.
+ *   FreeBSD:  No spinning.
+ *
+ *
+ * PTHREAD_MUTEX_ERRORCHECK is usually as fast as PTHREAD_MUTEX_NORMAL
+ * yet has lightweight deadlock detection.
+ *
+ *   Linux:    No spinning.  The internal name: PTHREAD_MUTEX_ERRORCHECK_NP.
+ *   FreeBSD:  No spinning.
+ *
+ *
+ * PTHREAD_MUTEX_RECURSIVE allows recursive locking.
+ *
+ *   Linux:    No spinning.  The internal name: PTHREAD_MUTEX_RECURSIVE_NP.
+ *   FreeBSD:  No spinning.
+ *
+ *
+ * PTHREAD_MUTEX_ADAPTIVE_NP spins on SMP systems before sleeping.
+ *
+ *   Linux:    No deadlock detection.  Dynamically changes a spin count
+ *             for each mutex from 10 to 100 based on spin count taken
+ *             previously.
+ *   FreeBSD:  Deadlock detection.  The default spin count is 2000.
+ *             It can be overriden using LIBPTHREAD_SPINLOOPS environment
+ *             variable or by pthread_mutex_setspinloops_np().  If a lock
+ *             is still busy, sched_yield() can be called on both UP and
+ *             SMP systems.  The default yield loop count is zero, but
+ *             it can be set by LIBPTHREAD_YIELDLOOPS environment
+ *             variable or by pthread_mutex_setyieldloops_np().
+ *   Solaris:  No PTHREAD_MUTEX_ADAPTIVE_NP.
+ *   MacOSX:   No PTHREAD_MUTEX_ADAPTIVE_NP.
+ *
+ *
+ * PTHREAD_MUTEX_ELISION_NP is a Linux extension to elide locks using
+ * Intel Restricted Transactional Memory.  It is the most suitable for
+ * rwlock pattern access because it allows simultaneous reads without lock.
+ * Supported since glibc 2.18.
+ *
+ *
+ * PTHREAD_MUTEX_DEFAULT is default mutex type.
+ *
+ *   Linux:    PTHREAD_MUTEX_NORMAL.
+ *   FreeBSD:  PTHREAD_MUTEX_ERRORCHECK.
+ *   Solaris:  PTHREAD_MUTEX_NORMAL.
+ *   MacOSX:   PTHREAD_MUTEX_NORMAL.
+ */
+
+
+ngx_int_t
+ngx_thread_mutex_create(ngx_thread_mutex_t *mtx, ngx_log_t *log)
+{
+    ngx_err_t            err;
+    pthread_mutexattr_t  attr;
+
+    err = pthread_mutexattr_init(&attr);
+    if (err != 0) {
+        ngx_log_error(NGX_LOG_EMERG, log, err,
+                      "pthread_mutexattr_init() failed");
+        return NGX_ERROR;
+    }
+
+    err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
+    if (err != 0) {
+        ngx_log_error(NGX_LOG_EMERG, log, err,
+                      "pthread_mutexattr_settype"
+                      "(PTHREAD_MUTEX_ERRORCHECK) failed");
+        return NGX_ERROR;
+    }
+
+    err = pthread_mutex_init(mtx, &attr);
+    if (err != 0) {
+        ngx_log_error(NGX_LOG_EMERG, log, err,
+                      "pthread_mutex_init() failed");
+        return NGX_ERROR;
+    }
+
+    err = pthread_mutexattr_destroy(&attr);
+    if (err != 0) {
+        ngx_log_error(NGX_LOG_ALERT, log, err,
+                      "pthread_mutexattr_destroy() failed");
+    }
+
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
+                   "pthread_mutex_init(%p)", mtx);
+    return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_thread_mutex_destroy(ngx_thread_mutex_t *mtx, ngx_log_t *log)
+{
+    ngx_err_t  err;
+
+    err = pthread_mutex_destroy(mtx);
+    if (err != 0) {
+        ngx_log_error(NGX_LOG_ALERT, log, err,
+                      "pthread_mutex_destroy() failed");
+        return NGX_ERROR;
+    }
+
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
+                   "pthread_mutex_destroy(%p)", mtx);
+    return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_thread_mutex_lock(ngx_thread_mutex_t *mtx, ngx_log_t *log)
+{
+    ngx_err_t  err;
+
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
+                   "pthread_mutex_lock(%p) enter", mtx);
+
+    err = pthread_mutex_lock(mtx);
+    if (err == 0) {
+        return NGX_OK;
+    }
+
+    ngx_log_error(NGX_LOG_ALERT, log, err, "pthread_mutex_lock() failed");
+
+    return NGX_ERROR;
+}
+
+
+ngx_int_t
+ngx_thread_mutex_unlock(ngx_thread_mutex_t *mtx, ngx_log_t *log)
+{
+    ngx_err_t  err;
+
+    err = pthread_mutex_unlock(mtx);
+
+#if 0
+    ngx_time_update();
+#endif
+
+    if (err == 0) {
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
+                       "pthread_mutex_unlock(%p) exit", mtx);
+        return NGX_OK;
+    }
+
+    ngx_log_error(NGX_LOG_ALERT, log, err, "pthread_mutex_unlock() failed");
+
+    return NGX_ERROR;
+}

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

@@ -31,8 +31,10 @@ ngx_libc_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, u_char **encrypted)
     struct crypt_data   cd;
 
     cd.initialized = 0;
+#ifdef __GLIBC__
     /* work around the glibc bug */
     cd.current_salt[0] = ~salt[0];
+#endif
 
     value = crypt_r((char *) key, (char *) salt, &cd);
 
@@ -62,16 +64,6 @@ ngx_libc_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, u_char **encrypted)
     size_t      len;
     ngx_err_t   err;
 
-#if (NGX_THREADS && NGX_NONREENTRANT_CRYPT)
-
-    /* crypt() is a time consuming function, so we only try to lock */
-
-    if (ngx_mutex_trylock(ngx_crypt_mutex) != NGX_OK) {
-        return NGX_AGAIN;
-    }
-
-#endif
-
     value = crypt((char *) key, (char *) salt);
 
     if (value) {
@@ -79,25 +71,15 @@ ngx_libc_crypt(ngx_pool_t *pool, u_char *key, u_char *salt, u_char **encrypted)
 
         *encrypted = ngx_pnalloc(pool, len);
         if (*encrypted == NULL) {
-#if (NGX_THREADS && NGX_NONREENTRANT_CRYPT)
-            ngx_mutex_unlock(ngx_crypt_mutex);
-#endif
             return NGX_ERROR;
         }
 
         ngx_memcpy(*encrypted, value, len);
-#if (NGX_THREADS && NGX_NONREENTRANT_CRYPT)
-        ngx_mutex_unlock(ngx_crypt_mutex);
-#endif
         return NGX_OK;
     }
 
     err = ngx_errno;
 
-#if (NGX_THREADS && NGX_NONREENTRANT_CRYPT)
-    ngx_mutex_unlock(ngx_crypt_mutex);
-#endif
-
     ngx_log_error(NGX_LOG_CRIT, pool->log, err, "crypt() failed");
 
     return NGX_ERROR;

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

@@ -10,25 +10,15 @@
 #include <ngx_event.h>
 
 
-#if (IOV_MAX > 64)
-#define NGX_IOVS  64
-#else
-#define NGX_IOVS  IOV_MAX
-#endif
-
-
 ngx_chain_t *
 ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
 {
-    u_char        *prev;
-    ssize_t        n, size, sent;
+    ssize_t        n, sent;
     off_t          send, prev_send;
-    ngx_uint_t     eintr, complete;
-    ngx_err_t      err;
-    ngx_array_t    vec;
     ngx_chain_t   *cl;
     ngx_event_t   *wev;
-    struct iovec  *iov, iovs[NGX_IOVS];
+    ngx_iovec_t    vec;
+    struct iovec   iovs[NGX_IOVS_PREALLOCATE];
 
     wev = c->write;
 
@@ -55,131 +45,172 @@ ngx_writev_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
 
     send = 0;
 
-    vec.elts = iovs;
-    vec.size = sizeof(struct iovec);
-    vec.nalloc = NGX_IOVS;
-    vec.pool = c->pool;
+    vec.iovs = iovs;
+    vec.nalloc = NGX_IOVS_PREALLOCATE;
 
     for ( ;; ) {
-        prev = NULL;
-        iov = NULL;
-        eintr = 0;
-        complete = 0;
         prev_send = send;
 
-        vec.nelts = 0;
-
         /* create the iovec and coalesce the neighbouring bufs */
 
-        for (cl = in; cl && send < limit; cl = cl->next) {
+        cl = ngx_output_chain_to_iovec(&vec, in, limit - send, c->log);
 
-            if (ngx_buf_special(cl->buf)) {
-                continue;
-            }
+        if (cl == NGX_CHAIN_ERROR) {
+            return NGX_CHAIN_ERROR;
+        }
 
-#if 1
-            if (!ngx_buf_in_memory(cl->buf)) {
-                ngx_debug_point();
-            }
-#endif
+        if (cl && cl->buf->in_file) {
+            ngx_log_error(NGX_LOG_ALERT, c->log, 0,
+                          "file buf in writev "
+                          "t:%d r:%d f:%d %p %p-%p %p %O-%O",
+                          cl->buf->temporary,
+                          cl->buf->recycled,
+                          cl->buf->in_file,
+                          cl->buf->start,
+                          cl->buf->pos,
+                          cl->buf->last,
+                          cl->buf->file,
+                          cl->buf->file_pos,
+                          cl->buf->file_last);
+
+            ngx_debug_point();
+
+            return NGX_CHAIN_ERROR;
+        }
 
-            size = cl->buf->last - cl->buf->pos;
+        send += vec.size;
 
-            if (send + size > limit) {
-                size = (ssize_t) (limit - send);
-            }
+        n = ngx_writev(c, &vec);
 
-            if (prev == cl->buf->pos) {
-                iov->iov_len += size;
+        if (n == NGX_ERROR) {
+            return NGX_CHAIN_ERROR;
+        }
 
-            } else {
-                if (vec.nelts >= IOV_MAX) {
-                    break;
-                }
+        sent = (n == NGX_AGAIN) ? 0 : n;
 
-                iov = ngx_array_push(&vec);
-                if (iov == NULL) {
-                    return NGX_CHAIN_ERROR;
-                }
+        c->sent += sent;
 
-                iov->iov_base = (void *) cl->buf->pos;
-                iov->iov_len = size;
-            }
+        in = ngx_chain_update_sent(in, sent);
 
-            prev = cl->buf->pos + size;
-            send += size;
+        if (send - prev_send != sent) {
+            wev->ready = 0;
+            return in;
         }
 
-        n = writev(c->fd, vec.elts, vec.nelts);
+        if (send >= limit || in == NULL) {
+            return in;
+        }
+    }
+}
 
-        if (n == -1) {
-            err = ngx_errno;
 
-            switch (err) {
-            case NGX_EAGAIN:
-                break;
+ngx_chain_t *
+ngx_output_chain_to_iovec(ngx_iovec_t *vec, ngx_chain_t *in, size_t limit,
+    ngx_log_t *log)
+{
+    size_t         total, size;
+    u_char        *prev;
+    ngx_uint_t     n;
+    struct iovec  *iov;
 
-            case NGX_EINTR:
-                eintr = 1;
-                break;
+    iov = NULL;
+    prev = NULL;
+    total = 0;
+    n = 0;
 
-            default:
-                wev->error = 1;
-                (void) ngx_connection_error(c, err, "writev() failed");
-                return NGX_CHAIN_ERROR;
-            }
+    for ( /* void */ ; in && total < limit; in = in->next) {
 
-            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
-                           "writev() not ready");
+        if (ngx_buf_special(in->buf)) {
+            continue;
         }
 
-        sent = n > 0 ? n : 0;
-
-        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "writev: %z", sent);
+        if (in->buf->in_file) {
+            break;
+        }
 
-        if (send - prev_send == sent) {
-            complete = 1;
+        if (!ngx_buf_in_memory(in->buf)) {
+            ngx_log_error(NGX_LOG_ALERT, log, 0,
+                          "bad buf in output chain "
+                          "t:%d r:%d f:%d %p %p-%p %p %O-%O",
+                          in->buf->temporary,
+                          in->buf->recycled,
+                          in->buf->in_file,
+                          in->buf->start,
+                          in->buf->pos,
+                          in->buf->last,
+                          in->buf->file,
+                          in->buf->file_pos,
+                          in->buf->file_last);
+
+            ngx_debug_point();
+
+            return NGX_CHAIN_ERROR;
         }
 
-        c->sent += sent;
+        size = in->buf->last - in->buf->pos;
 
-        for (cl = in; cl; cl = cl->next) {
+        if (size > limit - total) {
+            size = limit - total;
+        }
 
-            if (ngx_buf_special(cl->buf)) {
-                continue;
-            }
+        if (prev == in->buf->pos) {
+            iov->iov_len += size;
 
-            if (sent == 0) {
+        } else {
+            if (n == vec->nalloc) {
                 break;
             }
 
-            size = cl->buf->last - cl->buf->pos;
+            iov = &vec->iovs[n++];
 
-            if (sent >= size) {
-                sent -= size;
-                cl->buf->pos = cl->buf->last;
+            iov->iov_base = (void *) in->buf->pos;
+            iov->iov_len = size;
+        }
 
-                continue;
-            }
+        prev = in->buf->pos + size;
+        total += size;
+    }
 
-            cl->buf->pos += sent;
+    vec->count = n;
+    vec->size = total;
 
-            break;
-        }
+    return in;
+}
 
-        if (eintr) {
-            continue;
-        }
 
-        if (!complete) {
-            wev->ready = 0;
-            return cl;
-        }
+ssize_t
+ngx_writev(ngx_connection_t *c, ngx_iovec_t *vec)
+{
+    ssize_t    n;
+    ngx_err_t  err;
 
-        if (send >= limit || cl == NULL) {
-            return cl;
-        }
+eintr:
+
+    n = writev(c->fd, vec->iovs, vec->count);
 
-        in = cl;
+    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
+                   "writev: %z of %uz", n, vec->size);
+
+    if (n == -1) {
+        err = ngx_errno;
+
+        switch (err) {
+        case NGX_EAGAIN:
+            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
+                           "writev() not ready");
+            return NGX_AGAIN;
+
+        case NGX_EINTR:
+            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
+                           "writev() was interrupted");
+            goto eintr;
+
+        default:
+            c->write->error = 1;
+            ngx_connection_error(c, err, "writev() failed");
+            return NGX_ERROR;
+        }
     }
+
+    return n;
 }