mirror/nginx
1
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2025-06-07 17:52:38 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Igor Sysoev 2004-06-28 16:05:02 +00:00
parent c02473048c
commit b14b910202
11 changed files with 114 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/core/ngx_atomic.h
View File

@ -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_ */

6
src/core/ngx_times.h
View File

@ -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;

26
src/event/modules/ngx_kqueue_module.c
View File

@ -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);

6
src/event/ngx_event_posted.c
View File

@ -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;

2
src/event/ngx_event_posted.h
View File

@ -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

29
src/event/ngx_event_timer.c
View File

@ -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);
}

8
src/event/ngx_event_timer.h
View File

@ -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;
}

83
src/os/unix/ngx_freebsd_rfork_thread.c
View File

@ -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.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 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;

10
src/os/unix/ngx_process_cycle.c
View File

@ -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;
}

13
src/os/unix/ngx_thread.h
View File

@ -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 */

2
src/os/win32/ngx_win32_config.h
View File

@ -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"