mirror of
https://github.com/nginx/nginx.git
synced 2025-01-03 12:47:21 -06:00
c2068d08f0
*) Change: the "bl" and "af" parameters of the "listen" directive was
renamed to the "backlog" and "accept_filter".
*) Feature: the "rcvbuf" and "sndbuf" parameters of the "listen"
directive.
*) Change: the "$msec" log parameter does not require now the
additional the gettimeofday() system call.
*) Feature: the -t switch now tests the "listen" directives.
*) Bugfix: if the invalid address was specified in the "listen"
directive, then after the -HUP signal nginx left an open socket in
the CLOSED state.
*) Bugfix: the mime type may be incorrectly set to default value for
index file with variable in the name; the bug had appeared in 0.3.0.
*) Feature: the "timer_resolution" directive.
*) Feature: the millisecond "$upstream_response_time" log parameter.
*) Bugfix: a temporary file with client request body now is removed
just after the response header was transferred to a client.
*) Bugfix: OpenSSL 0.9.6 compatibility.
*) Bugfix: the SSL certificate and key file paths could not be relative.
*) Bugfix: the "ssl_prefer_server_ciphers" directive did not work in
the ngx_imap_ssl_module.
*) Bugfix: the "ssl_protocols" directive allowed to specify the single
protocol only.
173 lines
3.5 KiB
C
173 lines
3.5 KiB
C
|
|
/*
|
|
* Copyright (C) Igor Sysoev
|
|
*/
|
|
|
|
|
|
#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
|