nginx-0.0.7-2004-06-28-20:05:02 import

diff --git a/src/core/ngx_atomic.h b/src/core/ngx_atomic.h
index bbf4a7685af256a26001da6d8e3f8252a1451bb2..a149ad28b4adfd4d3ec165bb5d6acdd7fd5e451b 100644 (file)
--- a/src/core/ngx_atomic.h
+++ b/src/core/ngx_atomic.h
@@ -72,13 +72,19 @@ static ngx_inline uint32_t ngx_atomic_cmp_set(ngx_atomic_t *lock,
 
 #define ngx_atomic_inc(p)       InterlockedIncrement((long *) p)
 #define ngx_atomic_dec(p)       InterlockedDecrement((long *) p)
-/* STUB */
-#define ngx_atomic_cmp_set(lock, old, set)   1
-#if 0
-#define ngx_atomic_cmp_set(lock, old, set)                                   \
-                                  InterlockedCompareExchange(lock, set, old)
-#endif
 
+#if defined(__WATCOMC__) || defined(__BORLANDC__)
+
+#define ngx_atomic_cmp_set(lock, old, set)                                    \
+     (InterlockedCompareExchange((long *) lock, set, old) == old)
+
+#else
+
+#define ngx_atomic_cmp_set(lock, old, set)                                    \
+     (InterlockedCompareExchange((void **) lock, (void *) set, (void *) old)  \
+      == (void *) old)
+
+#endif
 
 #else
 
@@ -93,18 +99,8 @@ typedef volatile uint32_t  ngx_atomic_t;
 #endif
 
 
-static ngx_inline ngx_int_t ngx_trylock(ngx_atomic_t *lock)
-{
-    if (*lock) {
-        return NGX_BUSY;
-    }
-
-    if (ngx_atomic_cmp_set(lock, 0, 1)) {
-        return NGX_OK;
-    }
-
-    return NGX_BUSY;
-}
+#define ngx_trylock(lock)  (*(lock) == 0 && ngx_atomic_cmp_set(lock, 0, 1))
+#define ngx_unlock(lock)    *(lock) = 0
 
 
 #endif /* _NGX_ATOMIC_H_INCLUDED_ */

diff --git a/src/core/ngx_times.h b/src/core/ngx_times.h
index 1fb712d44f90249061fc7d5c74f8a00b7e674870..b5b6eb60a80c4eea2030e3d7f18f52239f920d32 100644 (file)
--- a/src/core/ngx_times.h
+++ b/src/core/ngx_times.h
@@ -28,9 +28,9 @@ extern volatile time_t     ngx_cached_time;
 #endif
 
 
-extern volatile ngx_str_t  ngx_cached_err_log_time;
-extern volatile ngx_str_t  ngx_cached_http_time;
-extern volatile ngx_str_t  ngx_cached_http_log_time;
+extern ngx_thread_volatile ngx_str_t  ngx_cached_err_log_time;
+extern ngx_thread_volatile ngx_str_t  ngx_cached_http_time;
+extern ngx_thread_volatile ngx_str_t  ngx_cached_http_log_time;
 
 extern ngx_epoch_msec_t    ngx_start_msec;
 

diff --git a/src/event/modules/ngx_kqueue_module.c b/src/event/modules/ngx_kqueue_module.c
index 001d6a85ebb09314e32541e96834ba88b7deb1aa..99370ac425c17392eedc7d9847979d1b471d268a 100644 (file)
--- a/src/event/modules/ngx_kqueue_module.c
+++ b/src/event/modules/ngx_kqueue_module.c
@@ -361,11 +361,10 @@ static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle)
             return NGX_ERROR;
         }
 
-         /*
-          * TODO: if timer is NGX_TIMER_INFINITE and any worker thread
-          *       is still busy then set the configurable 500ms timeout
-          *       to wake up another worker thread
-          */
+        if (timer == NGX_TIMER_INFINITE || timer > 500) {
+            timer = 500;
+            break;
+        }
 
 #endif
 
@@ -461,12 +460,17 @@ static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle)
         }
     }
 
-    if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
-        ngx_accept_mutex_unlock();
-        return NGX_ERROR;
-    }
+    if (events > 0) {
+        if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
+            ngx_accept_mutex_unlock();
+            return NGX_ERROR;
+        }
 
-    lock = 1;
+        lock = 1;
+
+    } else {
+        lock =0;
+    }
 
     for (i = 0; i < events; i++) {
 
@@ -588,7 +592,7 @@ static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle)
 
     if (ngx_posted_events) {
         if (ngx_threaded) {
-            ngx_cv_signal(ngx_posted_events_cv);
+            ngx_cond_signal(ngx_posted_events_cv);
 
         } else {
             ngx_event_process_posted(cycle);

diff --git a/src/event/ngx_event_posted.c b/src/event/ngx_event_posted.c
index 478744341495dcdba369859c36ffe7cbb1c1f7fe..b103159b013d2d305dcf4e1bab88cd9c8fd07bbc 100644 (file)
--- a/src/event/ngx_event_posted.c
+++ b/src/event/ngx_event_posted.c
@@ -8,7 +8,7 @@ ngx_thread_volatile ngx_event_t  *ngx_posted_events;
 
 #if (NGX_THREADS)
 ngx_mutex_t                      *ngx_posted_events_mutex;
-ngx_cv_t                         *ngx_posted_events_cv;
+ngx_cond_t                       *ngx_posted_events_cv;
 #endif
 
 
@@ -76,7 +76,7 @@ ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle)
                 return NGX_OK;
             }
 
-            if (ngx_trylock(ev->lock) == NGX_BUSY) {
+            if (ngx_trylock(ev->lock) == 0) {
 
                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                                "posted event " PTR_FMT " is busy", ev);
@@ -112,7 +112,7 @@ ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle)
 
             ev->event_handler(ev);
 
-            *(ev->lock) = 0;
+            ngx_unlock(ev->lock);
 
             if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
                 return NGX_ERROR;

diff --git a/src/event/ngx_event_posted.h b/src/event/ngx_event_posted.h
index b060cc6d9da94e0980769465c5c45f503659f710..ba484fac02c184f502c80921f9639c48ad3cfa19 100644 (file)
--- a/src/event/ngx_event_posted.h
+++ b/src/event/ngx_event_posted.h
@@ -22,7 +22,7 @@ extern ngx_thread_volatile ngx_event_t  *ngx_posted_events;
 ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle);
 
 extern ngx_mutex_t                      *ngx_posted_events_mutex;
-extern ngx_cv_t                         *ngx_posted_events_cv;
+extern ngx_cond_t                       *ngx_posted_events_cv;
 #endif
 
 

diff --git a/src/event/ngx_event_timer.c b/src/event/ngx_event_timer.c
index fb401cf84d69058d6a417efd0892a2cab1c9c5be..0f6de679308c133b5761ca27888bfc43817d6021 100644 (file)
--- a/src/event/ngx_event_timer.c
+++ b/src/event/ngx_event_timer.c
@@ -71,7 +71,7 @@ void ngx_event_expire_timers(ngx_msec_t timer)
     for ( ;; ) {
 
         if (ngx_event_timer_rbtree == &ngx_event_timer_sentinel) {
-            break;
+            return;
         }
 
         if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
@@ -81,17 +81,35 @@ void ngx_event_expire_timers(ngx_msec_t timer)
         node = ngx_rbtree_min((ngx_rbtree_t *) ngx_event_timer_rbtree,
                               &ngx_event_timer_sentinel);
 
-        ngx_mutex_unlock(ngx_event_timer_mutex);
-
         if (node->key <= (ngx_msec_t)
                          (ngx_old_elapsed_msec + timer) / NGX_TIMER_RESOLUTION)
         {
             ev = (ngx_event_t *)
                            ((char *) node - offsetof(ngx_event_t, rbtree_key));
 
-            ngx_del_timer(ev);
+            if (ngx_trylock(ev->lock) == 0) {
+                break;
+            }
+
+            ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
+                           "event timer del: %d: %d",
+                            ngx_event_ident(ev->data), ev->rbtree_key);
+
+            ngx_rbtree_delete((ngx_rbtree_t **) &ngx_event_timer_rbtree,
+                              &ngx_event_timer_sentinel,
+                              (ngx_rbtree_t *) &ev->rbtree_key);
+
+            ngx_mutex_unlock(ngx_event_timer_mutex);
 
+#if (NGX_DEBUG)
+            ev->rbtree_left = NULL;
+            ev->rbtree_right = NULL;
+            ev->rbtree_parent = NULL;
+#endif
+
+            ev->timer_set = 0;
             ev->timedout = 1;
+            ngx_unlock(ev->lock);
 
             if (ngx_threaded) {
                 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
@@ -107,7 +125,8 @@ void ngx_event_expire_timers(ngx_msec_t timer)
             ev->event_handler(ev);
             continue;
         }
-
         break;
     }
+
+    ngx_mutex_unlock(ngx_event_timer_mutex);
 }

diff --git a/src/event/ngx_event_timer.h b/src/event/ngx_event_timer.h
index e7e49d28d83f1be8ae8fe9451702b1e5addecba1..0ff640539a12133c0a9da0d5a2ebbe6806ba2e03 100644 (file)
--- a/src/event/ngx_event_timer.h
+++ b/src/event/ngx_event_timer.h
@@ -42,19 +42,15 @@ ngx_inline static void ngx_event_del_timer(ngx_event_t *ev)
                    "event timer del: %d: %d",
                     ngx_event_ident(ev->data), ev->rbtree_key);
 
-#if (NGX_THREADS)
     if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
         return;
     }
-#endif
 
     ngx_rbtree_delete((ngx_rbtree_t **) &ngx_event_timer_rbtree,
                       &ngx_event_timer_sentinel,
                       (ngx_rbtree_t *) &ev->rbtree_key);
 
-#if (NGX_THREADS)
     ngx_mutex_unlock(ngx_event_timer_mutex);
-#endif
 
 #if (NGX_DEBUG)
     ev->rbtree_left = NULL;
@@ -101,19 +97,15 @@ ngx_inline static void ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
                    "event timer add: %d: %d",
                     ngx_event_ident(ev->data), ev->rbtree_key);
 
-#if (NGX_THREADS)
     if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
         return;
     }
-#endif
 
     ngx_rbtree_insert((ngx_rbtree_t **) &ngx_event_timer_rbtree,
                       &ngx_event_timer_sentinel,
                       (ngx_rbtree_t *) &ev->rbtree_key);
 
-#if (NGX_THREADS)
     ngx_mutex_unlock(ngx_event_timer_mutex);
-#endif
 
     ev->timer_set = 1;
 }

diff --git a/src/os/unix/ngx_freebsd_rfork_thread.c b/src/os/unix/ngx_freebsd_rfork_thread.c
index c4cd30205dd590ecfa3e594493d21ba43ff48ef1..73c5152214c5facb3ab129a1b6b0afa3742e9ad2 100644 (file)
--- a/src/os/unix/ngx_freebsd_rfork_thread.c
+++ b/src/os/unix/ngx_freebsd_rfork_thread.c
@@ -459,6 +459,11 @@ ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
 
     /* free the mutex */
 
+#if 0
+    ngx_log_debug2(NGX_LOG_DEBUG_CORE, m->log, 0,
+                   "unlock mutex " PTR_FMT " lock:%X", m, old);
+#endif
+
     for ( ;; ) {
         lock = old & ~NGX_MUTEX_LOCK_BUSY;
 
@@ -524,33 +529,29 @@ ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
 }
 
 
-ngx_cv_t *ngx_cv_init(ngx_log_t *log)
+ngx_cond_t *ngx_cond_init(ngx_log_t *log)
 {
-    ngx_cv_t     *cv;
-    u_short       val[2];
+    ngx_cond_t   *cv;
     union semun   op;
 
-    if (!(cv = ngx_alloc(sizeof(ngx_cv_t), log))) {
+    if (!(cv = ngx_alloc(sizeof(ngx_cond_t), log))) {
         return NULL;
     }
 
-    cv->mutex.lock = 0;
-    cv->mutex.log = log;
+    cv->log = log;
 
-    cv->mutex.semid = semget(IPC_PRIVATE, 2, SEM_R|SEM_A);
-    if (cv->mutex.semid == -1) {
+    cv->semid = semget(IPC_PRIVATE, 2, SEM_R|SEM_A);
+    if (cv->semid == -1) {
         ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "semget() failed");
         return NULL;
     }
 
-    val[0] = 0;
-    val[1] = 0;
-    op.array = val;
+    op.val = 0;
 
-    if (semctl(cv->mutex.semid, 0, SETALL, op) == -1) {
-        ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "semctl(SETALL) failed");
+    if (semctl(cv->semid, 0, SETVAL, op) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "semctl(SETVAL) failed");
 
-        if (semctl(cv->mutex.semid, 0, IPC_RMID) == -1) {
+        if (semctl(cv->semid, 0, IPC_RMID) == -1) {
             ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
                           "semctl(IPC_RMID) failed");
         }
@@ -562,10 +563,10 @@ ngx_cv_t *ngx_cv_init(ngx_log_t *log)
 }
 
 
-void ngx_cv_done(ngx_cv_t *cv)
+void ngx_cond_done(ngx_cond_t *cv)
 {
-    if (semctl(cv->mutex.semid, 0, IPC_RMID) == -1) {
-        ngx_log_error(NGX_LOG_ALERT, cv->mutex.log, ngx_errno,
+    if (semctl(cv->semid, 0, IPC_RMID) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, cv->log, ngx_errno,
                       "semctl(IPC_RMID) failed");
     }
 
@@ -573,56 +574,52 @@ void ngx_cv_done(ngx_cv_t *cv)
 }
 
 
-ngx_int_t ngx_cv_wait(ngx_cv_t *cv)
+ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
 {
-    struct sembuf  op[2];
+    struct sembuf  op;
 
-    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->mutex.log, 0,
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
                    "cv " PTR_FMT " wait", cv);
 
-    op[0].sem_num = 0;
-    op[0].sem_op = -1;
-    op[0].sem_flg = SEM_UNDO;
+    op.sem_num = 0;
+    op.sem_op = -1;
+    op.sem_flg = SEM_UNDO;
 
-    op[1].sem_num = 1;
-    op[1].sem_op = -1;
-    op[1].sem_flg = SEM_UNDO;
-
-    if (semop(cv->mutex.semid, op, 2) == -1) {
-        ngx_log_error(NGX_LOG_ALERT, cv->mutex.log, ngx_errno,
+    if (semop(cv->semid, &op, 1) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, cv->log, ngx_errno,
                       "semop() failed while waiting on cv " PTR_FMT, cv);
         return NGX_ERROR;
     }
 
-    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->mutex.log, 0,
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
                    "cv " PTR_FMT " is waked up", cv);
 
+    if (ngx_mutex_lock(m) == NGX_ERROR) {
+        return NGX_ERROR;
+    }
+
     return NGX_OK;
 }
 
 
-ngx_int_t ngx_cv_signal(ngx_cv_t *cv)
+ngx_int_t ngx_cond_signal(ngx_cond_t *cv)
 {
-    struct sembuf  op[2];
+    struct sembuf  op;
 
-    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->mutex.log, 0,
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
                    "cv " PTR_FMT " to signal", cv);
 
-    op[0].sem_num = 0;
-    op[0].sem_op = 1;
-    op[0].sem_flg = SEM_UNDO;
-
-    op[1].sem_num = 1;
-    op[1].sem_op = 1;
-    op[1].sem_flg = SEM_UNDO;
+    op.sem_num = 0;
+    op.sem_op = 1;
+    op.sem_flg = SEM_UNDO;
 
-    if (semop(cv->mutex.semid, op, 2) == -1) {
-        ngx_log_error(NGX_LOG_ALERT, cv->mutex.log, ngx_errno,
+    if (semop(cv->semid, &op, 1) == -1) {
+        ngx_log_error(NGX_LOG_ALERT, cv->log, ngx_errno,
                       "semop() failed while signaling cv " PTR_FMT, cv);
         return NGX_ERROR;
     }
 
-    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->mutex.log, 0,
+    ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0,
                    "cv " PTR_FMT " is signaled", cv);
 
     return NGX_OK;

diff --git a/src/os/unix/ngx_process_cycle.c b/src/os/unix/ngx_process_cycle.c
index 6d7fe06c21e5d21a0936f42c45ebbd769d1d5cf0..dd50bba2518cab103b92ae61c65f8a8fad83bf20 100644 (file)
--- a/src/os/unix/ngx_process_cycle.c
+++ b/src/os/unix/ngx_process_cycle.c
@@ -625,14 +625,12 @@ static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
         exit(2);
     }
 
-    if (!(ngx_posted_events_cv = ngx_cv_init(cycle->log))) {
+    if (!(ngx_posted_events_cv = ngx_cond_init(cycle->log))) {
         /* fatal */
         exit(2);
     }
 
-    ngx_posted_events_mutex = &ngx_posted_events_cv->mutex;
-
-    for (i = 0; i < 1; i++) {
+    for (i = 0; i < 2; i++) {
         if (ngx_create_thread(&tid, ngx_worker_thread_cycle,
                               cycle, cycle->log) != 0)
         {
@@ -780,7 +778,9 @@ int ngx_worker_thread_cycle(void *data)
     ngx_setproctitle("worker thread");
 
     for ( ;; ) {
-        if (ngx_cv_wait(ngx_posted_events_cv) == NGX_ERROR) {
+        if (ngx_cond_wait(ngx_posted_events_cv, ngx_posted_events_mutex)
+                                                                  == NGX_ERROR)
+        {
             return 1;
         }
 

diff --git a/src/os/unix/ngx_thread.h b/src/os/unix/ngx_thread.h
index 6412fe8b2964d44fcddc6e57c3487b436d6f882b..c91ff99864abeac490f43eef0e2e9135b00c54d7 100644 (file)
--- a/src/os/unix/ngx_thread.h
+++ b/src/os/unix/ngx_thread.h
@@ -37,8 +37,9 @@ typedef volatile struct {
 
 
 typedef struct {
-    ngx_mutex_t   mutex;
-} ngx_cv_t;
+    int           semid;
+    ngx_log_t    *log;
+} ngx_cond_t;
 
 
 #define ngx_thread_sigmask(how, set, oset)                         \
@@ -107,10 +108,10 @@ ngx_int_t ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try);
 ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m);
 
 
-ngx_cv_t *ngx_cv_init(ngx_log_t *log);
-void ngx_cv_done(ngx_cv_t *cv);
-ngx_int_t ngx_cv_wait(ngx_cv_t *cv);
-ngx_int_t ngx_cv_signal(ngx_cv_t *cv);
+ngx_cond_t *ngx_cond_init(ngx_log_t *log);
+void ngx_cond_done(ngx_cond_t *cv);
+ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m);
+ngx_int_t ngx_cond_signal(ngx_cond_t *cv);
 
 
 #else /* !NGX_THREADS */

diff --git a/src/os/win32/ngx_win32_config.h b/src/os/win32/ngx_win32_config.h
index 72e5c5e795920ce840a0ca4308bafbbd2986d249..c48fb38234b33c4eac64ea2ff67738548125e191 100644 (file)
--- a/src/os/win32/ngx_win32_config.h
+++ b/src/os/win32/ngx_win32_config.h
@@ -104,6 +104,8 @@ typedef int               sig_atomic_t;
 typedef uint32_t          ngx_atomic_t;
 
 
+#define TIME_T_LEN        sizeof("-2147483648") - 1
+
 #define OFF_T_FMT         "%I64d"
 #define SIZE_T_FMT        "%d"
 #define SIZE_T_X_FMT      "%x"