nginxtra 1.0.15.0

data/src/nginx/src/event/ngx_event_pipe.h

@@ -0,0 +1,95 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#ifndef _NGX_EVENT_PIPE_H_INCLUDED_
+#define _NGX_EVENT_PIPE_H_INCLUDED_
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_event.h>
+
+
+typedef struct ngx_event_pipe_s  ngx_event_pipe_t;
+
+typedef ngx_int_t (*ngx_event_pipe_input_filter_pt)(ngx_event_pipe_t *p,
+                                                    ngx_buf_t *buf);
+typedef ngx_int_t (*ngx_event_pipe_output_filter_pt)(void *data,
+                                                     ngx_chain_t *chain);
+
+
+struct ngx_event_pipe_s {
+    ngx_connection_t  *upstream;
+    ngx_connection_t  *downstream;
+
+    ngx_chain_t       *free_raw_bufs;
+    ngx_chain_t       *in;
+    ngx_chain_t      **last_in;
+
+    ngx_chain_t       *out;
+    ngx_chain_t      **last_out;
+
+    ngx_chain_t       *free;
+    ngx_chain_t       *busy;
+
+    /*
+     * the input filter i.e. that moves HTTP/1.1 chunks
+     * from the raw bufs to an incoming chain
+     */
+
+    ngx_event_pipe_input_filter_pt    input_filter;
+    void                             *input_ctx;
+
+    ngx_event_pipe_output_filter_pt   output_filter;
+    void                             *output_ctx;
+
+    unsigned           read:1;
+    unsigned           cacheable:1;
+    unsigned           single_buf:1;
+    unsigned           free_bufs:1;
+    unsigned           upstream_done:1;
+    unsigned           upstream_error:1;
+    unsigned           upstream_eof:1;
+    unsigned           upstream_blocked:1;
+    unsigned           downstream_done:1;
+    unsigned           downstream_error:1;
+    unsigned           cyclic_temp_file:1;
+
+    ngx_int_t          allocated;
+    ngx_bufs_t         bufs;
+    ngx_buf_tag_t      tag;
+
+    ssize_t            busy_size;
+
+    off_t              read_length;
+
+    off_t              max_temp_file_size;
+    ssize_t            temp_file_write_size;
+
+    ngx_msec_t         read_timeout;
+    ngx_msec_t         send_timeout;
+    ssize_t            send_lowat;
+
+    ngx_pool_t        *pool;
+    ngx_log_t         *log;
+
+    ngx_chain_t       *preread_bufs;
+    size_t             preread_size;
+    ngx_buf_t         *buf_to_file;
+
+    ngx_temp_file_t   *temp_file;
+
+    /* STUB */ int     num;
+};
+
+
+ngx_int_t ngx_event_pipe(ngx_event_pipe_t *p, ngx_int_t do_write);
+ngx_int_t ngx_event_pipe_copy_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf);
+ngx_int_t ngx_event_pipe_add_free_buf(ngx_event_pipe_t *p, ngx_buf_t *b);
+
+
+#endif /* _NGX_EVENT_PIPE_H_INCLUDED_ */

data/src/nginx/src/event/ngx_event_posted.c

@@ -0,0 +1,173 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_event.h>
+
+
+ngx_thread_volatile ngx_event_t  *ngx_posted_accept_events;
+ngx_thread_volatile ngx_event_t  *ngx_posted_events;
+
+#if (NGX_THREADS)
+ngx_mutex_t                      *ngx_posted_events_mutex;
+#endif
+
+
+void
+ngx_event_process_posted(ngx_cycle_t *cycle,
+    ngx_thread_volatile ngx_event_t **posted)
+{
+    ngx_event_t  *ev;
+
+    for ( ;; ) {
+
+        ev = (ngx_event_t *) *posted;
+
+        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
+                      "posted event %p", ev);
+
+        if (ev == NULL) {
+            return;
+        }
+
+        ngx_delete_posted_event(ev);
+
+        ev->handler(ev);
+    }
+}
+
+
+#if (NGX_THREADS) && !(NGX_WIN32)
+
+void
+ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
+{
+    ngx_int_t     i;
+#if 0
+    ngx_uint_t    busy;
+    ngx_event_t  *ev;
+
+    busy = 1;
+
+    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
+        return;
+    }
+
+    for (ev = (ngx_event_t *) ngx_posted_events; ev; ev = ev->next) {
+        if (*(ev->lock) == 0) {
+            busy = 0;
+            break;
+        }
+    }
+
+    ngx_mutex_unlock(ngx_posted_events_mutex);
+
+    if (busy) {
+        return;
+    }
+#endif
+
+    for (i = 0; i < ngx_threads_n; i++) {
+        if (ngx_threads[i].state == NGX_THREAD_FREE) {
+            ngx_cond_signal(ngx_threads[i].cv);
+            return;
+        }
+    }
+}
+
+
+ngx_int_t
+ngx_event_thread_process_posted(ngx_cycle_t *cycle)
+{
+    ngx_event_t  *ev;
+
+    for ( ;; ) {
+
+        ev = (ngx_event_t *) ngx_posted_events;
+
+        for ( ;; ) {
+
+            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
+                          "posted event %p", ev);
+
+            if (ev == NULL) {
+                return NGX_OK;
+            }
+
+            if (ngx_trylock(ev->lock) == 0) {
+
+                ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
+                               "posted event %p is busy", ev);
+
+                ev = ev->next;
+                continue;
+            }
+
+            if (ev->lock != ev->own_lock) {
+                if (*(ev->own_lock)) {
+                    ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
+                             "the own lock of the posted event %p is busy", ev);
+                    ngx_unlock(ev->lock);
+                    ev = ev->next;
+                    continue;
+                }
+                *(ev->own_lock) = 1;
+            }
+
+            ngx_delete_posted_event(ev);
+
+            ev->locked = 1;
+
+            ev->ready |= ev->posted_ready;
+            ev->timedout |= ev->posted_timedout;
+            ev->pending_eof |= ev->posted_eof;
+#if (NGX_HAVE_KQUEUE)
+            ev->kq_errno |= ev->posted_errno;
+#endif
+            if (ev->posted_available) {
+                ev->available = ev->posted_available;
+            }
+
+            ev->posted_ready = 0;
+            ev->posted_timedout = 0;
+            ev->posted_eof = 0;
+#if (NGX_HAVE_KQUEUE)
+            ev->posted_errno = 0;
+#endif
+            ev->posted_available = 0;
+
+            ngx_mutex_unlock(ngx_posted_events_mutex);
+
+            ev->handler(ev);
+
+            ngx_mutex_lock(ngx_posted_events_mutex);
+
+            if (ev->locked) {
+                ngx_unlock(ev->lock);
+
+                if (ev->lock != ev->own_lock) {
+                    ngx_unlock(ev->own_lock);
+                }
+            }
+
+            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
+                           "posted event %p is done", ev);
+
+            break;
+        }
+    }
+}
+
+#else
+
+void
+ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
+{
+}
+
+#endif

data/src/nginx/src/event/ngx_event_posted.h

@@ -0,0 +1,75 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#ifndef _NGX_EVENT_POSTED_H_INCLUDED_
+#define _NGX_EVENT_POSTED_H_INCLUDED_
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_event.h>
+
+
+#if (NGX_THREADS)
+extern ngx_mutex_t  *ngx_posted_events_mutex;
+#endif
+
+
+#define ngx_locked_post_event(ev, queue)                                      \
+                                                                              \
+    if (ev->prev == NULL) {                                                   \
+        ev->next = (ngx_event_t *) *queue;                                    \
+        ev->prev = (ngx_event_t **) queue;                                    \
+        *queue = ev;                                                          \
+                                                                              \
+        if (ev->next) {                                                       \
+            ev->next->prev = &ev->next;                                       \
+        }                                                                     \
+                                                                              \
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0, "post event %p", ev);  \
+                                                                              \
+    } else  {                                                                 \
+        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                        \
+                       "update posted event %p", ev);                         \
+    }
+
+
+#define ngx_post_event(ev, queue)                                             \
+                                                                              \
+    ngx_mutex_lock(ngx_posted_events_mutex);                                  \
+    ngx_locked_post_event(ev, queue);                                         \
+    ngx_mutex_unlock(ngx_posted_events_mutex);
+
+
+#define ngx_delete_posted_event(ev)                                           \
+                                                                              \
+    *(ev->prev) = ev->next;                                                   \
+                                                                              \
+    if (ev->next) {                                                           \
+        ev->next->prev = ev->prev;                                            \
+    }                                                                         \
+                                                                              \
+    ev->prev = NULL;                                                          \
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,                            \
+                   "delete posted event %p", ev);
+
+
+
+void ngx_event_process_posted(ngx_cycle_t *cycle,
+    ngx_thread_volatile ngx_event_t **posted);
+void ngx_wakeup_worker_thread(ngx_cycle_t *cycle);
+
+#if (NGX_THREADS)
+ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle);
+#endif
+
+
+extern ngx_thread_volatile ngx_event_t  *ngx_posted_accept_events;
+extern ngx_thread_volatile ngx_event_t  *ngx_posted_events;
+
+
+#endif /* _NGX_EVENT_POSTED_H_INCLUDED_ */

data/src/nginx/src/event/ngx_event_timer.c

@@ -0,0 +1,159 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <ngx_event.h>
+
+
+#if (NGX_THREADS)
+ngx_mutex_t  *ngx_event_timer_mutex;
+#endif
+
+
+ngx_thread_volatile ngx_rbtree_t  ngx_event_timer_rbtree;
+static ngx_rbtree_node_t          ngx_event_timer_sentinel;
+
+/*
+ * the event timer rbtree may contain the duplicate keys, however,
+ * it should not be a problem, because we use the rbtree to find
+ * a minimum timer value only
+ */
+
+ngx_int_t
+ngx_event_timer_init(ngx_log_t *log)
+{
+    ngx_rbtree_init(&ngx_event_timer_rbtree, &ngx_event_timer_sentinel,
+                    ngx_rbtree_insert_timer_value);
+
+#if (NGX_THREADS)
+
+    if (ngx_event_timer_mutex) {
+        ngx_event_timer_mutex->log = log;
+        return NGX_OK;
+    }
+
+    ngx_event_timer_mutex = ngx_mutex_init(log, 0);
+    if (ngx_event_timer_mutex == NULL) {
+        return NGX_ERROR;
+    }
+
+#endif
+
+    return NGX_OK;
+}
+
+
+ngx_msec_t
+ngx_event_find_timer(void)
+{
+    ngx_msec_int_t      timer;
+    ngx_rbtree_node_t  *node, *root, *sentinel;
+
+    if (ngx_event_timer_rbtree.root == &ngx_event_timer_sentinel) {
+        return NGX_TIMER_INFINITE;
+    }
+
+    ngx_mutex_lock(ngx_event_timer_mutex);
+
+    root = ngx_event_timer_rbtree.root;
+    sentinel = ngx_event_timer_rbtree.sentinel;
+
+    node = ngx_rbtree_min(root, sentinel);
+
+    ngx_mutex_unlock(ngx_event_timer_mutex);
+
+    timer = (ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_msec;
+
+    return (ngx_msec_t) (timer > 0 ? timer : 0);
+}
+
+
+void
+ngx_event_expire_timers(void)
+{
+    ngx_event_t        *ev;
+    ngx_rbtree_node_t  *node, *root, *sentinel;
+
+    sentinel = ngx_event_timer_rbtree.sentinel;
+
+    for ( ;; ) {
+
+        ngx_mutex_lock(ngx_event_timer_mutex);
+
+        root = ngx_event_timer_rbtree.root;
+
+        if (root == sentinel) {
+            return;
+        }
+
+        node = ngx_rbtree_min(root, sentinel);
+
+        /* node->key <= ngx_current_time */
+
+        if ((ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_msec <= 0)
+        {
+            ev = (ngx_event_t *) ((char *) node - offsetof(ngx_event_t, timer));
+
+#if (NGX_THREADS)
+
+            if (ngx_threaded && ngx_trylock(ev->lock) == 0) {
+
+                /*
+                 * We cannot change the timer of the event that is being
+                 * handled by another thread.  And we cannot easy walk
+                 * the rbtree to find next expired timer so we exit the loop.
+                 * However, it should be a rare case when the event that is
+                 * being handled has an expired timer.
+                 */
+
+                ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
+                               "event %p is busy in expire timers", ev);
+                break;
+            }
+#endif
+
+            ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
+                           "event timer del: %d: %M",
+                           ngx_event_ident(ev->data), ev->timer.key);
+
+            ngx_rbtree_delete(&ngx_event_timer_rbtree, &ev->timer);
+
+            ngx_mutex_unlock(ngx_event_timer_mutex);
+
+#if (NGX_DEBUG)
+            ev->timer.left = NULL;
+            ev->timer.right = NULL;
+            ev->timer.parent = NULL;
+#endif
+
+            ev->timer_set = 0;
+
+#if (NGX_THREADS)
+            if (ngx_threaded) {
+                ev->posted_timedout = 1;
+
+                ngx_post_event(ev, &ngx_posted_events);
+
+                ngx_unlock(ev->lock);
+
+                continue;
+            }
+#endif
+
+            ev->timedout = 1;
+
+            ev->handler(ev);
+
+            continue;
+        }
+
+        break;
+    }
+
+    ngx_mutex_unlock(ngx_event_timer_mutex);
+}