nginx-0.0.1-2003-12-08-23:48:12 import

3 files changed, 142 insertions, 4 deletions

diff --git a/src/event/ngx_event.h b/src/event/ngx_event.h
index c2170250d..ee7ab0f43 100644
--- a/src/event/ngx_event.h
+++ b/src/event/ngx_event.h
@@ -36,9 +36,11 @@ struct ngx_event_s {
     /*
      * The inline of "ngx_rbtree_t  rbtree;".
      *
-     * It allows to pack rbtree_color and variuos event bit flags into
-     * the single int.  We also use "unsigned char" and then "usigned short"
-     * because otherwise MSVC 6.0 uses an additional int for bit flags.
+     * It allows to pack the rbtree_color and the variuos event bit flags into
+     * the single "int".  We also use "unsigned char" and then "usigned short"
+     * because otherwise MSVC 6.0 uses an additional "int" for the bit flags.
+     * We use "char rbtree_color" instead of "unsigned int rbtree_color:1"
+     * because it preserves the bits order on the big endian platforms.
      */
 
     ngx_int_t        rbtree_key;
diff --git a/src/event/ngx_event_accept.c b/src/event/ngx_event_accept.c
index ea63724e9..9a08e00f5 100644
--- a/src/event/ngx_event_accept.c
+++ b/src/event/ngx_event_accept.c
@@ -199,7 +199,14 @@ void ngx_event_accept(ngx_event_t *ev)
         rev->log = log;
         wev->log = log;
 
-        /* TODO: x86: MT: lock xadd, MP: lock xadd, shared */
+        /*
+         * In the multithreaded model the connection counter is updated by
+         * the main thread only that accept()s connections.
+         *
+         * TODO: MP: - allocated in a shared memory
+         *           - atomic increment (x86: lock xadd)
+         *             or protection by critical section or mutex
+         */
         c->number = ngx_connection_counter++;
 
         ngx_log_debug(ev->log, "accept: %d, %d" _ s _ c->number);
diff --git a/src/event/ngx_event_thread.c b/src/event/ngx_event_thread.c
new file mode 100644
index 000000000..527b49cd0
--- /dev/null
+++ b/src/event/ngx_event_thread.c
@@ -0,0 +1,129 @@
+
+volitile int  ngx_last_posted_event;
+
+
+typedef struct {
+    ngx_tid_t   tid;
+    ngx_cv_t    cv;
+} ngx_thread_data_t;
+
+static ngx_thread_data_t  *threead_data;
+
+
+
+
+
+{
+
+    err = ngx_thread_cond_wait(ngx_thread_data_cv, ngx_thread_data_mutex);
+
+    tid = ngx_thread_self();
+
+    for (i = 0; i < thread_data_n; i++) {
+        if (thread_data[i].tid == tid) {
+            cv = thread_data[i].cv;
+            break;
+        }
+    }
+
+    if (i == thread_data_n) {
+        error
+        return
+    }
+
+
+    for ( ;; ) {
+
+        err = ngx_thread_cond_wait(cv, ngx_posted_events_mutex);
+        if (err) {
+            ngx_log_error(NGX_ALERT, log, err,
+                          ngx_thread_cond_wait_n " failed, thread is exiting");
+            return;
+        }
+
+        for ( ;; ) {
+            ev = NULL;
+
+            for (i = ngx_last_posted_event; i > 0; i--) {
+                ev = ngx_posted_events[i];
+
+                if (ev == NULL) {
+                    continue;
+                }
+
+                err = ngx_thread_mutex_trylock(ev->mutex);
+
+                if (err == 0) {
+                    ngx_posted_events[i] = NULL;
+
+                    while (ngx_posted_events[ngx_last_posted_event] == NULL) {
+                        ngx_last_posted_event--;
+                    }
+
+                    break;
+                }
+
+                if (err == NGX_EBUSY) {
+                    ev = NULL;
+                    continue;
+                }
+
+                ngx_log_error(NGX_ALERT, log, err,
+                              ngx_thread_mutex_unlock_n " failed,
+                              thread is exiting");
+
+                ngx_worker_thread_error();
+                return;
+            }
+
+            err = ngx_thread_mutex_unlock(ngx_posted_events_mutex);
+            if (err) {
+                ngx_log_error(NGX_ALERT, log, err,
+                              ngx_thread_mutex_unlock_n
+                              " failed, thread exiting");
+                return;
+            }
+
+            if (ev == NULL) {
+                break;
+            }
+
+            ngx_event_handle_event(ev);
+
+            err = ngx_thread_mutex_unlock(ev->mutex);
+            if (err) {
+                ngx_log_error(NGX_ALERT, log, err,
+                              ngx_thread_mutex_unlock_n
+                              " failed, thread exiting");
+
+                ngx_worker_thread_error();
+                return;
+            }
+
+            err = ngx_thread_mutex_lock(ngx_posted_events_mutex);
+            if (err) {
+                ngx_log_error(NGX_ALERT, log, err,
+                              ngx_thread_mutex_lock_n
+                              " failed, thread exiting");
+                return;
+            }
+        }
+
+        if (restart) {
+            ngx_log_error(NGX_INFO, log, 0, "thread is exiting");
+            return;
+        }
+    }
+}
+
+ngx_worker_thread_error()
+{
+    ngx_err_t  err;
+
+    err = ngx_thread_mutex_unlock(ngx_posted_events_mutex);
+    if (err) {
+        ngx_log_error(NGX_ALERT, log, err,
+                      ngx_thread_mutex_unlock_n
+                      " failed, thread exiting");
+    }
+}