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.3.3-RELEASE import

Browse Source 
*) 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.
This commit is contained in:
Igor Sysoev 2005-10-19 12:33:58 +00:00
parent 8743f92a1a
commit c2068d08f0
86 changed files with 1856 additions and 1762 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
auto/cc/gcc
View File

@ -37,7 +37,7 @@ fi
case "$NGX_PLATFORM" in
*:sun4u)
# "-mcpu=v9" enables the "casxa" assembler instruction
# "-mcpu=v9" enables the "casa" assembler instruction
CFLAGS="$CFLAGS -mcpu=v9"
;;
@ -134,6 +134,8 @@ case "$NGX_GCC_VER" in
# we have a lot of the unused function arguments
CFLAGS="$CFLAGS -Wno-unused-parameter"
CFLAGS="$CFLAGS -Wno-unused-function"
CFLAGS="$CFLAGS -Wunused-variable"
CFLAGS="$CFLAGS -Wunused-value"
#CFLAGS="$CFLAGS -Wunreachable-code"
;;

24
auto/cc/icc
View File

@ -22,8 +22,18 @@ CFLAGS="$CFLAGS -Ob2"
# single-file IP optimizations
#IPO="-ip"
# multi-file IP optimizations
IPO="-ipo -ipo_obj"
case "$NGX_ICC_VER" in
9.*)
IPO="-ipo"
;;
*)
IPO="-ipo -ipo_obj"
;;
esac
CFLAGS="$CFLAGS $IPO"
CORE_LINK="$CORE_LINK $IPO"
CORE_LINK="$CORE_LINK -opt_report_file=$NGX_OBJS/opt_report_file"
@ -72,7 +82,7 @@ CFLAGS="$CFLAGS -wd171"
CFLAGS="$CFLAGS -wd181"
# zero used for undefined preprocessing identifier
CFLAGS="$CFLAGS -wd193"
#the format string ends before this argument
# the format string ends before this argument
CFLAGS="$CFLAGS -wd268"
# invalid format string conversion
CFLAGS="$CFLAGS -wd269"
@ -92,15 +102,17 @@ CFLAGS="$CFLAGS -wd981"
CFLAGS="$CFLAGS -wd1418"
# external declaration in primary source file
CFLAGS="$CFLAGS -wd1419"
# explicit conversion of a 64-bit integral type to a smaller integral type
CFLAGS="$CFLAGS -wd1683"
# conversion from pointer to same-sized integral type, warning on offsetof()
CFLAGS="$CFLAGS -wd1684"
case "$NGX_ICC_VER" in
8.* | 9.*)
# "cc" clobber ignored, warnings for Liunx's htons()
CFLAGS="$CFLAGS -wd1469"
# explicit conversion of a 64-bit integral type to a smaller
# integral type
CFLAGS="$CFLAGS -wd1683"
# conversion from pointer to same-sized integral type,
# warning on offsetof()
CFLAGS="$CFLAGS -wd1684"
# STUB
# non-POD class type passed through ellipsis, Linux only ?

18
auto/cc/name
View File

@ -11,47 +11,47 @@ if [ $CC = cl ]; then
2>&1 >/dev/null`; then
NGX_CC_NAME=msvc7
echo " using Microsoft Visual C++ 7 compiler"
echo " Microsoft Visual C++ 7 compiler"
else
NGX_CC_NAME=msvc
echo " using Microsoft Visual C++ compiler"
echo " Microsoft Visual C++ compiler"
fi
else
if [ $CC = wcl386 ]; then
NGX_CC_NAME=owc
echo " using Open Watcom C compiler"
echo " Open Watcom C compiler"
else
if [ $CC = bcc32 ]; then
NGX_CC_NAME=bcc
echo " using Borland C++ compiler"
echo " Borland C++ compiler"
else
if `$CC -v 2>&1 | grep 'gcc version' 2>&1 >/dev/null`; then
NGX_CC_NAME=gcc
echo " using GNU C compiler"
echo " GNU C compiler"
else
if `$CC -V 2>&1 | grep '^Intel(R) C' 2>&1 >/dev/null`; then
NGX_CC_NAME=icc
echo " using Intel C++ compiler"
echo " Intel C++ compiler"
else
if `$CC -V 2>&1 | grep 'Sun C' 2>&1 >/dev/null`; then
NGX_CC_NAME=sunc
echo " using Sun C compiler"
echo " Sun C compiler"
else
if `$CC -V 2>&1 | grep '^Compaq C' 2>&1 >/dev/null`; then
NGX_CC_NAME=ccc
echo " using Compaq C compiler"
echo " Compaq C compiler"
else
if `$CC -V 2>&1 | grep '^aCC: ' 2>&1 >/dev/null`; then
NGX_CC_NAME=acc
echo " using HP aC++ compiler"
echo " HP aC++ compiler"
else
NGX_CC_NAME=unknown

18
auto/configure vendored
View File

@ -19,12 +19,28 @@ if [ $NGX_DEBUG = YES ]; then
fi
if test -z "$NGX_PLATFORM"; then
echo "checking for OS"
NGX_SYSTEM=`uname -s 2>/dev/null`
NGX_RELEASE=`uname -r 2>/dev/null`
NGX_MACHINE=`uname -m 2>/dev/null`
echo " + $NGX_SYSTEM $NGX_RELEASE $NGX_MACHINE"
NGX_PLATFORM="$NGX_SYSTEM:$NGX_RELEASE:$NGX_MACHINE";
else
echo "building for $NGX_PLATFORM"
fi
if [ "$NGX_PLATFORM" != win32 ]; then
. auto/headers
fi
. auto/os/conf
. auto/cc/conf
. auto/os/conf
if [ "$NGX_PLATFORM" != win32 ]; then
. auto/os/features

15
auto/os/conf
View File

@ -2,20 +2,7 @@
# Copyright (C) Igor Sysoev
if test -z "$NGX_PLATFORM"; then
echo "checking for OS"
NGX_SYSTEM=`uname -s 2>/dev/null`
NGX_RELEASE=`uname -r 2>/dev/null`
NGX_MACHINE=`uname -m 2>/dev/null`
echo " + $NGX_SYSTEM $NGX_RELEASE $NGX_MACHINE"
NGX_PLATFORM="$NGX_SYSTEM:$NGX_RELEASE:$NGX_MACHINE";
else
echo "building for $NGX_PLATFORM"
fi
echo "checking for $NGX_SYSTEM specific features"
case "$NGX_PLATFORM" in

3
auto/os/features
View File

@ -92,6 +92,9 @@ fi
if [ "$NGX_SYSTEM" = "NetBSD" ]; then
have=NGX_HAVE_TIMER_EVENT . auto/have
echo " + kqueue's EVFILT_TIMER found"
# NetBSD 2.0 incompatibly defines kevent.udata as "intptr_t"
cat << END >> $NGX_AUTO_CONFIG_H

15
auto/os/freebsd
View File

@ -37,7 +37,7 @@ fi
# sendfile
if [ $osreldate -gt 300007 ]; then
echo " + using sendfile()"
echo " + sendfile() found"
have=NGX_HAVE_SENDFILE . auto/have
CORE_SRCS="$CORE_SRCS $FREEBSD_SENDFILE_SRCS"
@ -49,7 +49,7 @@ fi
if [ \( $osreldate -lt 500000 -a $osreldate -ge 410000 \) \
-o $osreldate -ge 500011 ]
then
echo " + using kqueue"
echo " + kqueue found"
have=NGX_HAVE_KQUEUE . auto/have
have=NGX_HAVE_CLEAR_EVENT . auto/have
@ -67,10 +67,19 @@ NGX_KQUEUE_CHECKED=YES
if [ \( $version -lt 500000 -a $version -ge 430000 \) \
-o $version -ge 500018 ]
then
echo " + using kqueue's NOTE_LOWAT"
echo " + kqueue's NOTE_LOWAT found"
have=NGX_HAVE_LOWAT_EVENT . auto/have
fi
# kqueue's EVFILT_TIMER
if [ \( $version -lt 500000 -a $version -ge 440001 \) \
-o $version -ge 500023 ]
then
echo " + kqueue's EVFILT_TIMER found"
have=NGX_HAVE_TIMER_EVENT . auto/have
fi
if [ $USE_THREADS = "rfork" ]; then

2
auto/os/linux
View File

@ -25,7 +25,7 @@ version=${version:-0}
# enable the rt signals on Linux 2.2.19 and onward
if [ $version -ge 131609 -o $EVENT_RTSIG = YES ]; then
echo " + using rt signals"
echo " + rt signals found"
have=NGX_HAVE_RTSIG . auto/have
have=NGX_HAVE_POLL . auto/have
EVENT_MODULES="$EVENT_MODULES $RTSIG_MODULE"

135
docs/xml/nginx/changes.xml
View File

@ -9,6 +9,141 @@
<title lang="en">nginx changelog</title>
<changes ver="0.3.3" date="19.10.2005">
<change type="change">
<para lang="ru">
ÐÁÒÁÍÅÔÒÙ "bl" É "af" ÄÉÒÅËÔÉ×Ù listen ÐÅÒÅÉÍÅÎÏ×ÁÎÙ × "backlog"
É "accept_filter".
</para>
<para lang="en">
the "bl" and "af" parameters of the "listen" directive was renamed to
the "backlog" and "accept_filter".
</para>
</change>
<change type="feature">
<para lang="ru">
ÐÁÒÁÍÅÔÒÙ "rcvbuf" É "sndbuf" × ÄÉÒÅËÔÉ×Å listen.
</para>
<para lang="en">
the "rcvbuf" and "sndbuf" parameters of the "listen" directive.
</para>
</change>
<change type="change">
<para lang="ru">
ÐÁÒÁÍÅÔÒ ÌÏÇÁ $msec ÔÅÐÅÒØ ÎÅ ÔÒÅÂÕÅÔ ÄÏÐÏÌÎÉÔÅÌØÎÏÇÏ ÓÉÓÔÅÍÎÏÇÏ
×ÙÚÏ×Á gettimeofday().
</para>
<para lang="en">
the "$msec" log parameter does not require now the additional
the gettimeofday() system call.
</para>
</change>
<change type="feature">
<para lang="ru">
ËÌÀÞ -t ÔÅÐÅÒØ ÐÒÏ×ÅÒÑÅÔ ÄÉÒÅËÔÉ×Ù listen.
</para>
<para lang="en">
the -t switch now tests the "listen" directives.
</para>
</change>
<change type="bugfix">
<para lang="ru">
ÅÓÌÉ × ÄÉÒÅËÔÉ×Å listen ÂÙÌ ÕËÁÚÁÎ ÎÅ×ÅÒÎÙÊ ÁÄÒÅÓ, ÔÏ nginx ÐÏÓÌÅ
ÓÉÇÎÁÌÁ -HUP ÏÓÔÁ×ÌÑÌ ÏÔËÒÙÔÙÊ ÓÏËÅÔ × ÓÏÓÔÏÑÎÉÉ CLOSED.
</para>
<para lang="en">
if the invalid address was specified in the "listen" directive, then
after the -HUP signal nginx left an open socket in the CLOSED state.
</para>
</change>
<change type="bugfix">
<para lang="ru">
ÄÌÑ ÉÎÄÅËÓÎÙÈ ÆÁÊÌÏ×, ÓÏÄÅÒÖÁÝÉÈ × ÉÍÅÎÉ ÐÅÒÅÍÅÎÎÕÀ, ÍÏÇ ÎÅ×ÅÒÎÏ ×ÙÓÔÁ×ÌÑÔØÓÑ
ÔÉÐ mime ÐÏ ÕÍÏÌÞÁÎÉÀ;
ÏÛÉÂËÁ ÐÏÑ×ÉÌÁÓØ × 0.3.0.
</para>
<para lang="en">
the mime type may be incorrectly set to default value for index file with
variable in the name;
bug appeared in 0.3.0.
</para>
</change>
<change type="feature">
<para lang="ru">
ÄÉÒÅËÔÉ×Á timer_resolution.
</para>
<para lang="en">
the "timer_resolution" directive.
</para>
</change>
<change type="feature">
<para lang="ru">
ÐÁÒÁÍÅÔÒ ÌÏÇÁ $upstream_response_time × ÍÉÌÌÉÓÅËÕÎÄÁÈ.
</para>
<para lang="en">
the millisecond "$upstream_response_time" log parameter.
</para>
</change>
<change type="bugfix">
<para lang="ru">
×ÒÅÍÅÎÎÙÊ ÆÁÊÌ Ó ÔÅÌÏÍ ÚÁÐÒÏÓÁ ËÌÉÅÎÔÁ ÔÅÐÅÒØ ÕÄÁÌÑÅÔÓÑ ÓÒÁÚÕ ÐÏÓÌÅ ÔÏÇÏ,
ËÁË ËÌÉÅÎÔÕ ÐÅÒÅÄÁÎ ÚÁÇÏÌÏ×ÏË ÏÔ×ÅÔÁ.
</para>
<para lang="en">
a temporary file with client request body now is removed just after
the response header was transferred to a client.
</para>
</change>
<change type="bugfix">
<para lang="ru">
ÓÏ×ÍÅÓÔÉÍÏÓÔØ Ó OpenSSL 0.9.6.
</para>
<para lang="en">
OpenSSL 0.9.6 compatibility.
</para>
</change>
<change type="bugfix">
<para lang="ru">
ÐÕÔÉ Ë ÆÁÊÌÁÍ Ó SSL ÓÅÒÔÉÆÉËÁÔÏÍ É ËÌÀÞÏÍ ÎÅ ÍÏÇÌÉ ÂÙÔØ ÏÔÎÏÓÉÔÅÌØÎÙÍÉ.
</para>
<para lang="en">
the SSL certificate and key file paths could not be relative.
</para>
</change>
<change type="bugfix">
<para lang="ru">
ÄÉÒÅËÔÉ×Á ssl_prefer_server_ciphers ÎÅ ÒÁÂÏÔÁÌÁ ÄÌÑ ÍÏÄÕÌÑ ngx_imap_ssl_module.
</para>
<para lang="en">
the "ssl_prefer_server_ciphers" directive did not work in
the ngx_imap_ssl_module.
</para>
</change>
<change type="bugfix">
<para lang="ru">
ÄÉÒÅËÔÉ×Á ssl_protocols ÐÏÚ×ÏÌÑÌÁ ÚÁÄÁÔØ ÔÏÌØËÏ ÏÄÉÎ ÐÒÏÔÏËÏÌ.
</para>
<para lang="en">
the "ssl_protocols" directive allowed to specify the single protocol only.
</para>
</change>
</changes>
<changes ver="0.3.2" date="12.10.2005">
<change type="feature">

15
src/core/nginx.c
View File

@ -29,19 +29,26 @@ static ngx_conf_enum_t ngx_debug_points[] = {
static ngx_command_t ngx_core_commands[] = {
{ ngx_string("daemon"),
NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
ngx_conf_set_flag_slot,
0,
offsetof(ngx_core_conf_t, daemon),
NULL },
{ ngx_string("master_process"),
NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
ngx_conf_set_flag_slot,
0,
offsetof(ngx_core_conf_t, master),
NULL },
{ ngx_string("timer_resolution"),
NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
ngx_conf_set_msec_slot,
0,
offsetof(ngx_core_conf_t, timer_resolution),
NULL },
{ ngx_string("pid"),
NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
ngx_conf_set_str_slot,
@ -534,6 +541,8 @@ ngx_core_module_create_conf(ngx_cycle_t *cycle)
ccf->daemon = NGX_CONF_UNSET;
ccf->master = NGX_CONF_UNSET;
ccf->timer_resolution = NGX_CONF_UNSET_MSEC;
ccf->worker_processes = NGX_CONF_UNSET;
ccf->debug_points = NGX_CONF_UNSET;
@ -564,6 +573,8 @@ ngx_core_module_init_conf(ngx_cycle_t *cycle, void *conf)
ngx_conf_init_value(ccf->daemon, 1);
ngx_conf_init_value(ccf->master, 1);
ngx_conf_init_msec_value(ccf->timer_resolution, 0);
ngx_conf_init_value(ccf->worker_processes, 1);
ngx_conf_init_value(ccf->debug_points, 0);

2
src/core/nginx.h
View File

@ -8,7 +8,7 @@
#define _NGINX_H_INCLUDED_
#define NGINX_VER "nginx/0.3.2"
#define NGINX_VER "nginx/0.3.3"
#define NGINX_VAR "NGINX"
#define NGX_OLDPID_EXT ".oldbin"

2
src/core/ngx_conf_file.c
View File

@ -624,7 +624,7 @@ ngx_conf_include(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
value = cf->args->elts;
file = value[1];
if (ngx_conf_full_name(cf->cycle, &file) == NGX_ERROR){
if (ngx_conf_full_name(cf->cycle, &file) == NGX_ERROR) {
return NGX_CONF_ERROR;
}

3
src/core/ngx_config.h
View File

@ -104,6 +104,9 @@ typedef long ngx_flag_t;
#define ngx_align(p) (u_char *) (((uintptr_t) p + NGX_ALIGN) & ~NGX_ALIGN)
#define ngx_abort abort
/* TODO: auto_conf: ngx_inline inline __inline __inline__ */
#ifndef ngx_inline
#define ngx_inline inline

287
src/core/ngx_connection.c
View File

@ -66,13 +66,12 @@ ngx_set_inherited_sockets(ngx_cycle_t *cycle)
ngx_uint_t i;
ngx_listening_t *ls;
struct sockaddr_in *sin;
socklen_t olen;
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
ngx_err_t err;
socklen_t aflen;
struct accept_filter_arg af;
#endif
#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
socklen_t tlen;
int timeout;
#endif
@ -126,12 +125,38 @@ ngx_set_inherited_sockets(ngx_cycle_t *cycle)
ls[i].backlog = -1;
olen = sizeof(int);
if (getsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF, (void *) &ls[i].rcvbuf,
&olen)
== -1)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
"getsockopt(SO_RCVBUF) %V failed, ignored",
&ls[i].addr_text);
ls[i].rcvbuf = -1;
}
olen = sizeof(int);
if (getsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF, (void *) &ls[i].sndbuf,
&olen)
== -1)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
"getsockopt(SO_SNDBUF) %V failed, ignored",
&ls[i].addr_text);
ls[i].sndbuf = -1;
}
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
ngx_memzero(&af, sizeof(struct accept_filter_arg));
aflen = sizeof(struct accept_filter_arg);
olen = sizeof(struct accept_filter_arg);
if (getsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, &af, &aflen)
if (getsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER, &af, &olen)
== -1)
{
err = ngx_errno;
@ -146,7 +171,7 @@ ngx_set_inherited_sockets(ngx_cycle_t *cycle)
continue;
}
if (aflen < sizeof(struct accept_filter_arg) || af.af_name[0] == '\0') {
if (olen < sizeof(struct accept_filter_arg) || af.af_name[0] == '\0') {
continue;
}
@ -162,9 +187,9 @@ ngx_set_inherited_sockets(ngx_cycle_t *cycle)
#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
timeout = 0;
tlen = sizeof(int);
olen = sizeof(int);
if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &timeout, &tlen)
if (getsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &timeout, &olen)
== -1)
{
ngx_log_error(NGX_LOG_NOTICE, cycle->log, ngx_errno,
@ -188,7 +213,8 @@ ngx_set_inherited_sockets(ngx_cycle_t *cycle)
ngx_int_t
ngx_open_listening_sockets(ngx_cycle_t *cycle)
{
ngx_uint_t tries, failed, reuseaddr, i;
int reuseaddr;
ngx_uint_t i, tries, failed;
ngx_err_t err;
ngx_log_t *log;
ngx_socket_t s;
@ -201,9 +227,9 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
log = cycle->log;
/* TODO: tries configurable */
/* TODO: configurable try number */
for (tries = /* STUB */ 5; tries; tries--) {
for (tries = 5 ; tries; tries--) {
failed = 0;
/* for each listening socket */
@ -236,25 +262,19 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
return NGX_ERROR;
}
#if (NGX_WIN32)
/*
* Winsock assignes a socket number divisible by 4
* so to find a connection we divide a socket number by 4.
*/
if (s % 4) {
ngx_log_error(NGX_LOG_EMERG, log, 0,
ngx_socket_n " created socket %d", s);
return NGX_ERROR;
}
#endif
if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
(const void *) &reuseaddr, sizeof(int)) == -1) {
(const void *) &reuseaddr, sizeof(int))
== -1)
{
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"setsockopt(SO_REUSEADDR) %V failed",
&ls[i].addr_text);
if (ngx_close_socket(s) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_close_socket_n " %V failed",
&ls[i].addr_text);
return NGX_ERROR;
}
@ -265,56 +285,54 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_nonblocking_n " %V failed",
&ls[i].addr_text);
return NGX_ERROR;
}
}
#if 0
if (ls[i].nonblocking) {
if (ngx_nonblocking(s) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_nonblocking_n " %V failed",
&ls[i].addr_text);
if (ngx_close_socket(s) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_close_socket_n " %V failed",
&ls[i].addr_text);
return NGX_ERROR;
}
}
#endif
if (bind(s, ls[i].sockaddr, ls[i].socklen) == -1) {
err = ngx_socket_errno;
if (err == NGX_EADDRINUSE && ngx_test_config) {
continue;
}
ngx_log_error(NGX_LOG_EMERG, log, err,
"bind() to %V failed", &ls[i].addr_text);
if (err != NGX_EADDRINUSE)
return NGX_ERROR;
if (ngx_close_socket(s) == -1)
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_close_socket_n " %V failed",
&ls[i].addr_text);
if (err != NGX_EADDRINUSE) {
return NGX_ERROR;
}
failed = 1;
continue;
}
if (listen(s, ls[i].backlog) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
"listen() to %V failed", &ls[i].addr_text);
return NGX_ERROR;
}
/* TODO: deferred accept */
ls[i].listen = 1;
ls[i].fd = s;
}
if (!failed)
if (!failed) {
break;
}
/* TODO: delay configurable */
ngx_log_error(NGX_LOG_NOTICE, log, 0,
"try again to bind() after 500ms");
ngx_msleep(500);
}
@ -327,6 +345,143 @@ ngx_open_listening_sockets(ngx_cycle_t *cycle)
}
void
ngx_configure_listening_socket(ngx_cycle_t *cycle)
{
ngx_uint_t i;
ngx_listening_t *ls;
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
struct accept_filter_arg af;
#endif
#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
int timeout;
#endif
ls = cycle->listening.elts;
for (i = 0; i < cycle->listening.nelts; i++) {
if (ls[i].rcvbuf != -1) {
if (setsockopt(ls[i].fd, SOL_SOCKET, SO_RCVBUF,
(const void *) &ls[i].rcvbuf, sizeof(int))
== -1)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
"setsockopt(SO_RCVBUF) %V failed, ignored",
&ls[i].addr_text);
return;
}
}
if (ls[i].sndbuf != -1) {
if (setsockopt(ls[i].fd, SOL_SOCKET, SO_SNDBUF,
(const void *) &ls[i].sndbuf, sizeof(int))
== -1)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
"setsockopt(SO_SNDBUF) %V failed, ignored",
&ls[i].addr_text);
return;
}
}
if (ls[i].listen) {
if (listen(ls[i].fd, ls[i].backlog) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_socket_errno,
"changing the listen() backlog to %d "
"for %V failed, ignored",
&ls[i].addr_text, ls[i].backlog);
}
}
/*
* setting deferred mode should be last operation on socket,
* because code may prematurely continue cycle on failure
*/
#if (NGX_HAVE_DEFERRED_ACCEPT)
#ifdef SO_ACCEPTFILTER
if (ls->delete_deferred) {
if (setsockopt(ls->fd, SOL_SOCKET, SO_ACCEPTFILTER, NULL, 0) == -1)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"setsockopt(SO_ACCEPTFILTER, NULL) "
"for %V failed, ignored",
&ls->addr_text);
if (ls->accept_filter) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"could not change the accept filter "
"to \"%s\" for %V, ignored",
ls->accept_filter, &ls->addr_text);
}
continue;
}
ls->deferred_accept = 0;
}
if (ls->add_deferred) {
ngx_memzero(&af, sizeof(struct accept_filter_arg));
(void) ngx_cpystrn((u_char *) af.af_name,
(u_char *) ls->accept_filter, 16);
if (setsockopt(ls->fd, SOL_SOCKET, SO_ACCEPTFILTER,
&af, sizeof(struct accept_filter_arg))
== -1)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"setsockopt(SO_ACCEPTFILTER, \"%s\") "
" for %V failed, ignored",
ls->accept_filter, &ls->addr_text);
continue;
}
ls->deferred_accept = 1;
}
#endif
#ifdef TCP_DEFER_ACCEPT
if (ls->add_deferred || ls->delete_deferred) {
if (ls->add_deferred) {
timeout = (int) (ls->post_accept_timeout / 1000);
} else {
timeout = 0;
}
if (setsockopt(ls->fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
&timeout, sizeof(int))
== -1)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"setsockopt(TCP_DEFER_ACCEPT, %d) for %V failed, "
"ignored",
timeout, &ls->addr_text);
continue;
}
}
if (ls->add_deferred) {
ls->deferred_accept = 1;
}
#endif
#endif /* NGX_HAVE_DEFERRED_ACCEPT */
}
return;
}
void
ngx_close_listening_sockets(ngx_cycle_t *cycle)
{
@ -361,6 +516,9 @@ ngx_close_listening_sockets(ngx_cycle_t *cycle)
c->fd = (ngx_socket_t) -1;
ngx_log_debug2(NGX_LOG_DEBUG_CORE, cycle->log, 0,
"close listening %V #%d ", &ls[i].addr_text, ls[i].fd);
if (ngx_close_socket(ls[i].fd) == -1) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
ngx_close_socket_n " %V failed", &ls[i].addr_text);
@ -495,28 +653,27 @@ ngx_close_connection(ngx_connection_t *c)
* before we clean the connection
*/
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_OK) {
ngx_mutex_lock(ngx_posted_events_mutex);
if (c->read->prev) {
ngx_delete_posted_event(c->read);
}
if (c->write->prev) {
ngx_delete_posted_event(c->write);
}
c->read->closed = 1;
c->write->closed = 1;
if (c->single_connection) {
ngx_unlock(&c->lock);
c->read->locked = 0;
c->write->locked = 0;
}
ngx_mutex_unlock(ngx_posted_events_mutex);
if (c->read->prev) {
ngx_delete_posted_event(c->read);
}
if (c->write->prev) {
ngx_delete_posted_event(c->write);
}
c->read->closed = 1;
c->write->closed = 1;
if (c->single_connection) {
ngx_unlock(&c->lock);
c->read->locked = 0;
c->write->locked = 0;
}
ngx_mutex_unlock(ngx_posted_events_mutex);
#else
if (c->read->prev) {

6
src/core/ngx_connection.h
View File

@ -25,7 +25,10 @@ struct ngx_listening_s {
int family;
int type;
int backlog;
int rcvbuf;
int sndbuf;
/* handler of accepted connection */
ngx_connection_handler_pt handler;
@ -51,7 +54,7 @@ struct ngx_listening_s {
unsigned bound:1; /* already bound */
unsigned inherited:1; /* inherited from previous process */
unsigned nonblocking_accept:1;
unsigned change_backlog:1;
unsigned listen:1;
unsigned nonblocking:1;
unsigned shared:1; /* shared between threads or processes */
unsigned addr_ntop:1;
@ -162,6 +165,7 @@ ngx_listening_t *ngx_listening_inet_stream_socket(ngx_conf_t *cf,
in_addr_t addr, in_port_t port);
ngx_int_t ngx_set_inherited_sockets(ngx_cycle_t *cycle);
ngx_int_t ngx_open_listening_sockets(ngx_cycle_t *cycle);
void ngx_configure_listening_socket(ngx_cycle_t *cycle);
void ngx_close_listening_sockets(ngx_cycle_t *cycle);
void ngx_close_connection(ngx_connection_t *c);
ngx_int_t ngx_connection_error(ngx_connection_t *c, ngx_err_t err, char *text);

135
src/core/ngx_cycle.c
View File

@ -37,7 +37,8 @@ static ngx_str_t error_log = ngx_null_string;
#endif
ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)
ngx_cycle_t *
ngx_init_cycle(ngx_cycle_t *old_cycle)
{
void *rv;
ngx_uint_t i, n, failed;
@ -45,18 +46,11 @@ ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)
ngx_conf_t conf;
ngx_pool_t *pool;
ngx_cycle_t *cycle, **old;
ngx_socket_t fd;
ngx_list_part_t *part;
ngx_open_file_t *file;
ngx_listening_t *ls, *nls;
ngx_core_conf_t *ccf;
ngx_core_module_t *module;
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
struct accept_filter_arg af;
#endif
#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
int timeout;
#endif
log = old_cycle->log;
@ -315,39 +309,19 @@ ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)
if (ngx_cmp_sockaddr(nls[n].sockaddr, ls[i].sockaddr)
== NGX_OK)
{
fd = ls[i].fd;
#if (NGX_WIN32)
/*
* Winsock assignes a socket number divisible by 4 so
* to find a connection we divide a socket number by 4.
*/
fd /= 4;
#endif
if (fd >= (ngx_socket_t) cycle->connection_n) {
ngx_log_error(NGX_LOG_EMERG, log, 0,
"%d connections is not enough to hold "
"an open listening socket on %V, "
"required at least %d connections",
cycle->connection_n,
&ls[i].addr_text, fd);
failed = 1;
break;
}
nls[n].fd = ls[i].fd;
nls[n].previous = &ls[i];
ls[i].remain = 1;
if (ls[n].backlog != nls[i].backlog) {
nls[n].change_backlog = 1;
nls[n].listen = 1;
}
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
/*
* FreeBSD, except the most recent versions,
* can not remove accept filter
* could not remove accept filter
*/
nls[n].deferred_accept = ls[i].deferred_accept;
@ -404,93 +378,13 @@ ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)
}
}
if (!ngx_test_config && !failed) {
if (!failed) {
if (ngx_open_listening_sockets(cycle) == NGX_ERROR) {
failed = 1;
}
if (!failed) {
ls = cycle->listening.elts;
for (i = 0; i < cycle->listening.nelts; i++) {
if (ls[i].change_backlog) {
if (listen(ls[i].fd, ls[i].backlog) == -1) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_socket_errno,
"changing the listen() backlog to %d "
"for %V failed, ignored",
&ls[i].addr_text, ls[i].backlog);
}
}
#if (NGX_HAVE_DEFERRED_ACCEPT)
#ifdef SO_ACCEPTFILTER
if (ls[i].delete_deferred) {
if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER,
NULL, 0) == -1)
{
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"setsockopt(SO_ACCEPTFILTER, NULL) "
"for %V failed, ignored",
&ls[i].addr_text);
if (ls[i].accept_filter) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"could not change the accept filter "
"to \"%s\" for %V, ignored",
ls[i].accept_filter, &ls[i].addr_text);
}
continue;
}
ls[i].deferred_accept = 0;
}
if (ls[i].add_deferred) {
ngx_memzero(&af, sizeof(struct accept_filter_arg));
(void) ngx_cpystrn((u_char *) af.af_name,
(u_char *) ls[i].accept_filter, 16);
if (setsockopt(ls[i].fd, SOL_SOCKET, SO_ACCEPTFILTER,
&af, sizeof(struct accept_filter_arg)) == -1)
{
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"setsockopt(SO_ACCEPTFILTER, \"%s\") "
"for %V failed, ignored",
ls[i].accept_filter, &ls[i].addr_text);
continue;
}
ls[i].deferred_accept = 1;
}
#endif
#ifdef TCP_DEFER_ACCEPT
if (ls[i].add_deferred || ls[i].delete_deferred) {
timeout = 0;
if (ls[i].add_deferred) {
timeout = (int) (ls[i].post_accept_timeout / 1000);
}
if (setsockopt(ls[i].fd, IPPROTO_TCP, TCP_DEFER_ACCEPT,
&timeout, sizeof(int)) == -1)
{
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"setsockopt(TCP_DEFER_ACCEPT, %d) "
"for %V failed, ignored",
timeout, &ls[i].addr_text);
continue;
}
}
if (ls[i].add_deferred) {
ls[i].deferred_accept = 1;
}
#endif
#endif
}
if (!ngx_test_config && !failed) {
ngx_configure_listening_socket(cycle);
}
}
}
@ -680,7 +574,8 @@ ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)
}
static ngx_int_t ngx_cmp_sockaddr(struct sockaddr *sa1, struct sockaddr *sa2)
static ngx_int_t
ngx_cmp_sockaddr(struct sockaddr *sa1, struct sockaddr *sa2)
{
struct sockaddr_in *sin1, *sin2;
@ -707,7 +602,8 @@ static ngx_int_t ngx_cmp_sockaddr(struct sockaddr *sa1, struct sockaddr *sa2)
#if !(NGX_WIN32)
ngx_int_t ngx_create_pidfile(ngx_cycle_t *cycle, ngx_cycle_t *old_cycle)
ngx_int_t
ngx_create_pidfile(ngx_cycle_t *cycle, ngx_cycle_t *old_cycle)
{
ngx_uint_t trunc;
size_t len;
@ -776,7 +672,8 @@ ngx_int_t ngx_create_pidfile(ngx_cycle_t *cycle, ngx_cycle_t *old_cycle)
}
void ngx_delete_pidfile(ngx_cycle_t *cycle)
void
ngx_delete_pidfile(ngx_cycle_t *cycle)
{
u_char *name;
ngx_core_conf_t *ccf;
@ -798,7 +695,8 @@ void ngx_delete_pidfile(ngx_cycle_t *cycle)
#endif
void ngx_reopen_files(ngx_cycle_t *cycle, ngx_uid_t user)
void
ngx_reopen_files(ngx_cycle_t *cycle, ngx_uid_t user)
{
ngx_fd_t fd;
ngx_uint_t i;
@ -936,7 +834,8 @@ void ngx_reopen_files(ngx_cycle_t *cycle, ngx_uid_t user)
}
static void ngx_clean_old_cycles(ngx_event_t *ev)
static void
ngx_clean_old_cycles(ngx_event_t *ev)
{
ngx_uint_t i, n, found, live;
ngx_log_t *log;

2
src/core/ngx_cycle.h
View File

@ -54,6 +54,8 @@ typedef struct {
ngx_flag_t daemon;
ngx_flag_t master;
ngx_msec_t timer_resolution;
ngx_int_t worker_processes;
ngx_int_t debug_points;

25
src/core/ngx_file.c
View File

@ -40,8 +40,8 @@ ngx_create_temp_file(ngx_file_t *file, ngx_path_t *path, ngx_pool_t *pool,
{
ngx_err_t err;
ngx_atomic_uint_t n;
ngx_pool_cleanup_file_t *cln;
ngx_pool_cleanup_t *cln;
ngx_pool_cleanup_file_t *clnf;
file->name.len = path->name.len + 1 + path->len + NGX_ATOMIC_T_LEN;
@ -66,6 +66,11 @@ ngx_create_temp_file(ngx_file_t *file, ngx_path_t *path, ngx_pool_t *pool,
ngx_create_hashed_filename(file, path);
cln = ngx_pool_cleanup_add(pool, sizeof(ngx_pool_cleanup_file_t));
if (cln == NULL) {
return NGX_ERROR;
}
#if 1
file->fd = ngx_open_tempfile(file->name.data, persistent);
#else
@ -76,19 +81,13 @@ ngx_create_temp_file(ngx_file_t *file, ngx_path_t *path, ngx_pool_t *pool,
"temp fd:%d", file->fd);
if (file->fd != NGX_INVALID_FILE) {
cln = ngx_palloc(pool, sizeof(ngx_pool_cleanup_file_t));
if (cln == NULL) {
return NGX_ERROR;
}
cln->fd = file->fd;
cln->name = file->name.data;
cln->log = pool->log;
cln->handler = ngx_pool_cleanup_file;
clnf = cln->data;
if (ngx_pool_cleanup_add(pool, ngx_pool_cleanup_file, cln) == NULL)
{
return NGX_ERROR;
}
clnf->fd = file->fd;
clnf->name = file->name.data;
clnf->log = pool->log;
return NGX_OK;
}

20
src/core/ngx_palloc.c
View File

@ -207,7 +207,7 @@ ngx_pcalloc(ngx_pool_t *pool, size_t size)
ngx_pool_cleanup_t *
ngx_pool_cleanup_add(ngx_pool_t *p, ngx_pool_cleanup_pt handler, void *data)
ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
{
ngx_pool_cleanup_t *c;
@ -216,12 +216,23 @@ ngx_pool_cleanup_add(ngx_pool_t *p, ngx_pool_cleanup_pt handler, void *data)
return NULL;
}
c->handler = handler;
c->data = data;
if (size) {
c->data = ngx_palloc(p, size);
if (c->data == NULL) {
return NULL;
}
} else {
c->data = NULL;
}
c->handler = NULL;
c->next = p->cleanup;
p->cleanup = c;
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, p->log, 0, "add cleanup: %p", c);
return c;
}
@ -231,6 +242,9 @@ ngx_pool_cleanup_file(void *data)
{
ngx_pool_cleanup_file_t *c = data;
ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, c->log, 0, "run cleanup: %p, fd:%d",
c, c->fd);
if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
ngx_close_file_n " \"%s\" failed", c->name);

3
src/core/ngx_palloc.h
View File

@ -71,8 +71,7 @@ void *ngx_pcalloc(ngx_pool_t *pool, size_t size);
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p);
ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p,
ngx_pool_cleanup_pt handler, void *data);
ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size);
void ngx_pool_cleanup_file(void *data);

11
src/core/ngx_parse.c
View File

@ -8,11 +8,13 @@
#include <ngx_core.h>
ngx_int_t ngx_parse_size(ngx_str_t *line)
ssize_t
ngx_parse_size(ngx_str_t *line)
{
u_char last;
size_t len;
ngx_int_t scale, size;
ssize_t size;
ngx_int_t scale;
len = line->len;
last = line->data[len - 1];
@ -34,7 +36,7 @@ ngx_int_t ngx_parse_size(ngx_str_t *line)
scale = 1;
}
size = ngx_atoi(line->data, len);
size = ngx_atosz(line->data, len);
if (size == NGX_ERROR) {
return NGX_ERROR;
}
@ -45,7 +47,8 @@ ngx_int_t ngx_parse_size(ngx_str_t *line)
}
ngx_int_t ngx_parse_time(ngx_str_t *line, ngx_int_t sec)
ngx_int_t
ngx_parse_time(ngx_str_t *line, ngx_int_t sec)
{
size_t len;
u_char *start, last;

2
src/core/ngx_parse.h
View File

@ -15,7 +15,7 @@
#define NGX_PARSE_LARGE_TIME -2
ngx_int_t ngx_parse_size(ngx_str_t *line);
ssize_t ngx_parse_size(ngx_str_t *line);
ngx_int_t ngx_parse_time(ngx_str_t *line, ngx_int_t sec);

15
src/core/ngx_radix_tree.c
View File

@ -205,6 +205,7 @@ ngx_radix32tree_delete(ngx_radix_tree_t *tree, uint32_t key, uint32_t mask)
for ( ;; ) {
if (node->parent->right == node) {
node->parent->right = NULL;
} else {
node->parent->left = NULL;
}
@ -214,11 +215,15 @@ ngx_radix32tree_delete(ngx_radix_tree_t *tree, uint32_t key, uint32_t mask)
node = node->parent;
if (node->right
|| node->left
|| node->value != NGX_RADIX_NO_VALUE
|| node->parent == NULL)
{
if (node->right || node->left) {
break;
}
if (node->value != NGX_RADIX_NO_VALUE) {
break;
}
if (node->parent == NULL) {
break;
}
}

3
src/core/ngx_spinlock.c
View File

@ -12,7 +12,8 @@
* TODO: the P4 optimized assembler version with the "pause" operation
*/
void ngx_spinlock(ngx_atomic_t *lock, ngx_uint_t spin)
void
ngx_spinlock(ngx_atomic_t *lock, ngx_uint_t spin)
{
#if (NGX_HAVE_ATOMIC_OPS)

197
src/core/ngx_times.c
View File

@ -8,61 +8,33 @@
#include <ngx_core.h>
ngx_msec_t ngx_current_time;
ngx_int_t ngx_gmtoff;
static ngx_tm_t ngx_cached_gmtime;
/*
* In the threaded mode only one thread updates the cached time and strings
* and these operations are protected by the mutex. The reading of the cached
* time and strings is not protected by the mutex. To avoid the race
* conditions for non-atomic values we use the NGX_TIME_SLOTS slots to store
* time value and strings. Thus thread may get the corrupted values only
* if it is preempted while copying and then it is not scheduled to run
* more than NGX_TIME_SLOTS seconds.
* The time may be updated by signal handler or by several threads.
* The time update operations are rare and require to hold the ngx_time_lock.
* The time read operations are frequent, so they are lock-free and get time
* values and strings from the current slot. Thus thread may get the corrupted
* values only if it is preempted while copying and then it is not scheduled
* to run more than NGX_TIME_SLOTS seconds.
*/
#if (NGX_THREADS)
#define NGX_TIME_SLOTS 64
#define NGX_TIME_SLOTS 60
static ngx_uint_t slot = NGX_TIME_SLOTS;
static ngx_uint_t slot = NGX_TIME_SLOTS;
static ngx_atomic_t ngx_time_lock;
static ngx_mutex_t *ngx_time_mutex;
volatile ngx_msec_t ngx_current_msec;
volatile ngx_time_t *ngx_cached_time;
volatile ngx_str_t ngx_cached_err_log_time;
volatile ngx_str_t ngx_cached_http_time;
volatile ngx_str_t ngx_cached_http_log_time;
#else
#define NGX_TIME_SLOTS 1
#define slot 0
#endif
#if (NGX_THREADS && (NGX_TIME_T_SIZE > NGX_SIG_ATOMIC_T_SIZE))
volatile time_t *ngx_cached_time;
static time_t cached_time[NGX_TIME_SLOTS];
#else
volatile time_t ngx_cached_time;
#endif
ngx_thread_volatile ngx_str_t ngx_cached_err_log_time;
ngx_thread_volatile ngx_str_t ngx_cached_http_time;
ngx_thread_volatile ngx_str_t ngx_cached_http_log_time;
static u_char cached_err_log_time[NGX_TIME_SLOTS]
[sizeof("1970/09/28 12:00:00")];
static u_char cached_http_time[NGX_TIME_SLOTS]
[sizeof("Mon, 28 Sep 1970 06:00:00 GMT")];
static u_char cached_http_log_time[NGX_TIME_SLOTS]
[sizeof("28/Sep/1970:12:00:00 +0600")];
static ngx_time_t cached_time[NGX_TIME_SLOTS];
static u_char cached_err_log_time[NGX_TIME_SLOTS]
[sizeof("1970/09/28 12:00:00")];
static u_char cached_http_time[NGX_TIME_SLOTS]
[sizeof("Mon, 28 Sep 1970 06:00:00 GMT")];
static u_char cached_http_log_time[NGX_TIME_SLOTS]
[sizeof("28/Sep/1970:12:00:00 +0600")];
static char *week[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
@ -72,63 +44,29 @@ static char *months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
void
ngx_time_init(void)
{
struct timeval tv;
ngx_memzero(&ngx_cached_gmtime, sizeof(ngx_tm_t));
#ifdef ngx_tm_zone
ngx_cached_gmtime.ngx_tm_zone = "GMT";
#endif
ngx_cached_err_log_time.len = sizeof("1970/09/28 12:00:00") - 1;
ngx_cached_http_time.len = sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1;
ngx_cached_http_log_time.len = sizeof("28/Sep/1970:12:00:00 +0600") - 1;
#if (NGX_THREADS && (NGX_TIME_T_SIZE > NGX_SIG_ATOMIC_T_SIZE))
ngx_cached_time = &cached_time[0];
#endif
ngx_gettimeofday(&tv);
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
#if !(NGX_WIN32)
tzset();
#endif
ngx_time_update(tv.tv_sec);
ngx_time_update(0, 0);
}
#if (NGX_THREADS)
ngx_int_t
ngx_time_mutex_init(ngx_log_t *log)
{
ngx_time_mutex = ngx_mutex_init(log, NGX_MUTEX_LIGHT);
if (ngx_time_mutex == NULL) {
return NGX_ERROR;
}
return NGX_OK;
}
#endif
void
ngx_time_update(time_t s)
ngx_time_update(time_t sec, ngx_uint_t msec)
{
u_char *p;
ngx_tm_t tm;
u_char *p0, *p1, *p2;
ngx_tm_t tm, gmt;
ngx_time_t *tp;
struct timeval tv;
if (ngx_time() == s) {
return;
}
#if (NGX_THREADS)
if (ngx_mutex_trylock(ngx_time_mutex) != NGX_OK) {
if (!ngx_trylock(&ngx_time_lock)) {
return;
}
@ -138,75 +76,80 @@ ngx_time_update(time_t s)
slot++;
}
#if (NGX_THREADS && (NGX_TIME_T_SIZE > NGX_SIG_ATOMIC_T_SIZE))
ngx_cached_time = &cached_time[slot];
#endif
if (sec == 0) {
ngx_gettimeofday(&tv);
#endif
sec = tv.tv_sec;
msec = tv.tv_usec / 1000;
}
ngx_time() = s;
ngx_current_msec = (ngx_msec_t) sec * 1000 + msec;
ngx_gmtime(s, &ngx_cached_gmtime);
tp = &cached_time[slot];
tp->msec = msec;
if (tp->sec == sec) {
ngx_unlock(&ngx_time_lock);
return;
}
tp->sec = sec;
ngx_gmtime(sec, &gmt);
p = cached_http_time[slot];
(void) ngx_sprintf(p, "%s, %02d %s %4d %02d:%02d:%02d GMT",
week[ngx_cached_gmtime.ngx_tm_wday],
ngx_cached_gmtime.ngx_tm_mday,
months[ngx_cached_gmtime.ngx_tm_mon - 1],
ngx_cached_gmtime.ngx_tm_year,
ngx_cached_gmtime.ngx_tm_hour,
ngx_cached_gmtime.ngx_tm_min,
ngx_cached_gmtime.ngx_tm_sec);
ngx_cached_http_time.data = p;
p0 = cached_http_time[slot];
(void) ngx_sprintf(p0, "%s, %02d %s %4d %02d:%02d:%02d GMT",
week[gmt.ngx_tm_wday], gmt.ngx_tm_mday,
months[gmt.ngx_tm_mon - 1], gmt.ngx_tm_year,
gmt.ngx_tm_hour, gmt.ngx_tm_min, gmt.ngx_tm_sec);
#if (NGX_HAVE_GETTIMEZONE)
ngx_gmtoff = ngx_gettimezone();
ngx_gmtime(s + ngx_gmtoff * 60, &tm);
tp->gmtoff = ngx_gettimezone();
ngx_gmtime(sec + tp->gmtoff * 60, &tm);
#elif (NGX_HAVE_GMTOFF)
ngx_localtime(&tm);
ngx_gmtoff = (ngx_int_t) (tm.ngx_tm_gmtoff / 60);
ngx_localtime(sec, &tm);
tp->gmtoff = (ngx_int_t) (tm.ngx_tm_gmtoff / 60);
#else
ngx_localtime(&tm);
ngx_gmtoff = ngx_timezone(tm.ngx_tm_isdst);
ngx_localtime(sec, &tm);
tp->gmtoff = ngx_timezone(tm.ngx_tm_isdst);
#endif
p = cached_err_log_time[slot];
p1 = cached_err_log_time[slot];
(void) ngx_sprintf(p, "%4d/%02d/%02d %02d:%02d:%02d",
(void) ngx_sprintf(p1, "%4d/%02d/%02d %02d:%02d:%02d",
tm.ngx_tm_year, tm.ngx_tm_mon,
tm.ngx_tm_mday, tm.ngx_tm_hour,
tm.ngx_tm_min, tm.ngx_tm_sec);
ngx_cached_err_log_time.data = p;
p2 = cached_http_log_time[slot];
p = cached_http_log_time[slot];
(void) ngx_sprintf(p, "%02d/%s/%d:%02d:%02d:%02d %c%02d%02d",
(void) ngx_sprintf(p2, "%02d/%s/%d:%02d:%02d:%02d %c%02d%02d",
tm.ngx_tm_mday, months[tm.ngx_tm_mon - 1],
tm.ngx_tm_year, tm.ngx_tm_hour,
tm.ngx_tm_min, tm.ngx_tm_sec,
ngx_gmtoff < 0 ? '-' : '+',
abs(ngx_gmtoff / 60), abs(ngx_gmtoff % 60));
ngx_cached_http_log_time.data = p;
tp->gmtoff < 0 ? '-' : '+',
ngx_abs(tp->gmtoff / 60), ngx_abs(tp->gmtoff % 60));
#if (NGX_THREADS)
ngx_mutex_unlock(ngx_time_mutex);
#endif
ngx_memory_barrier();
ngx_cached_time = tp;
ngx_cached_http_time.data = p0;
ngx_cached_err_log_time.data = p1;
ngx_cached_http_log_time.data = p2;
ngx_unlock(&ngx_time_lock);
}

36
src/core/ngx_times.h
View File

@ -12,40 +12,34 @@
#include <ngx_core.h>
typedef struct {
time_t sec;
ngx_uint_t msec;
ngx_int_t gmtoff;
} ngx_time_t;
void ngx_time_init(void);
void ngx_time_update(time_t s);
void ngx_time_update(time_t sec, ngx_uint_t msec);
u_char *ngx_http_time(u_char *buf, time_t t);
u_char *ngx_http_cookie_time(u_char *buf, time_t t);
void ngx_gmtime(time_t t, ngx_tm_t *tp);
#if (NGX_THREADS)
ngx_int_t ngx_time_mutex_init(ngx_log_t *log);
#endif
#if (NGX_THREADS && (NGX_TIME_T_SIZE > NGX_SIG_ATOMIC_T_SIZE))
extern volatile ngx_time_t *ngx_cached_time;
#define ngx_time() *ngx_cached_time
extern volatile time_t *ngx_cached_time;
#define ngx_time() ngx_cached_time->sec
#define ngx_timeofday() (ngx_time_t *) ngx_cached_time
#else
#define ngx_time() ngx_cached_time
extern volatile time_t ngx_cached_time;
#endif
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_int_t ngx_gmtoff;
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;
/*
* milliseconds elapsed since epoch and truncated to ngx_msec_t,
* used in event timers
*/
extern ngx_msec_t ngx_current_time;
extern volatile ngx_msec_t ngx_current_msec;
#endif /* _NGX_TIMES_H_INCLUDED_ */

13
src/event/modules/ngx_aio_module.c
View File

@ -14,12 +14,13 @@
#endif
static ngx_int_t ngx_aio_init(ngx_cycle_t *cycle);
static ngx_int_t ngx_aio_init(ngx_cycle_t *cycle, ngx_msec_t timer);
static void ngx_aio_done(ngx_cycle_t *cycle);
static ngx_int_t ngx_aio_add_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_aio_del_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_aio_del_connection(ngx_connection_t *c, u_int flags);
static ngx_int_t ngx_aio_process_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_aio_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags);
ngx_os_io_t ngx_os_aio = {
@ -73,9 +74,9 @@ ngx_module_t ngx_aio_module = {
#if (NGX_HAVE_KQUEUE)
static ngx_int_t
ngx_aio_init(ngx_cycle_t *cycle)
ngx_aio_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
if (ngx_kqueue_module_ctx.actions.init(cycle) == NGX_ERROR) {
if (ngx_kqueue_module_ctx.actions.init(cycle, timer) == NGX_ERROR) {
return NGX_ERROR;
}
@ -159,9 +160,9 @@ ngx_aio_del_connection(ngx_connection_t *c, u_int flags)
static ngx_int_t
ngx_aio_process_events(ngx_cycle_t *cycle)
ngx_aio_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
{
return ngx_kqueue_module_ctx.actions.process_events(cycle);
return ngx_kqueue_module_ctx.actions.process_events(cycle, timer, flags);
}
#endif /* NGX_HAVE_KQUEUE */

163
src/event/modules/ngx_devpoll_module.c
View File

@ -31,12 +31,13 @@ typedef struct {
} ngx_devpoll_conf_t;
static ngx_int_t ngx_devpoll_init(ngx_cycle_t *cycle);
static ngx_int_t ngx_devpoll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
static void ngx_devpoll_done(ngx_cycle_t *cycle);
static ngx_int_t ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_devpoll_process_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_devpoll_process_events(ngx_cycle_t *cycle,
ngx_msec_t timer, ngx_uint_t flags);
static void *ngx_devpoll_create_conf(ngx_cycle_t *cycle);
static char *ngx_devpoll_init_conf(ngx_cycle_t *cycle, void *conf);
@ -107,7 +108,7 @@ ngx_module_t ngx_devpoll_module = {
static ngx_int_t
ngx_devpoll_init(ngx_cycle_t *cycle)
ngx_devpoll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
size_t n;
ngx_devpoll_conf_t *dpcf;
@ -323,48 +324,21 @@ ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags)
ngx_int_t
ngx_devpoll_process_events(ngx_cycle_t *cycle)
ngx_devpoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags)
{
int events, revents;
size_t n;
ngx_err_t err;
ngx_int_t i;
ngx_uint_t lock, accept_lock;
ngx_msec_t timer, delta;
#if 0
ngx_cycle_t **old_cycle;
#endif
ngx_event_t *rev, *wev;
ngx_uint_t level;
ngx_msec_t delta;
ngx_event_t *rev, *wev, **queue;
ngx_connection_t *c;
struct dvpoll dvp;
struct timeval tv;
timer = ngx_event_find_timer();
/* NGX_TIMER_INFINITE == INFTIM */
accept_lock = 0;
if (ngx_accept_mutex) {
if (ngx_accept_disabled > 0) {
ngx_accept_disabled--;
} else {
if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
return NGX_ERROR;
}
if (ngx_accept_mutex_held) {
accept_lock = 1;
} else if (timer == NGX_TIMER_INFINITE
|| timer > ngx_accept_mutex_delay)
{
timer = ngx_accept_mutex_delay;
}
}
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"devpoll timer: %M", timer);
@ -373,7 +347,6 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle)
if (write(dp, change_list, n) != (ssize_t) n) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"write(/dev/poll) failed");
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
}
@ -391,21 +364,32 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle)
nchanges = 0;
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_current_time;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
delta = ngx_current_msec;
if (flags & NGX_UPDATE_TIME) {
ngx_time_update(0, 0);
}
if (err) {
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
cycle->log, err, "ioctl(DP_POLL) failed");
ngx_accept_mutex_unlock();
if (err == NGX_EINTR) {
if (ngx_event_timer_alarm) {
ngx_event_timer_alarm = 0;
return NGX_OK;
}
level = NGX_LOG_INFO;
} else {
level = NGX_LOG_ALERT;
}
ngx_log_error(level, cycle->log, err, "ioctl(DP_POLL) failed");
return NGX_ERROR;
}
if (timer != NGX_TIMER_INFINITE) {
delta = ngx_current_time - delta;
delta = ngx_current_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"devpoll timer: %M, delta: %M", timer, delta);
@ -413,17 +397,15 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle)
if (events == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"ioctl(DP_POLL) returned no events without timeout");
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
ngx_accept_mutex_unlock();
return NGX_ERROR;
if (events == 0) {
return NGX_OK;
}
lock = 1;
ngx_mutex_lock(ngx_posted_events_mutex);
for (i = 0; i < events; i++) {
c = ngx_cycle->files[event_list[i].fd];
@ -468,74 +450,49 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle)
revents |= POLLIN|POLLOUT;
}
wev = c->write;
if ((revents & POLLOUT) && wev->active) {
wev->ready = 1;
if (!ngx_threaded && !ngx_accept_mutex_held) {
wev->handler(wev);
} else {
ngx_post_event(wev);
}
}
/*
* POLLIN must be handled after POLLOUT because we use
* the optimization to avoid the unnecessary mutex locking/unlocking
* if the accept event is the last one.
*/
rev = c->read;
if ((revents & POLLIN) && rev->active) {
rev->ready = 1;
if (!ngx_threaded && !ngx_accept_mutex_held) {
if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
rev->posted_ready = 1;
} else {
rev->ready = 1;
}
if (flags & NGX_POST_EVENTS) {
queue = (ngx_event_t **) (rev->accept ?
&ngx_posted_accept_events : &ngx_posted_events);
ngx_locked_post_event(rev, queue);
} else {
rev->handler(rev);
}
}
} else if (!rev->accept) {
ngx_post_event(rev);
wev = c->write;
} else if (ngx_accept_disabled <= 0) {
ngx_mutex_unlock(ngx_posted_events_mutex);
if ((revents & POLLOUT) && wev->active) {
c->read->handler(rev);
if (flags & NGX_POST_THREAD_EVENTS) {
wev->posted_ready = 1;
if (ngx_accept_disabled > 0) {
ngx_accept_mutex_unlock();
accept_lock = 0;
}
} else {
wev->ready = 1;
}
if (i + 1 == events) {
lock = 0;
break;
}
if (flags & NGX_POST_EVENTS) {
ngx_locked_post_event(wev, &ngx_posted_events);
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
if (accept_lock) {
ngx_accept_mutex_unlock();
}
return NGX_ERROR;
}
} else {
wev->handler(wev);
}
}
}
if (accept_lock) {
ngx_accept_mutex_unlock();
}
if (lock) {
ngx_mutex_unlock(ngx_posted_events_mutex);
}
ngx_event_expire_timers();
if (!ngx_threaded) {
ngx_event_process_posted(cycle);
}
ngx_mutex_unlock(ngx_posted_events_mutex);
return NGX_OK;
}

195
src/event/modules/ngx_epoll_module.c
View File

@ -70,13 +70,14 @@ typedef struct {
} ngx_epoll_conf_t;
static ngx_int_t ngx_epoll_init(ngx_cycle_t *cycle);
static ngx_int_t ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
static void ngx_epoll_done(ngx_cycle_t *cycle);
static ngx_int_t ngx_epoll_add_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_epoll_del_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_epoll_add_connection(ngx_connection_t *c);
static ngx_int_t ngx_epoll_del_connection(ngx_connection_t *c, u_int flags);
static ngx_int_t ngx_epoll_process_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags);
static void *ngx_epoll_create_conf(ngx_cycle_t *cycle);
static char *ngx_epoll_init_conf(ngx_cycle_t *cycle, void *conf);
@ -137,7 +138,7 @@ ngx_module_t ngx_epoll_module = {
static ngx_int_t
ngx_epoll_init(ngx_cycle_t *cycle)
ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
ngx_event_conf_t *ecf;
ngx_epoll_conf_t *epcf;
@ -382,57 +383,20 @@ ngx_epoll_del_connection(ngx_connection_t *c, u_int flags)
static ngx_int_t
ngx_epoll_process_events(ngx_cycle_t *cycle)
ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
{
int events;
uint32_t revents;
ngx_int_t instance, i;
ngx_uint_t lock, accept_lock;
ngx_uint_t level;
ngx_err_t err;
ngx_log_t *log;
ngx_msec_t timer, delta;
ngx_event_t *rev, *wev;
struct timeval tv;
ngx_msec_t delta;
ngx_event_t *rev, *wev, **queue;
ngx_connection_t *c;
timer = ngx_event_find_timer();
#if (NGX_THREADS)
if (timer == NGX_TIMER_ERROR) {
return NGX_ERROR;
}
if (timer == NGX_TIMER_INFINITE || timer > 500) {
timer = 500;
}
#endif
/* NGX_TIMER_INFINITE == INFTIM */
accept_lock = 0;
if (ngx_accept_mutex) {
if (ngx_accept_disabled > 0) {
ngx_accept_disabled--;
} else {
if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
return NGX_ERROR;
}
if (ngx_accept_mutex_held) {
accept_lock = 1;
} else if (timer == NGX_TIMER_INFINITE
|| timer > ngx_accept_mutex_delay)
{
timer = ngx_accept_mutex_delay;
}
}
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"epoll timer: %M", timer);
@ -444,14 +408,14 @@ ngx_epoll_process_events(ngx_cycle_t *cycle)
err = 0;
}
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_current_time;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
delta = ngx_current_msec;
if (flags & NGX_UPDATE_TIME) {
ngx_time_update(0, 0);
}
if (timer != NGX_TIMER_INFINITE) {
delta = ngx_current_time - delta;
delta = ngx_current_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"epoll timer: %M, delta: %M", timer, delta);
@ -459,30 +423,34 @@ ngx_epoll_process_events(ngx_cycle_t *cycle)
if (events == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"epoll_wait() returned no events without timeout");
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
}
if (err) {
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
cycle->log, err, "epoll_wait() failed");
ngx_accept_mutex_unlock();
if (err == NGX_EINTR) {
if (ngx_event_timer_alarm) {
ngx_event_timer_alarm = 0;
return NGX_OK;
}
level = NGX_LOG_INFO;
} else {
level = NGX_LOG_ALERT;
}
ngx_log_error(level, cycle->log, err, "epoll_wait() failed");
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;
} else {
lock =0;
if (events == 0) {
return NGX_OK;
}
ngx_mutex_lock(ngx_posted_events_mutex);
log = cycle->log;
for (i = 0; i < events; i++) {
@ -539,94 +507,47 @@ ngx_epoll_process_events(ngx_cycle_t *cycle)
revents |= EPOLLIN|EPOLLOUT;
}
if ((revents & EPOLLIN) && rev->active) {
if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
rev->posted_ready = 1;
} else {
rev->ready = 1;
}
if (flags & NGX_POST_EVENTS) {
queue = (ngx_event_t **) (rev->accept ?
&ngx_posted_accept_events : &ngx_posted_events);
ngx_locked_post_event(rev, queue);
} else {
rev->handler(rev);
}
}
wev = c->write;
if ((revents & EPOLLOUT) && wev->active) {
if (ngx_threaded) {
if (flags & NGX_POST_THREAD_EVENTS) {
wev->posted_ready = 1;
ngx_post_event(wev);
} else {
wev->ready = 1;
if (!ngx_accept_mutex_held) {
wev->handler(wev);
} else {
ngx_post_event(wev);
}
}
}
/*
* EPOLLIN must be handled after EPOLLOUT because we use
* the optimization to avoid the unnecessary mutex locking/unlocking
* if the accept event is the last one.
*/
if ((revents & EPOLLIN) && rev->active) {
if (ngx_threaded && !rev->accept) {
rev->posted_ready = 1;
ngx_post_event(rev);
continue;
}
rev->ready = 1;
if (flags & NGX_POST_EVENTS) {
ngx_locked_post_event(wev, &ngx_posted_events);
if (!ngx_threaded && !ngx_accept_mutex_held) {
rev->handler(rev);
} else if (!rev->accept) {
ngx_post_event(rev);
} else if (ngx_accept_disabled <= 0) {
ngx_mutex_unlock(ngx_posted_events_mutex);
rev->handler(rev);
if (ngx_accept_disabled > 0) {
ngx_accept_mutex_unlock();
accept_lock = 0;
}
if (i + 1 == events) {
lock = 0;
break;
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
if (accept_lock) {
ngx_accept_mutex_unlock();
}
return NGX_ERROR;
}
} else {
wev->handler(wev);
}
}
}
if (accept_lock) {
ngx_accept_mutex_unlock();
}
if (lock) {
ngx_mutex_unlock(ngx_posted_events_mutex);
}
ngx_event_expire_timers();
if (ngx_posted_events) {
if (ngx_threaded) {
ngx_wakeup_worker_thread(cycle);
} else {
ngx_event_process_posted(cycle);
}
}
ngx_mutex_unlock(ngx_posted_events_mutex);
return NGX_OK;
}

85
src/event/modules/ngx_iocp_module.c
View File

@ -10,11 +10,13 @@
#include <ngx_iocp_module.h>
static ngx_int_t ngx_iocp_init(ngx_cycle_t *cycle);
static ngx_int_t ngx_iocp_init(ngx_cycle_t *cycle, ngx_msec_t timer);
static ngx_thread_value_t __stdcall ngx_iocp_timer(void *data);
static void ngx_iocp_done(ngx_cycle_t *cycle);
static ngx_int_t ngx_iocp_add_event(ngx_event_t *ev, int event, u_int key);
static ngx_int_t ngx_iocp_del_connection(ngx_connection_t *c, u_int flags);
static ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags);
static void *ngx_iocp_create_conf(ngx_cycle_t *cycle);
static char *ngx_iocp_init_conf(ngx_cycle_t *cycle, void *conf);
@ -93,11 +95,13 @@ ngx_os_io_t ngx_iocp_io = {
};
static HANDLE iocp;
static HANDLE iocp;
static ngx_tid_t timer_thread;
static ngx_msec_t msec;
static ngx_int_t
ngx_iocp_init(ngx_cycle_t *cycle)
ngx_iocp_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
ngx_iocp_conf_t *cf;
@ -109,7 +113,7 @@ ngx_iocp_init(ngx_cycle_t *cycle)
}
if (iocp == NULL) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"CreateIoCompletionPort() failed");
return NGX_ERROR;
}
@ -120,10 +124,55 @@ ngx_iocp_init(ngx_cycle_t *cycle)
ngx_event_flags = NGX_USE_AIO_EVENT|NGX_USE_IOCP_EVENT;
if (timer == 0) {
return NGX_OK;
}
/*
* The waitable timer could not be used, because
* GetQueuedCompletionStatus() does not set a thread to alertable state
*/
if (timer_thread == NULL) {
msec = timer;
if (ngx_create_thread(&timer_thread, ngx_iocp_timer, &msec, cycle->log)
!= 0)
{
return NGX_ERROR;
}
}
ngx_event_flags |= NGX_USE_TIMER_EVENT;
return NGX_OK;
}
static ngx_thread_value_t __stdcall
ngx_iocp_timer(void *data)
{
ngx_msec_t timer = *(ngx_msec_t *) data;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
"THREAD %p %p", &msec, data);
for ( ;; ) {
Sleep(timer);
ngx_time_update(0, 0);
#if 1
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0, "timer");
#endif
}
#ifdef __WATCOMC__
return 0;
#endif
}
static void
ngx_iocp_done(ngx_cycle_t *cycle)
{
@ -178,19 +227,17 @@ ngx_iocp_del_connection(ngx_connection_t *c, u_int flags)
static
ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags)
{
int rc;
u_int key;
u_long bytes;
ngx_err_t err;
ngx_msec_t timer, delta;
ngx_msec_t delta;
ngx_event_t *ev;
struct timeval tv;
ngx_event_ovlp_t *ovlp;
timer = ngx_event_find_timer();
if (timer == NGX_TIMER_INFINITE) {
timer = INFINITE;
}
@ -206,17 +253,17 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
err = 0;
}
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_current_msec;
if (flags & NGX_UPDATE_TIME) {
ngx_time_update(0, 0);
}
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"iocp: %d b:%d k:%d ov:%p", rc, bytes, key, ovlp);
delta = ngx_current_time;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (timer != INFINITE) {
delta = ngx_current_time - delta;
delta = ngx_current_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"iocp timer: %M, delta: %M", timer, delta);
@ -231,8 +278,6 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
return NGX_ERROR;
}
ngx_event_expire_timers();
return NGX_OK;
}
@ -263,8 +308,6 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, err,
"iocp: aborted event %p", ev);
ngx_event_expire_timers();
return NGX_OK;
}
@ -297,8 +340,6 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
ev->handler(ev);
ngx_event_expire_timers();
return NGX_OK;
}

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

@ -16,13 +16,14 @@ typedef struct {
} ngx_kqueue_conf_t;
static ngx_int_t ngx_kqueue_init(ngx_cycle_t *cycle);
static ngx_int_t ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer);
static void ngx_kqueue_done(ngx_cycle_t *cycle);
static ngx_int_t ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags);
static ngx_int_t ngx_kqueue_process_changes(ngx_cycle_t *cycle, ngx_uint_t try);
static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags);
static ngx_inline void ngx_kqueue_dump_event(ngx_log_t *log,
struct kevent *kev);
@ -111,8 +112,9 @@ ngx_module_t ngx_kqueue_module = {
static ngx_int_t
ngx_kqueue_init(ngx_cycle_t *cycle)
ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
struct kevent kev;
struct timespec ts;
ngx_kqueue_conf_t *kcf;
@ -191,25 +193,50 @@ ngx_kqueue_init(ngx_cycle_t *cycle)
}
}
ngx_event_flags = 0;
#if (NGX_HAVE_TIMER_EVENT)
if (timer) {
kev.ident = 0;
kev.filter = EVFILT_TIMER;
kev.flags = EV_ADD|EV_ENABLE;
kev.fflags = 0;
kev.data = timer;
kev.udata = 0;
ts.tv_sec = 0;
ts.tv_nsec = 0;
if (kevent(ngx_kqueue, &kev, 1, NULL, 0, &ts) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"kevent(EVFILT_TIMER) failed");
return NGX_ERROR;
}
ngx_event_flags |= NGX_USE_TIMER_EVENT;
}
#endif
ngx_event_flags |= NGX_USE_ONESHOT_EVENT|NGX_USE_KQUEUE_EVENT;
#if (NGX_HAVE_CLEAR_EVENT)
ngx_event_flags |= NGX_USE_CLEAR_EVENT;
#else
ngx_event_flags |= NGX_USE_LEVEL_EVENT;
#endif
#if (NGX_HAVE_LOWAT_EVENT)
ngx_event_flags |= NGX_USE_LOWAT_EVENT;
#endif
nevents = kcf->events;
ngx_io = ngx_os_io;
ngx_event_actions = ngx_kqueue_module_ctx.actions;
ngx_event_flags = NGX_USE_ONESHOT_EVENT
#if 1
#if (NGX_HAVE_CLEAR_EVENT)
|NGX_USE_CLEAR_EVENT
#else
|NGX_USE_LEVEL_EVENT
#endif
#endif
#if (NGX_HAVE_LOWAT_EVENT)
|NGX_USE_LOWAT_EVENT
#endif
|NGX_USE_KQUEUE_EVENT;
return NGX_OK;
}
@ -254,9 +281,7 @@ ngx_kqueue_add_event(ngx_event_t *ev, int event, u_int flags)
ev->disabled = 0;
ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;
if (ngx_mutex_lock(list_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(list_mutex);
#if 1
@ -317,9 +342,7 @@ ngx_kqueue_del_event(ngx_event_t *ev, int event, u_int flags)
ev->active = 0;
ev->disabled = 0;
if (ngx_mutex_lock(list_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(list_mutex);
#if 1
@ -441,56 +464,19 @@ ngx_kqueue_set_event(ngx_event_t *ev, int filter, u_int flags)
static ngx_int_t
ngx_kqueue_process_events(ngx_cycle_t *cycle)
ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags)
{
int events, n;
ngx_int_t i, instance;
ngx_uint_t lock, accept_lock;
ngx_err_t err;
ngx_msec_t timer, delta;
ngx_event_t *ev;
struct timeval tv;
struct timespec ts, *tp;
timer = ngx_event_find_timer();
#if (NGX_THREADS)
if (timer == NGX_TIMER_ERROR) {
return NGX_ERROR;
}
if (timer == NGX_TIMER_INFINITE || timer > 500) {
timer = 500;
}
#endif
accept_lock = 0;
if (ngx_accept_mutex) {
if (ngx_accept_disabled > 0) {
ngx_accept_disabled--;
} else {
if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
return NGX_ERROR;
}
if (ngx_accept_mutex_held) {
accept_lock = 1;
} else if (timer == NGX_TIMER_INFINITE
|| timer > ngx_accept_mutex_delay)
{
timer = ngx_accept_mutex_delay;
}
}
}
int events, n;
ngx_int_t i, instance;
ngx_uint_t level;
ngx_err_t err;
ngx_msec_t delta;
ngx_event_t *ev, **queue;
struct timespec ts, *tp;
if (ngx_threaded) {
if (ngx_kqueue_process_changes(cycle, 0) == NGX_ERROR) {
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
@ -521,24 +507,35 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
err = 0;
}
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_current_msec;
if (flags & NGX_UPDATE_TIME) {
ngx_time_update(0, 0);
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"kevent events: %d", events);
delta = ngx_current_time;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (err) {
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
cycle->log, err, "kevent() failed");
ngx_accept_mutex_unlock();
if (err == NGX_EINTR) {
if (ngx_event_timer_alarm) {
ngx_event_timer_alarm = 0;
return NGX_OK;
}
level = NGX_LOG_INFO;
} else {
level = NGX_LOG_ALERT;
}
ngx_log_error(level, cycle->log, err, "kevent() failed");
return NGX_ERROR;
}
if (timer != NGX_TIMER_INFINITE) {
delta = ngx_current_time - delta;
delta = ngx_current_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"kevent timer: %M, delta: %M", timer, delta);
@ -547,23 +544,16 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
if (events == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"kevent() returned no events without timeout");
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;
} else {
lock =0;
if (events == 0) {
return NGX_OK;
}
ngx_mutex_lock(ngx_posted_events_mutex);
for (i = 0; i < events; i++) {
ngx_kqueue_dump_event(cycle->log, &event_list[i]);
@ -574,6 +564,15 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
continue;
}
#if (NGX_HAVE_TIMER_EVENT)
if (event_list[i].filter == EVFILT_TIMER) {
ngx_time_update(0, 0);
continue;
}
#endif
ev = (ngx_event_t *) event_list[i].udata;
switch (event_list[i].filter) {
@ -606,7 +605,7 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
#if (NGX_THREADS)
if (ngx_threaded && !ev->accept) {
if ((flags & NGX_POST_THREAD_EVENTS) && !ev->accept) {
ev->posted_ready = 1;
ev->posted_available = event_list[i].data;
@ -615,7 +614,7 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
ev->posted_errno = event_list[i].fflags;
}
ngx_post_event(ev);
ngx_locked_post_event(ev, &ngx_posted_events);
continue;
}
@ -651,60 +650,18 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
continue;
}
if (!ngx_threaded && !ngx_accept_mutex_held) {
ev->handler(ev);
if (flags & NGX_POST_EVENTS) {
queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
&ngx_posted_events);
ngx_locked_post_event(ev, queue);
continue;
}
if (!ev->accept) {
ngx_post_event(ev);
continue;
}
if (ngx_accept_disabled > 0) {
continue;
}
ngx_mutex_unlock(ngx_posted_events_mutex);
ev->handler(ev);
if (ngx_accept_disabled > 0) {
ngx_accept_mutex_unlock();
accept_lock = 0;
}
if (i + 1 == events) {
lock = 0;
break;
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
if (accept_lock) {
ngx_accept_mutex_unlock();
}
return NGX_ERROR;
}
}
if (accept_lock) {
ngx_accept_mutex_unlock();
}
if (lock) {
ngx_mutex_unlock(ngx_posted_events_mutex);
}
ngx_event_expire_timers();
if (ngx_posted_events) {
if (ngx_threaded) {
ngx_wakeup_worker_thread(cycle);
} else {
ngx_event_process_posted(cycle);
}
}
ngx_mutex_unlock(ngx_posted_events_mutex);
return NGX_OK;
}
@ -719,14 +676,9 @@ ngx_kqueue_process_changes(ngx_cycle_t *cycle, ngx_uint_t try)
struct timespec ts;
struct kevent *changes;
if (ngx_mutex_lock(kevent_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(kevent_mutex);
if (ngx_mutex_lock(list_mutex) == NGX_ERROR) {
ngx_mutex_unlock(kevent_mutex);
return NGX_ERROR;
}
ngx_mutex_lock(list_mutex);
if (nchanges == 0) {
ngx_mutex_unlock(list_mutex);

244
src/event/modules/ngx_poll_module.c
View File

@ -9,23 +9,18 @@
#include <ngx_event.h>
static ngx_int_t ngx_poll_init(ngx_cycle_t *cycle);
static ngx_int_t ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
static void ngx_poll_done(ngx_cycle_t *cycle);
static ngx_int_t ngx_poll_add_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_poll_process_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags);
static char *ngx_poll_init_conf(ngx_cycle_t *cycle, void *conf);
static struct pollfd *event_list;
static int nevents;
#if 0
static ngx_event_t **ready_index;
#endif
static ngx_event_t *accept_events;
static ngx_str_t poll_name = ngx_string("poll");
@ -67,7 +62,7 @@ ngx_module_t ngx_poll_module = {
static ngx_int_t
ngx_poll_init(ngx_cycle_t *cycle)
ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
struct pollfd *list;
@ -91,27 +86,13 @@ ngx_poll_init(ngx_cycle_t *cycle)
}
event_list = list;
#if 0
if (ready_index) {
ngx_free(ready_index);
}
ready_index = ngx_alloc(sizeof(ngx_event_t *) * 2 * cycle->connection_n,
cycle->log);
if (ready_index == NULL) {
return NGX_ERROR;
}
#endif
}
ngx_io = ngx_os_io;
ngx_event_actions = ngx_poll_module_ctx.actions;
ngx_event_flags = NGX_USE_LEVEL_EVENT
|NGX_USE_ONESHOT_EVENT
|NGX_USE_FD_EVENT;
ngx_event_flags = NGX_USE_LEVEL_EVENT|NGX_USE_FD_EVENT;
return NGX_OK;
}
@ -121,14 +102,8 @@ static void
ngx_poll_done(ngx_cycle_t *cycle)
{
ngx_free(event_list);
#if 0
ngx_free(ready_index);
#endif
event_list = NULL;
#if 0
ready_index = NULL;
#endif
}
@ -189,10 +164,8 @@ ngx_poll_add_event(ngx_event_t *ev, int event, u_int flags)
static ngx_int_t
ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
{
ngx_uint_t i;
ngx_cycle_t **cycle;
ngx_event_t *e;
ngx_connection_t *c;
ngx_event_t *e;
ngx_connection_t *c;
c = ev->data;
@ -233,19 +206,6 @@ ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
c = ngx_cycle->files[event_list[nevents].fd];
if (c->fd == -1) {
cycle = ngx_old_cycles.elts;
for (i = 0; i < ngx_old_cycles.nelts; i++) {
if (cycle[i] == NULL) {
continue;
}
c = cycle[i]->files[event_list[nevents].fd];
if (c->fd != -1) {
break;
}
}
}
if (c->fd == -1) {
ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
"unexpected last event");
@ -275,19 +235,15 @@ ngx_poll_del_event(ngx_event_t *ev, int event, u_int flags)
static ngx_int_t
ngx_poll_process_events(ngx_cycle_t *cycle)
ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
{
int ready, revents;
ngx_err_t err;
ngx_int_t i, nready;
ngx_uint_t n, found, lock;
ngx_msec_t timer, delta;
ngx_cycle_t **old_cycle;
ngx_event_t *ev;
ngx_uint_t found, level;
ngx_msec_t delta;
ngx_event_t *ev, **queue;
ngx_connection_t *c;
struct timeval tv;
timer = ngx_event_find_timer();
/* NGX_TIMER_INFINITE == INFTIM */
@ -301,24 +257,6 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
}
#endif
if (ngx_accept_mutex) {
if (ngx_accept_disabled > 0) {
ngx_accept_disabled--;
} else {
if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
return NGX_ERROR;
}
if (ngx_accept_mutex_held == 0
&& (timer == NGX_TIMER_INFINITE
|| timer > ngx_accept_mutex_delay))
{
timer = ngx_accept_mutex_delay;
}
}
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %M", timer);
ready = poll(event_list, (u_int) nevents, (int) timer);
@ -329,24 +267,35 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
err = 0;
}
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_current_msec;
delta = ngx_current_time;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (flags & NGX_UPDATE_TIME) {
ngx_time_update(0, 0);
}
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"poll ready %d of %d", ready, nevents);
if (err) {
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
cycle->log, err, "poll() failed");
ngx_accept_mutex_unlock();
if (err == NGX_EINTR) {
if (ngx_event_timer_alarm) {
ngx_event_timer_alarm = 0;
return NGX_OK;
}
level = NGX_LOG_INFO;
} else {
level = NGX_LOG_ALERT;
}
ngx_log_error(level, cycle->log, err, "poll() failed");
return NGX_ERROR;
}
if (timer != NGX_TIMER_INFINITE) {
delta = ngx_current_time - delta;
delta = ngx_current_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"poll timer: %M, delta: %M", timer, delta);
@ -354,24 +303,23 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
if (ready == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"poll() returned no events without timeout");
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
ngx_accept_mutex_unlock();
return NGX_ERROR;
if (ready == 0) {
return NGX_OK;
}
lock = 1;
ngx_mutex_lock(ngx_posted_events_mutex);
nready = 0;
for (i = 0; i < nevents && ready; i++) {
revents = event_list[i].revents;
#if 0
#if 1
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"poll: %d: fd:%d ev:%04Xd rev:%04Xd",
i, event_list[i].fd, event_list[i].events, revents);
@ -405,19 +353,6 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
c = ngx_cycle->files[event_list[i].fd];
if (c->fd == -1) {
old_cycle = ngx_old_cycles.elts;
for (n = 0; n < ngx_old_cycles.nelts; n++) {
if (old_cycle[n] == NULL) {
continue;
}
c = old_cycle[n]->files[event_list[i].fd];
if (c->fd != -1) {
break;
}
}
}
if (c->fd == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "unexpected event");
@ -453,43 +388,31 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
found = 1;
ev = c->read;
ev->ready = 1;
if (ev->oneshot) {
if (ev->timer_set) {
ngx_del_timer(ev);
}
ngx_poll_del_event(ev, NGX_READ_EVENT, 0);
}
if ((flags & NGX_POST_THREAD_EVENTS) && !ev->accept) {
ev->posted_ready = 1;
if (ev->accept) {
ev->next = accept_events;
accept_events = ev;
} else {
ngx_post_event(ev);
ev->ready = 1;
}
#if 0
ready_index[nready++] = c->read;
#endif
queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
&ngx_posted_events);
ngx_locked_post_event(ev, queue);
}
if (revents & POLLOUT) {
found = 1;
ev = c->write;
ev->ready = 1;
if (ev->oneshot) {
if (ev->timer_set) {
ngx_del_timer(ev);
}
ngx_poll_del_event(ev, NGX_WRITE_EVENT, 0);
if (flags & NGX_POST_THREAD_EVENTS) {
ev->posted_ready = 1;
} else {
ev->ready = 1;
}
ngx_post_event(ev);
#if 0
ready_index[nready++] = c->write;
#endif
ngx_locked_post_event(ev, &ngx_posted_events);
}
if (found) {
@ -498,83 +421,12 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
}
}
#if 0
for (i = 0; i < nready; i++) {
ev = ready_index[i];
if (!ev->active) {
continue;
}
ev->ready = 1;
if (ev->oneshot) {
if (ev->timer_set) {
ngx_del_timer(ev);
}
if (ev->write) {
ngx_poll_del_event(ev, NGX_WRITE_EVENT, 0);
} else {
ngx_poll_del_event(ev, NGX_READ_EVENT, 0);
}
}
ev->handler(ev);
}
#endif
ev = accept_events;
for ( ;; ) {
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"accept event %p", ev);
if (ev == NULL) {
break;
}
ngx_mutex_unlock(ngx_posted_events_mutex);
ev->handler(ev);
if (ngx_accept_disabled > 0) {
lock = 0;
break;
}
ev = ev->next;
if (ev == NULL) {
lock = 0;
break;
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
}
ngx_accept_mutex_unlock();
accept_events = NULL;
if (lock) {
ngx_mutex_unlock(ngx_posted_events_mutex);
}
ngx_mutex_unlock(ngx_posted_events_mutex);
if (ready != 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "poll ready != events");
}
ngx_event_expire_timers();
if (!ngx_threaded) {
ngx_event_process_posted(cycle);
}
return nready;
}

229
src/event/modules/ngx_rtsig_module.c
View File

@ -38,12 +38,14 @@ typedef struct {
extern ngx_event_module_t ngx_poll_module_ctx;
static ngx_int_t ngx_rtsig_init(ngx_cycle_t *cycle);
static ngx_int_t ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer);
static void ngx_rtsig_done(ngx_cycle_t *cycle);
static ngx_int_t ngx_rtsig_add_connection(ngx_connection_t *c);
static ngx_int_t ngx_rtsig_del_connection(ngx_connection_t *c, u_int flags);
static ngx_int_t ngx_rtsig_process_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_rtsig_process_overflow(ngx_cycle_t *cycle);
static ngx_int_t ngx_rtsig_process_events(ngx_cycle_t *cycle,
ngx_msec_t timer, ngx_uint_t flags);
static ngx_int_t ngx_rtsig_process_overflow(ngx_cycle_t *cycle,
ngx_msec_t timer, ngx_uint_t flags);
static void *ngx_rtsig_create_conf(ngx_cycle_t *cycle);
static char *ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf);
@ -134,7 +136,7 @@ ngx_module_t ngx_rtsig_module = {
static ngx_int_t
ngx_rtsig_init(ngx_cycle_t *cycle)
ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
ngx_rtsig_conf_t *rtscf;
@ -144,6 +146,7 @@ ngx_rtsig_init(ngx_cycle_t *cycle)
sigaddset(&set, rtscf->signo);
sigaddset(&set, rtscf->signo + 1);
sigaddset(&set, SIGIO);
sigaddset(&set, SIGALRM);
if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
@ -279,59 +282,19 @@ ngx_rtsig_del_connection(ngx_connection_t *c, u_int flags)
static ngx_int_t
ngx_rtsig_process_events(ngx_cycle_t *cycle)
ngx_rtsig_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
{
int signo;
ngx_int_t instance;
ngx_msec_t timer, delta;
ngx_msec_t delta;
ngx_err_t err;
siginfo_t si;
ngx_event_t *rev, *wev;
struct timeval tv;
struct timespec ts, *tp;
struct sigaction sa;
ngx_connection_t *c;
ngx_rtsig_conf_t *rtscf;
if (overflow) {
timer = 0;
} else {
timer = ngx_event_find_timer();
#if (NGX_THREADS)
if (timer == NGX_TIMER_ERROR) {
return NGX_ERROR;
}
if (timer == NGX_TIMER_INFINITE || timer > 500) {
timer = 500;
}
#endif
if (ngx_accept_mutex) {
if (ngx_accept_disabled > 0) {
ngx_accept_disabled--;
} else {
ngx_accept_mutex_held = 0;
if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
return NGX_ERROR;
}
if (ngx_accept_mutex_held == 0
&& (timer == NGX_TIMER_INFINITE
|| timer > ngx_accept_mutex_delay))
{
timer = ngx_accept_mutex_delay;
}
}
}
}
if (timer == NGX_TIMER_INFINITE) {
tp = NULL;
@ -357,7 +320,6 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
if (err == NGX_EAGAIN) {
if (timer == NGX_TIMER_INFINITE) {
ngx_accept_mutex_unlock();
ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
"sigtimedwait() returned EAGAIN without timeout");
return NGX_ERROR;
@ -373,21 +335,20 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
signo, si.si_fd, si.si_band);
}
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_current_time;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
delta = ngx_current_msec;
if (flags & NGX_UPDATE_TIME) {
ngx_time_update(0, 0);
}
if (err) {
ngx_accept_mutex_unlock();
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
cycle->log, err, "sigtimedwait() failed");
return NGX_ERROR;
}
if (timer != NGX_TIMER_INFINITE) {
delta = ngx_current_time - delta;
delta = ngx_current_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"rtsig timer: %M, delta: %M", timer, delta);
@ -404,9 +365,8 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
c = ngx_cycle->files[si.si_fd];
if (c == NULL) {
/* the stale event */
ngx_accept_mutex_unlock();
/* the stale event */
return NGX_OK;
}
@ -415,84 +375,36 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
rev = c->read;
if (c->read->instance != instance) {
if (rev->instance != instance) {
/*
* the stale event from a file descriptor
* that was just closed in this iteration
*/
ngx_accept_mutex_unlock();
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"rtsig: stale event %p", c);
return NGX_OK;
}
if (si.si_band & (POLLIN|POLLHUP|POLLERR)) {
if (rev->active) {
if (ngx_threaded && !rev->accept) {
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
rev->posted_ready = 1;
ngx_post_event(rev);
ngx_mutex_unlock(ngx_posted_events_mutex);
} else {
rev->ready = 1;
if (!ngx_threaded && !ngx_accept_mutex_held) {
rev->handler(rev);
} else if (rev->accept) {
if (ngx_accept_disabled <= 0) {
rev->handler(rev);
}
} else {
ngx_post_event(rev);
}
}
}
if ((si.si_band & (POLLIN|POLLHUP|POLLERR)) && rev->active) {
rev->ready = 1;
rev->handler(rev);
}
wev = c->write;
if (si.si_band & (POLLOUT|POLLHUP|POLLERR)) {
if (wev->active) {
if (ngx_threaded) {
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
wev->posted_ready = 1;
ngx_post_event(wev);
ngx_mutex_unlock(ngx_posted_events_mutex);
} else {
wev->ready = 1;
if (!ngx_threaded && !ngx_accept_mutex_held) {
wev->handler(wev);
} else {
ngx_post_event(wev);
}
}
}
if ((si.si_band & (POLLOUT|POLLHUP|POLLERR)) && wev->active) {
wev->ready = 1;
wev->handler(wev);
}
} else if (signo == SIGALRM) {
return NGX_OK;
} else if (signo == SIGIO) {
ngx_accept_mutex_unlock();
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"rt signal queue overflowed");
@ -520,48 +432,35 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
return NGX_ERROR;
} else if (signo != -1) {
ngx_accept_mutex_unlock();
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"sigtimedwait() returned unexpected signal: %d", signo);
return NGX_ERROR;
}
ngx_accept_mutex_unlock();
ngx_event_expire_timers();
if (ngx_posted_events) {
if (ngx_threaded) {
ngx_wakeup_worker_thread(cycle);
} else {
ngx_event_process_posted(cycle);
}
}
if (signo == -1) {
return NGX_AGAIN;
} else {
if (signo != -1) {
return NGX_OK;
}
return NGX_AGAIN;
}
/* TODO: old cylces */
static ngx_int_t
ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
ngx_rtsig_process_overflow(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags)
{
int name[2], rtsig_max, rtsig_nr, events, ready;
size_t len;
ngx_int_t tested, n, i;
ngx_err_t err;
ngx_event_t *rev, *wev;
ngx_event_t *rev, *wev, **queue;
ngx_connection_t *c;
ngx_rtsig_conf_t *rtscf;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"rtsig process overflow");
rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
tested = 0;
@ -608,6 +507,9 @@ ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
for ( ;; ) {
ready = poll(overflow_list, n, 0);
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"rtsig overflow poll:%d", ready);
if (ready == -1) {
err = ngx_errno;
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
@ -626,9 +528,7 @@ ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
continue;
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(ngx_posted_events_mutex);
for (i = 0; i < n; i++) {
c = cycle->files[overflow_list[i].fd];
@ -647,13 +547,21 @@ ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
{
tested++;
if (ngx_threaded) {
if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
rev->posted_ready = 1;
ngx_post_event(rev);
} else {
rev->ready = 1;
rev->handler(rev);
}
if (flags & NGX_POST_EVENTS) {
queue = (ngx_event_t **) (rev->accept ?
&ngx_posted_accept_events : &ngx_posted_events);
ngx_locked_post_event(rev, queue);
} else {
rev->handler(rev);
}
}
@ -667,13 +575,18 @@ ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
{
tested++;
if (ngx_threaded) {
if (flags & NGX_POST_THREAD_EVENTS) {
wev->posted_ready = 1;
ngx_post_event(wev);
} else {
wev->ready = 1;
wev->handler(wev);
}
if (flags & NGX_POST_EVENTS) {
ngx_locked_post_event(wev, &ngx_posted_events);
} else {
wev->handler(wev);
}
}
}
@ -688,8 +601,8 @@ ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
* Check the current rt queue length to prevent
* the new overflow.
*
* Learn the /proc/sys/kernel/rtsig-max value because
* it can be changed since the last checking.
* learn the "/proc/sys/kernel/rtsig-max" value because
* it can be changed since the last checking
*/
name[0] = CTL_KERN;
@ -713,16 +626,17 @@ ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
}
/*
* drain the rt signal queue if the /proc/sys/kernel/rtsig-nr
* drain the rt signal queue if the /"proc/sys/kernel/rtsig-nr"
* is bigger than
* /proc/sys/kernel/rtsig-max / rtsig_overflow_threshold
* "/proc/sys/kernel/rtsig-max" / "rtsig_overflow_threshold"
*/
if (rtsig_max / rtscf->overflow_threshold < rtsig_nr) {
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"rtsig queue state: %d/%d",
rtsig_nr, rtsig_max);
while (ngx_rtsig_process_events(cycle) == NGX_OK) {
while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK)
{
/* void */
}
}
@ -734,20 +648,17 @@ ngx_rtsig_process_overflow(ngx_cycle_t *cycle)
* so drain the rt signal queue unconditionally
*/
while (ngx_rtsig_process_events(cycle) == NGX_OK) { /* void */ }
while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK) {
/* void */
}
}
tested = 0;
}
}
if (ngx_posted_events) {
if (ngx_threaded) {
ngx_wakeup_worker_thread(cycle);
} else {
ngx_event_process_posted(cycle);
}
if (flags & NGX_UPDATE_TIME) {
ngx_time_update(0, 0);
}
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,

273
src/event/modules/ngx_select_module.c
View File

@ -10,11 +10,12 @@
static ngx_int_t ngx_select_init(ngx_cycle_t *cycle);
static ngx_int_t ngx_select_init(ngx_cycle_t *cycle, ngx_msec_t timer);
static void ngx_select_done(ngx_cycle_t *cycle);
static ngx_int_t ngx_select_add_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_select_del_event(ngx_event_t *ev, int event, u_int flags);
static ngx_int_t ngx_select_process_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags);
static char *ngx_select_init_conf(ngx_cycle_t *cycle, void *conf);
@ -33,11 +34,6 @@ static int max_fd;
static ngx_uint_t nevents;
static ngx_event_t **event_index;
#if 0
static ngx_event_t **ready_index;
#endif
static ngx_event_t *accept_events;
static ngx_str_t select_name = ngx_string("select");
@ -79,7 +75,7 @@ ngx_module_t ngx_select_module = {
static ngx_int_t
ngx_select_init(ngx_cycle_t *cycle)
ngx_select_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
ngx_event_t **index;
@ -103,26 +99,15 @@ ngx_select_init(ngx_cycle_t *cycle)
ngx_memcpy(index, event_index, sizeof(ngx_event_t *) * nevents);
ngx_free(event_index);
}
event_index = index;
#if 0
if (ready_index) {
ngx_free(ready_index);
}
ready_index = ngx_alloc(sizeof(ngx_event_t *) * 2 * cycle->connection_n,
cycle->log);
if (ready_index == NULL) {
return NGX_ERROR;
}
#endif
}
ngx_io = ngx_os_io;
ngx_event_actions = ngx_select_module_ctx.actions;
ngx_event_flags = NGX_USE_LEVEL_EVENT|NGX_USE_ONESHOT_EVENT;
ngx_event_flags = NGX_USE_LEVEL_EVENT;
#if (NGX_WIN32)
max_read = max_write = 0;
@ -138,9 +123,6 @@ static void
ngx_select_done(ngx_cycle_t *cycle)
{
ngx_free(event_index);
#if 0
ngx_free(ready_index);
#endif
event_index = NULL;
}
@ -262,41 +244,22 @@ ngx_select_del_event(ngx_event_t *ev, int event, u_int flags)
static ngx_int_t
ngx_select_process_events(ngx_cycle_t *cycle)
ngx_select_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags)
{
int ready, nready;
ngx_uint_t i, found, lock;
ngx_err_t err;
ngx_msec_t timer, delta;
ngx_event_t *ev;
ngx_connection_t *c;
struct timeval tv, *tp;
#if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
static ngx_msec_t deltas = 0;
int ready, nready;
ngx_uint_t i, found;
ngx_err_t err;
ngx_msec_t delta;
ngx_event_t *ev, **queue;
ngx_connection_t *c;
struct timeval tv, *tp;
#if !(NGX_WIN32)
ngx_uint_t level;
#endif
timer = ngx_event_find_timer();
#if !(NGX_WIN32)
if (ngx_accept_mutex) {
if (ngx_accept_disabled > 0) {
ngx_accept_disabled--;
} else {
if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
return NGX_ERROR;
}
if (ngx_accept_mutex_held == 0
&& (timer == NGX_TIMER_INFINITE
|| timer > ngx_accept_mutex_delay))
{
timer = ngx_accept_mutex_delay;
}
}
}
if (max_fd == -1) {
for (i = 0; i < nevents; i++) {
c = event_index[i]->data;
@ -353,9 +316,13 @@ ngx_select_process_events(ngx_cycle_t *cycle)
#endif
#if (NGX_WIN32)
ready = select(0, &work_read_fd_set, &work_write_fd_set, NULL, tp);
#else
ready = select(max_fd + 1, &work_read_fd_set, &work_write_fd_set, NULL, tp);
#endif
if (ready == -1) {
@ -364,58 +331,14 @@ ngx_select_process_events(ngx_cycle_t *cycle)
err = 0;
}
#if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
delta = ngx_current_msec;
if (timer != NGX_TIMER_INFINITE) {
delta = timer - ((ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000);
/*
* learn the real time and update the cached time
* if the sum of the last deltas overcomes 1 second
*/
deltas += delta;
if (deltas > 1000) {
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
deltas = tv.tv_usec / 1000;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000
+ tv.tv_usec / 1000;
} else {
ngx_current_time += delta;
}
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select timer: %M, delta: %M", timer, delta);
} else {
deltas = 0;
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_current_time;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (ready == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"select() returned no events without timeout");
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
if (flags & NGX_UPDATE_TIME) {
ngx_time_update(0, 0);
}
#else /* !(NGX_HAVE_SELECT_CHANGE_TIMEOUT) */
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
delta = ngx_current_time;
ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
if (timer != NGX_TIMER_INFINITE) {
delta = ngx_current_time - delta;
delta = ngx_current_msec - delta;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select timer: %M, delta: %M", timer, delta);
@ -424,34 +347,48 @@ ngx_select_process_events(ngx_cycle_t *cycle)
if (ready == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"select() returned no events without timeout");
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
}
#endif /* NGX_HAVE_SELECT_CHANGE_TIMEOUT */
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"select ready %d", ready);
if (err) {
#if (NGX_WIN32)
if (err) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, err, "select() failed");
return NGX_ERROR;
}
#else
ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
cycle->log, err, "select() failed");
if (err) {
if (err == NGX_EINTR) {
if (ngx_event_timer_alarm) {
ngx_event_timer_alarm = 0;
return NGX_OK;
}
level = NGX_LOG_INFO;
} else {
level = NGX_LOG_ALERT;
}
ngx_log_error(level, cycle->log, err, "select() failed");
return NGX_ERROR;
}
#endif
ngx_accept_mutex_unlock();
return NGX_ERROR;
if (nevents == 0) {
return NGX_OK;
}
ngx_mutex_lock(ngx_posted_events_mutex);
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
lock = 1;
nready = 0;
for (i = 0; i < nevents; i++) {
@ -477,110 +414,20 @@ ngx_select_process_events(ngx_cycle_t *cycle)
if (found) {
ev->ready = 1;
if (ev->oneshot) {
if (ev->timer_set) {
ngx_del_timer(ev);
}
if (ev->write) {
ngx_select_del_event(ev, NGX_WRITE_EVENT, 0);
} else {
ngx_select_del_event(ev, NGX_READ_EVENT, 0);
}
}
if (ev->accept) {
ev->next = accept_events;
accept_events = ev;
} else {
ngx_post_event(ev);
}
queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
&ngx_posted_events);
ngx_locked_post_event(ev, queue);
nready++;
#if 0
ready_index[nready++] = ev;
#endif
}
}
#if 0
for (i = 0; i < nready; i++) {
ev = ready_index[i];
ready--;
if (!ev->active) {
continue;
}
ev->ready = 1;
if (ev->oneshot) {
if (ev->timer_set) {
ngx_del_timer(ev);
}
if (ev->write) {
ngx_select_del_event(ev, NGX_WRITE_EVENT, 0);
} else {
ngx_select_del_event(ev, NGX_READ_EVENT, 0);
}
}
ev->handler(ev);
}
#endif
ev = accept_events;
for ( ;; ) {
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"accept event %p", ev);
if (ev == NULL) {
break;
}
ngx_mutex_unlock(ngx_posted_events_mutex);
ev->handler(ev);
if (ngx_accept_disabled > 0) {
lock = 0;
break;
}
ev = ev->next;
if (ev == NULL) {
lock = 0;
break;
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
ngx_accept_mutex_unlock();
return NGX_ERROR;
}
}
ngx_accept_mutex_unlock();
accept_events = NULL;
if (lock) {
ngx_mutex_unlock(ngx_posted_events_mutex);
}
ngx_mutex_unlock(ngx_posted_events_mutex);
if (ready != nready) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "select ready != events");
}
ngx_event_expire_timers();
if (!ngx_threaded) {
ngx_event_process_posted(cycle);
}
return NGX_OK;
}
@ -599,19 +446,25 @@ ngx_select_init_conf(ngx_cycle_t *cycle, void *conf)
/* disable warning: the default FD_SETSIZE is 1024U in FreeBSD 5.x */
#if !(NGX_WIN32)
if ((unsigned) ecf->connections > FD_SETSIZE) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
"the maximum number of files "
"supported by select() is " ngx_value(FD_SETSIZE));
return NGX_CONF_ERROR;
}
#endif
#if (NGX_THREADS) && !(NGX_WIN32)
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
"select() is not supported in the threaded mode");
return NGX_CONF_ERROR;
#else
return NGX_CONF_OK;
#endif
}

129
src/event/ngx_event.c
View File

@ -34,6 +34,9 @@ static char *ngx_event_init_conf(ngx_cycle_t *cycle, void *conf);
static char *ngx_accept_mutex_check(ngx_conf_t *cf, void *post, void *data);
static ngx_uint_t ngx_timer_resolution;
sig_atomic_t ngx_event_timer_alarm;
static ngx_uint_t ngx_event_max_module;
ngx_uint_t ngx_event_flags;
@ -192,6 +195,77 @@ ngx_module_t ngx_event_core_module = {
};
void
ngx_process_events_and_timers(ngx_cycle_t *cycle)
{
ngx_uint_t flags;
ngx_msec_t timer;
if (ngx_timer_resolution) {
timer = NGX_TIMER_INFINITE;
flags = 0;
} else {
timer = ngx_event_find_timer();
flags = NGX_UPDATE_TIME;
#if (NGX_THREADS)
if (timer == NGX_TIMER_INFINITE || timer > 500) {
timer = 500;
}
#endif
}
if (ngx_accept_mutex) {
if (ngx_accept_disabled > 0) {
ngx_accept_disabled--;
} else {
if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
return;
}
if (ngx_accept_mutex_held) {
flags |= NGX_POST_EVENTS;
} else {
if (timer == NGX_TIMER_INFINITE
|| timer > ngx_accept_mutex_delay)
{
timer = ngx_accept_mutex_delay;
}
}
}
}
(void) ngx_process_events(cycle, timer, flags);
ngx_event_expire_timers();
if (ngx_posted_accept_events) {
ngx_event_process_posted(cycle, &ngx_posted_accept_events);
}
if (ngx_accept_mutex_held) {
ngx_accept_mutex = 0;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"posted events %p", ngx_posted_events);
if (ngx_posted_events) {
if (ngx_threaded) {
ngx_wakeup_worker_thread(cycle);
} else {
ngx_event_process_posted(cycle, &ngx_posted_events);
}
}
}
ngx_int_t
ngx_handle_read_event(ngx_event_t *rev, u_int flags)
{
@ -332,12 +406,12 @@ ngx_event_module_init(ngx_cycle_t *cycle)
{
void ***cf;
ngx_event_conf_t *ecf;
ngx_core_conf_t *ccf;
#if !(NGX_WIN32)
char *shared;
size_t size;
ngx_int_t limit;
struct rlimit rlmt;
ngx_core_conf_t *ccf;
#endif
cf = ngx_get_conf(cycle->conf_ctx, ngx_events_module);
@ -353,10 +427,12 @@ ngx_event_module_init(ngx_cycle_t *cycle)
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
"using the \"%s\" event method", ecf->name);
#if !(NGX_WIN32)
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
ngx_timer_resolution = ccf->timer_resolution;
#if !(NGX_WIN32)
if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"getrlimit(RLIMIT_NOFILE) failed, ignored");
@ -417,6 +493,8 @@ ngx_event_module_init(ngx_cycle_t *cycle)
#endif
*ngx_connection_counter = 1;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"counter: %p, %d",
ngx_connection_counter, *ngx_connection_counter);
@ -427,6 +505,23 @@ ngx_event_module_init(ngx_cycle_t *cycle)
}
#if !(NGX_WIN32)
void
ngx_timer_signal_handler(int signo)
{
ngx_event_timer_alarm = 1;
ngx_time_update(0, 0);
#if 1
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0, "timer signal");
#endif
}
#endif
static ngx_int_t
ngx_event_process_init(ngx_cycle_t *cycle)
{
@ -441,6 +536,8 @@ ngx_event_process_init(ngx_cycle_t *cycle)
ngx_iocp_conf_t *iocpcf;
#else
struct rlimit rlmt;
struct sigaction sa;
struct itimerval itv;
#endif
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
@ -473,7 +570,8 @@ ngx_event_process_init(ngx_cycle_t *cycle)
if (ngx_modules[m]->ctx_index == ecf->use) {
module = ngx_modules[m]->ctx;
if (module->actions.init(cycle) == NGX_ERROR) {
if (module->actions.init(cycle, ngx_timer_resolution) == NGX_ERROR)
{
/* fatal */
exit(2);
}
@ -483,6 +581,29 @@ ngx_event_process_init(ngx_cycle_t *cycle)
#if !(NGX_WIN32)
if (ngx_timer_resolution && !(ngx_event_flags & NGX_USE_TIMER_EVENT)) {
ngx_memzero(&sa, sizeof(struct sigaction));
sa.sa_handler = ngx_timer_signal_handler;
sigemptyset(&sa.sa_mask);
if (sigaction(SIGALRM, &sa, NULL) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"sigaction(SIGALRM) failed");
return NGX_ERROR;
}
itv.it_interval.tv_sec = ngx_timer_resolution / 1000;
itv.it_interval.tv_usec = (ngx_timer_resolution % 1000) * 1000;
itv.it_value.tv_sec = ngx_timer_resolution / 1000;
itv.it_value.tv_usec = (ngx_timer_resolution % 1000 ) * 1000;
if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"setitimer() failed");
}
}
if (ngx_event_flags & NGX_USE_FD_EVENT) {
if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {

26
src/event/ngx_event.h
View File

@ -134,6 +134,9 @@ struct ngx_event_s {
unsigned closed:1;
/* to test on worker exit */
unsigned channel:1;
#if (NGX_THREADS)
unsigned locked:1;
@ -196,9 +199,10 @@ typedef struct {
ngx_int_t (*del_conn)(ngx_connection_t *c, u_int flags);
ngx_int_t (*process_changes)(ngx_cycle_t *cycle, ngx_uint_t nowait);
ngx_int_t (*process_events)(ngx_cycle_t *cycle);
ngx_int_t (*process_events)(ngx_cycle_t *cycle, ngx_msec_t timer,
ngx_uint_t flags);
ngx_int_t (*init)(ngx_cycle_t *cycle);
ngx_int_t (*init)(ngx_cycle_t *cycle, ngx_msec_t timer);
void (*done)(ngx_cycle_t *cycle);
} ngx_event_actions_t;
@ -214,7 +218,7 @@ extern ngx_event_actions_t ngx_event_actions;
/*
* The event filter is deleted after a notification without an additional
* syscall: select, poll, kqueue, epoll, Solaris 10's event ports.
* syscall: kqueue, epoll, Solaris 10's event ports.
*/
#define NGX_USE_ONESHOT_EVENT 0x00000002
@ -270,6 +274,12 @@ extern ngx_event_actions_t ngx_event_actions;
*/
#define NGX_USE_FD_EVENT 0x00000400
/*
* The event module handles periodic or absolute timer event by itself:
* kqueue in FreeBSD 4.4 and NetBSD 2.0, Solaris 10's event ports.
*/
#define NGX_USE_TIMER_EVENT 0x00000800
/*
@ -446,13 +456,12 @@ extern ngx_atomic_t *ngx_stat_writing;
#endif
#define ngx_accept_mutex_unlock() \
if (ngx_accept_mutex_held) { \
*ngx_accept_mutex = 0; \
}
#define NGX_UPDATE_TIME 1
#define NGX_POST_EVENTS 2
#define NGX_POST_THREAD_EVENTS 4
extern sig_atomic_t ngx_event_timer_alarm;
extern ngx_uint_t ngx_event_flags;
extern ngx_module_t ngx_events_module;
extern ngx_module_t ngx_event_core_module;
@ -470,6 +479,7 @@ ngx_int_t ngx_enable_accept_events(ngx_cycle_t *cycle);
u_char *ngx_accept_log_error(ngx_log_t *log, u_char *buf, size_t len);
void ngx_process_events_and_timers(ngx_cycle_t *cycle);
ngx_int_t ngx_handle_read_event(ngx_event_t *rev, u_int flags);
ngx_int_t ngx_handle_write_event(ngx_event_t *wev, size_t lowat);

2
src/event/ngx_event_acceptex.c
View File

@ -188,7 +188,7 @@ ngx_event_post_acceptex(ngx_listening_t *ls, ngx_uint_t n)
err = ngx_socket_errno;
if (err != WSA_IO_PENDING) {
ngx_log_error(NGX_LOG_ALERT, &ls->log, err,
"AcceptEx() %s falied", ls->addr_text.data);
"AcceptEx() %V falied", &ls->addr_text);
ngx_close_posted_connection(c);
return NGX_ERROR;

80
src/event/ngx_event_busy_lock.c
View File

@ -10,7 +10,7 @@
static int ngx_event_busy_lock_look_cachable(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx);
ngx_event_busy_lock_ctx_t *ctx);
static void ngx_event_busy_lock_handler(ngx_event_t *ev);
static void ngx_event_busy_lock_posted_handler(ngx_event_t *ev);
@ -23,14 +23,12 @@ static void ngx_event_busy_lock_posted_handler(ngx_event_t *ev);
* NGX_ERROR: an error occured while the mutex locking
*/
ngx_int_t ngx_event_busy_lock(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
ngx_int_t
ngx_event_busy_lock(ngx_event_busy_lock_t *bl, ngx_event_busy_lock_ctx_t *ctx)
{
ngx_int_t rc;
if (ngx_mutex_lock(bl->mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(bl->mutex);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->event->log, 0,
"event busy lock: b:%d mb:%d",
@ -66,14 +64,13 @@ ngx_int_t ngx_event_busy_lock(ngx_event_busy_lock_t *bl,
}
ngx_int_t ngx_event_busy_lock_cachable(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
ngx_int_t
ngx_event_busy_lock_cachable(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
{
ngx_int_t rc;
if (ngx_mutex_lock(bl->mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(bl->mutex);
rc = ngx_event_busy_lock_look_cachable(bl, ctx);
@ -112,15 +109,14 @@ ngx_int_t ngx_event_busy_lock_cachable(ngx_event_busy_lock_t *bl,
}
ngx_int_t ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
void
ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
{
ngx_event_t *ev;
ngx_event_busy_lock_ctx_t *wakeup;
if (ngx_mutex_lock(bl->mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(bl->mutex);
if (bl->events) {
wakeup = bl->events;
@ -138,7 +134,7 @@ ngx_int_t ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
if (wakeup == NULL) {
ngx_mutex_unlock(bl->mutex);
return NGX_OK;
return;
}
if (ctx->md5) {
@ -152,13 +148,7 @@ ngx_int_t ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
ev = wakeup->event;
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_post_event(ev);
ngx_mutex_unlock(ngx_posted_events_mutex);
ngx_post_event(ev, &ngx_posted_events);
}
ngx_mutex_unlock(bl->mutex);
@ -177,27 +167,18 @@ ngx_int_t ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
ngx_del_timer(ev);
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_post_event(ev);
ngx_mutex_unlock(ngx_posted_events_mutex);
ngx_post_event(ev, &ngx_posted_events);
}
return NGX_OK;
}
ngx_int_t ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
void
ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
{
ngx_event_busy_lock_ctx_t *c, *p;
if (ngx_mutex_lock(bl->mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(bl->mutex);
bl->waiting--;
@ -216,13 +197,12 @@ ngx_int_t ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
}
ngx_mutex_unlock(bl->mutex);
return NGX_OK;
}
static int ngx_event_busy_lock_look_cachable(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
static ngx_int_t
ngx_event_busy_lock_look_cachable(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx)
{
ngx_int_t free;
ngx_uint_t i, bit, cachable, mask;
@ -286,21 +266,17 @@ static int ngx_event_busy_lock_look_cachable(ngx_event_busy_lock_t *bl,
}
static void ngx_event_busy_lock_handler(ngx_event_t *ev)
static void
ngx_event_busy_lock_handler(ngx_event_t *ev)
{
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return;
}
ngx_post_event(ev);
ngx_mutex_unlock(ngx_posted_events_mutex);
ev->handler = ngx_event_busy_lock_posted_handler;
ngx_post_event(ev, &ngx_posted_events);
}
static void ngx_event_busy_lock_posted_handler(ngx_event_t *ev)
static void
ngx_event_busy_lock_posted_handler(ngx_event_t *ev)
{
ngx_event_busy_lock_ctx_t *ctx;

12
src/event/ngx_event_busy_lock.h
View File

@ -52,13 +52,13 @@ typedef struct {
ngx_int_t ngx_event_busy_lock(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx);
ngx_event_busy_lock_ctx_t *ctx);
ngx_int_t ngx_event_busy_lock_cachable(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx);
ngx_int_t ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx);
ngx_int_t ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx);
ngx_event_busy_lock_ctx_t *ctx);
void ngx_event_busy_unlock(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx);
void ngx_event_busy_lock_cancel(ngx_event_busy_lock_t *bl,
ngx_event_busy_lock_ctx_t *ctx);
#endif /* _NGX_EVENT_BUSY_LOCK_H_INCLUDED_ */

3
src/event/ngx_event_connect.c
View File

@ -141,7 +141,8 @@ ngx_event_connect_peer(ngx_peer_connection_t *pc)
if (pc->rcvbuf) {
if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
(const void *) &pc->rcvbuf, sizeof(int)) == -1) {
(const void *) &pc->rcvbuf, sizeof(int)) == -1)
{
ngx_log_error(NGX_LOG_ALERT, pc->log, ngx_socket_errno,
"setsockopt(SO_RCVBUF) failed");

67
src/event/ngx_event_openssl.c
View File

@ -105,7 +105,27 @@ ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols)
return NGX_ERROR;
}
SSL_CTX_set_options(ssl->ctx, SSL_OP_ALL);
/*
* these options are needed on client side only:
* SSL_OP_MICROSOFT_SESS_ID_BUG
* SSL_OP_NETSCAPE_CHALLENGE_BUG
* SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
*/
SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG);
SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER);
/* this option allow a potential SSL 2.0 rollback (CAN-2005-2969) */
SSL_CTX_set_options(ssl->ctx, SSL_OP_MSIE_SSLV2_RSA_PADDING);
SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLEAY_080_CLIENT_DH_BUG);
SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_D5_BUG);
SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_BLOCK_PADDING_BUG);
#ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
SSL_CTX_set_options(ssl->ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
#endif
if (ngx_ssl_protocols[protocols >> 1] != 0) {
SSL_CTX_set_options(ssl->ctx, ngx_ssl_protocols[protocols >> 1]);
@ -120,20 +140,31 @@ ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols)
ngx_int_t
ngx_ssl_certificate(ngx_ssl_t *ssl, u_char *cert, u_char *key)
ngx_ssl_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *cert,
ngx_str_t *key)
{
if (SSL_CTX_use_certificate_chain_file(ssl->ctx, (char *) cert) == 0) {
ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
"SSL_CTX_use_certificate_chain_file(\"%s\") failed",
cert);
if (ngx_conf_full_name(cf->cycle, cert) == NGX_ERROR) {
return NGX_ERROR;
}
if (SSL_CTX_use_PrivateKey_file(ssl->ctx, (char *) key, SSL_FILETYPE_PEM)
if (SSL_CTX_use_certificate_chain_file(ssl->ctx, (char *) cert->data)
== 0)
{
ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
"SSL_CTX_use_PrivateKey_file(\"%s\") failed", key);
"SSL_CTX_use_certificate_chain_file(\"%s\") failed",
cert->data);
return NGX_ERROR;
}
if (ngx_conf_full_name(cf->cycle, key) == NGX_ERROR) {
return NGX_ERROR;
}
if (SSL_CTX_use_PrivateKey_file(ssl->ctx, (char *) key->data,
SSL_FILETYPE_PEM) == 0)
{
ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
"SSL_CTX_use_PrivateKey_file(\"%s\") failed", key->data);
return NGX_ERROR;
}
@ -402,13 +433,7 @@ ngx_ssl_handle_recv(ngx_connection_t *c, int n)
return NGX_ERROR;
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_post_event(c->write);
ngx_mutex_unlock(ngx_posted_events_mutex);
ngx_post_event(c->write, &ngx_posted_events);
}
return NGX_OK;
@ -632,13 +657,7 @@ ngx_ssl_write(ngx_connection_t *c, u_char *data, size_t size)
return NGX_ERROR;
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_post_event(c->read);
ngx_mutex_unlock(ngx_posted_events_mutex);
ngx_post_event(c->read, &ngx_posted_events);
}
return n;
@ -925,8 +944,8 @@ static char *
ngx_openssl_noengine(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"ssl_engine\" is not supported: " NGX_SSL_NAME
" library does not support crypto accelerators");
"\"ssl_engine\" directive is available only in "
"OpenSSL 0.9.7 and higher,");
return NGX_CONF_ERROR;
}

3
src/event/ngx_event_openssl.h
View File

@ -58,7 +58,8 @@ typedef struct {
ngx_int_t ngx_ssl_init(ngx_log_t *log);
ngx_int_t ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols);
ngx_int_t ngx_ssl_certificate(ngx_ssl_t *ssl, u_char *cert, u_char *key);
ngx_int_t ngx_ssl_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
ngx_str_t *cert, ngx_str_t *key);
ngx_int_t ngx_ssl_generate_rsa512_key(ngx_ssl_t *ssl);
ngx_int_t ngx_ssl_create_connection(ngx_ssl_t *ssl, ngx_connection_t *c,
ngx_uint_t flags);

20
src/event/ngx_event_posted.c
View File

@ -9,6 +9,7 @@
#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)
@ -16,13 +17,15 @@ ngx_mutex_t *ngx_posted_events_mutex;
#endif
void ngx_event_process_posted(ngx_cycle_t *cycle)
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 *) ngx_posted_events;
ev = (ngx_event_t *) *posted;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"posted event %p", ev);
@ -40,7 +43,8 @@ void ngx_event_process_posted(ngx_cycle_t *cycle)
#if (NGX_THREADS) && !(NGX_WIN32)
void ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
void
ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
{
ngx_int_t i;
#if 0
@ -76,7 +80,8 @@ void ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
}
ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle)
ngx_int_t
ngx_event_thread_process_posted(ngx_cycle_t *cycle)
{
ngx_event_t *ev;
@ -139,9 +144,7 @@ ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle)
ev->handler(ev);
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(ngx_posted_events_mutex);
if (ev->locked) {
ngx_unlock(ev->lock);
@ -161,7 +164,8 @@ ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle)
#else
void ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
void
ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
{
}

89
src/event/ngx_event_posted.h
View File

@ -13,43 +13,62 @@
#include <ngx_event.h>
#define ngx_post_event(ev) \
if (ev->prev == NULL) { \
ev->next = (ngx_event_t *) ngx_posted_events; \
ev->prev = (ngx_event_t **) &ngx_posted_events; \
ngx_posted_events = 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_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);
void ngx_wakeup_worker_thread(ngx_cycle_t *cycle);
extern ngx_thread_volatile ngx_event_t *ngx_posted_events;
#if (NGX_THREADS)
ngx_int_t ngx_event_thread_process_posted(ngx_cycle_t *cycle);
extern ngx_mutex_t *ngx_posted_events_mutex;
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_ */

19
src/event/ngx_event_timer.c
View File

@ -52,9 +52,7 @@ ngx_event_find_timer(void)
return NGX_TIMER_INFINITE;
}
if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
return NGX_TIMER_ERROR;
}
ngx_mutex_lock(ngx_event_timer_mutex);
root = ngx_event_timer_rbtree.root;
sentinel = ngx_event_timer_rbtree.sentinel;
@ -63,7 +61,7 @@ ngx_event_find_timer(void)
ngx_mutex_unlock(ngx_event_timer_mutex);
timer = (ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_time;
timer = (ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_msec;
return (ngx_msec_t) (timer > 0 ? timer : 0);
}
@ -79,9 +77,7 @@ ngx_event_expire_timers(void)
for ( ;; ) {
if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
return;
}
ngx_mutex_lock(ngx_event_timer_mutex);
root = ngx_event_timer_rbtree.root;
@ -93,7 +89,7 @@ ngx_event_expire_timers(void)
/* node->key <= ngx_current_time */
if ((ngx_msec_int_t) node->key - (ngx_msec_int_t) ngx_current_time <= 0)
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));
@ -133,14 +129,9 @@ ngx_event_expire_timers(void)
#if (NGX_THREADS)
if (ngx_threaded) {
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return;
}
ev->posted_timedout = 1;
ngx_post_event(ev);
ngx_mutex_unlock(ngx_posted_events_mutex);
ngx_post_event(ev, &ngx_posted_events);
ngx_unlock(ev->lock);

11
src/event/ngx_event_timer.h
View File

@ -14,7 +14,6 @@
#define NGX_TIMER_INFINITE (ngx_msec_t) -1
#define NGX_TIMER_ERROR (ngx_msec_t) -2
#define NGX_TIMER_LAZY_DELAY 300
@ -39,9 +38,7 @@ ngx_event_del_timer(ngx_event_t *ev)
"event timer del: %d: %M",
ngx_event_ident(ev->data), ev->timer.key);
if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
return;
}
ngx_mutex_lock(ngx_event_timer_mutex);
ngx_rbtree_delete(&ngx_event_timer_rbtree, &ev->timer);
@ -63,7 +60,7 @@ ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
ngx_msec_t key;
ngx_msec_int_t diff;
key = ngx_current_time + timer;
key = ngx_current_msec + timer;
if (ev->timer_set) {
@ -91,9 +88,7 @@ ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
"event timer add: %d: %M:%M",
ngx_event_ident(ev->data), timer, ev->timer.key);
if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
return;
}
ngx_mutex_lock(ngx_event_timer_mutex);
ngx_rbtree_insert(&ngx_event_timer_rbtree, &ev->timer);

5
src/http/modules/ngx_http_autoindex_module.c
View File

@ -144,6 +144,7 @@ ngx_http_autoindex_handler(ngx_http_request_t *r)
ngx_dir_t dir;
ngx_uint_t i, level;
ngx_pool_t *pool;
ngx_time_t *tp;
ngx_chain_t out;
ngx_array_t entries;
ngx_http_autoindex_entry_t *entry;
@ -372,6 +373,8 @@ ngx_http_autoindex_handler(ngx_http_request_t *r)
b->last = ngx_cpymem(b->last, "<hr><pre><a href=\"../\">../</a>" CRLF,
sizeof("<hr><pre><a href=\"../\">../</a>" CRLF) - 1);
tp = ngx_timeofday();
for (i = 0; i < entries.nelts; i++) {
b->last = ngx_cpymem(b->last, "<a href=\"", sizeof("<a href=\"") - 1);
@ -428,7 +431,7 @@ ngx_http_autoindex_handler(ngx_http_request_t *r)
*b->last++ = ' ';
ngx_gmtime(entry[i].mtime + ngx_gmtoff * 60 * alcf->localtime, &tm);
ngx_gmtime(entry[i].mtime + tp->gmtoff * 60 * alcf->localtime, &tm);
b->last = ngx_sprintf(b->last, "%02d-%s-%d %02d:%02d ",
tm.ngx_tm_mday,

1
src/http/modules/ngx_http_geo_module.c
View File

@ -123,6 +123,7 @@ ngx_http_geo_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
}
tree = ngx_radix_tree_create(cf->pool, -1);
if (tree == NULL) {
return NGX_CONF_ERROR;
}

33
src/http/modules/ngx_http_index_module.c
View File

@ -126,7 +126,8 @@ ngx_http_index_handler(ngx_http_request_t *r)
ngx_uint_t i;
ngx_http_index_t *index;
ngx_http_index_ctx_t *ctx;
ngx_pool_cleanup_file_t *cln;
ngx_pool_cleanup_t *cln;
ngx_pool_cleanup_file_t *clnf;
ngx_http_script_code_pt code;
ngx_http_script_engine_t e;
ngx_http_core_loc_conf_t *clcf;
@ -180,9 +181,9 @@ ngx_http_index_handler(ngx_http_request_t *r)
e.ip = index[i].lengths->elts;
e.request = r;
/* 1 byte for terminating '\0' and 4 bytes is preallocation */
/* 1 byte for terminating '\0' */
len = 1 + 4;
len = 1;
while (*(uintptr_t *) e.ip) {
lcode = *(ngx_http_script_len_code_pt *) e.ip;
@ -190,6 +191,10 @@ ngx_http_index_handler(ngx_http_request_t *r)
}
ctx->index.len = len;
/* 16 bytes are preallocation */
len += 16;
}
if (len > ctx->path.len) {
@ -228,6 +233,11 @@ ngx_http_index_handler(ngx_http_request_t *r)
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
"open index \"%s\"", ctx->path.data);
cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_pool_cleanup_file_t));
if (cln == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
fd = ngx_open_file(ctx->path.data, NGX_FILE_RDONLY, NGX_FILE_OPEN);
if (fd == (ngx_fd_t) NGX_AGAIN) {
@ -268,19 +278,12 @@ ngx_http_index_handler(ngx_http_request_t *r)
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
cln->handler = ngx_pool_cleanup_file;
clnf = cln->data;
cln = ngx_palloc(r->pool, sizeof(ngx_pool_cleanup_file_t));
if (cln == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
cln->fd = fd;
cln->name = ctx->path.data;
cln->log = r->pool->log;
if (ngx_pool_cleanup_add(r->pool, ngx_pool_cleanup_file, cln) == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
clnf->fd = fd;
clnf->name = ctx->path.data;
clnf->log = r->pool->log;
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

11
src/http/modules/ngx_http_ssi_filter_module.c
View File

@ -1968,6 +1968,7 @@ ngx_http_ssi_date_gmt_local_variable(ngx_http_request_t *r, uintptr_t gmt)
{
ngx_http_ssi_ctx_t *ctx;
ngx_http_variable_value_t *vv;
ngx_time_t *tp;
struct tm tm;
char buf[NGX_HTTP_SSI_DATE_LEN];
@ -1976,12 +1977,14 @@ ngx_http_ssi_date_gmt_local_variable(ngx_http_request_t *r, uintptr_t gmt)
return NULL;
}
tp = ngx_timeofday();
ctx = ngx_http_get_module_ctx(r, ngx_http_ssi_filter_module);
if (ctx->timefmt.len == sizeof("%s") - 1
&& ctx->timefmt.data[0] == '%' && ctx->timefmt.data[1] == 's')
{
vv->value = ngx_time() + (gmt ? 0 : ngx_gmtoff);
vv->value = tp->sec + (gmt ? 0 : tp->gmtoff);
vv->text.data = ngx_palloc(r->pool, NGX_TIME_T_LEN);
if (vv->text.data == NULL) {
@ -1994,12 +1997,12 @@ ngx_http_ssi_date_gmt_local_variable(ngx_http_request_t *r, uintptr_t gmt)
}
if (gmt) {
ngx_libc_gmtime(&tm);
ngx_libc_gmtime(tp->sec, &tm);
} else {
ngx_libc_localtime(&tm);
ngx_libc_localtime(tp->sec, &tm);
}
vv->value = ngx_time() + (gmt ? 0 : ngx_gmtoff);
vv->value = tp->sec + (gmt ? 0 : tp->gmtoff);
vv->text.len = strftime(buf, NGX_HTTP_SSI_DATE_LEN,
(char *) ctx->timefmt.data, &tm);

53
src/http/modules/ngx_http_ssl_module.c
View File

@ -17,6 +17,15 @@ static void *ngx_http_ssl_create_srv_conf(ngx_conf_t *cf);
static char *ngx_http_ssl_merge_srv_conf(ngx_conf_t *cf,
void *parent, void *child);
#if !defined (SSL_OP_CIPHER_SERVER_PREFERENCE)
static char *ngx_http_ssl_nosupported(ngx_conf_t *cf, ngx_command_t *cmd,
void *conf);
static char ngx_http_ssl_openssl097[] = "OpenSSL 0.9.7 and higher";
#endif
static ngx_conf_bitmask_t ngx_http_ssl_protocols[] = {
{ ngx_string("SSLv2"), NGX_SSL_SSLv2 },
@ -26,6 +35,7 @@ static ngx_conf_bitmask_t ngx_http_ssl_protocols[] = {
};
static ngx_command_t ngx_http_ssl_commands[] = {
{ ngx_string("ssl"),
@ -50,14 +60,14 @@ static ngx_command_t ngx_http_ssl_commands[] = {
NULL },
{ ngx_string("ssl_protocols"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
ngx_conf_set_bitmask_slot,
NGX_HTTP_SRV_CONF_OFFSET,
offsetof(ngx_http_ssl_srv_conf_t, protocols),
&ngx_http_ssl_protocols },
{ ngx_string("ssl_ciphers"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
ngx_conf_set_str_slot,
NGX_HTTP_SRV_CONF_OFFSET,
offsetof(ngx_http_ssl_srv_conf_t, ciphers),
@ -65,10 +75,14 @@ static ngx_command_t ngx_http_ssl_commands[] = {
{ ngx_string("ssl_prefer_server_ciphers"),
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_FLAG,
#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
ngx_conf_set_flag_slot,
NGX_HTTP_SRV_CONF_OFFSET,
offsetof(ngx_http_ssl_srv_conf_t, prefer_server_ciphers),
NULL },
#else
ngx_http_ssl_nosupported, 0, 0, ngx_http_ssl_openssl097 },
#endif
ngx_null_command
};
@ -144,6 +158,8 @@ ngx_http_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
ngx_http_ssl_srv_conf_t *prev = parent;
ngx_http_ssl_srv_conf_t *conf = child;
ngx_pool_cleanup_t *cln;
ngx_conf_merge_value(conf->enable, prev->enable, 0);
if (conf->enable == 0) {
@ -172,29 +188,37 @@ ngx_http_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
return NGX_CONF_ERROR;
}
if (ngx_pool_cleanup_add(cf->pool, ngx_ssl_cleanup_ctx, &conf->ssl) == NULL)
{
cln = ngx_pool_cleanup_add(cf->pool, 0);
if (cln == NULL) {
return NGX_CONF_ERROR;
}
if (ngx_ssl_certificate(&conf->ssl, conf->certificate.data,
conf->certificate_key.data) != NGX_OK)
cln->handler = ngx_ssl_cleanup_ctx;
cln->data = &conf->ssl;
if (ngx_ssl_certificate(cf, &conf->ssl, &conf->certificate,
&conf->certificate_key) != NGX_OK)
{
return NGX_CONF_ERROR;
}
if (SSL_CTX_set_cipher_list(conf->ssl.ctx,
(const char *) conf->ciphers.data) == 0)
(const char *) conf->ciphers.data)
== 0)
{
ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
"SSL_CTX_set_cipher_list(\"%V\") failed",
&conf->ciphers);
}
#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
if (conf->prefer_server_ciphers) {
SSL_CTX_set_options(conf->ssl.ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
}
#endif
/* a temporary 512-bit RSA key is required for export versions of MSIE */
if (ngx_ssl_generate_rsa512_key(&conf->ssl) != NGX_OK) {
return NGX_CONF_ERROR;
@ -207,3 +231,18 @@ ngx_http_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
return NGX_CONF_OK;
}
#if !defined (SSL_OP_CIPHER_SERVER_PREFERENCE)
static char *
ngx_http_ssl_nosupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"%V\" directive is available only in %s,",
&cmd->name, cmd->post);
return NGX_CONF_ERROR;
}
#endif

24
src/http/modules/ngx_http_static_module.c
View File

@ -82,7 +82,8 @@ ngx_http_static_handler(ngx_http_request_t *r)
ngx_buf_t *b;
ngx_chain_t out;
ngx_file_info_t fi;
ngx_pool_cleanup_file_t *cln;
ngx_pool_cleanup_t *cln;
ngx_pool_cleanup_file_t *clnf;
ngx_http_core_loc_conf_t *clcf;
if (r->uri.data[r->uri.len - 1] == '/') {
@ -119,6 +120,11 @@ ngx_http_static_handler(ngx_http_request_t *r)
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
"http filename: \"%s\"", path.data);
cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_pool_cleanup_file_t));
if (cln == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
fd = ngx_open_file(path.data, NGX_FILE_RDONLY, NGX_FILE_OPEN);
if (fd == NGX_INVALID_FILE) {
@ -223,18 +229,12 @@ ngx_http_static_handler(ngx_http_request_t *r)
log->action = "sending response to client";
cln = ngx_palloc(r->pool, sizeof(ngx_pool_cleanup_file_t));
if (cln == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
cln->handler = ngx_pool_cleanup_file;
clnf = cln->data;
cln->fd = fd;
cln->name = path.data;
cln->log = r->pool->log;
if (ngx_pool_cleanup_add(r->pool, ngx_pool_cleanup_file, cln) == NULL) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
clnf->fd = fd;
clnf->name = path.data;
clnf->log = r->pool->log;
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_length_n = ngx_file_size(&fi);

2
src/http/ngx_http.c
View File

@ -659,6 +659,8 @@ ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
#endif
ls->backlog = in_addr[a].conf.backlog;
ls->rcvbuf = in_addr[a].conf.rcvbuf;
ls->sndbuf = in_addr[a].conf.sndbuf;
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
ls->accept_filter = in_addr[a].conf.accept_filter;

48
src/http/ngx_http_core_module.c
View File

@ -152,11 +152,7 @@ static ngx_command_t ngx_http_core_commands[] = {
NULL },
{ ngx_string("listen"),
#if 0
NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
#else
NGX_HTTP_SRV_CONF|NGX_CONF_1MORE,
#endif
ngx_http_core_listen,
NGX_HTTP_SRV_CONF_OFFSET,
0,
@ -2010,7 +2006,7 @@ ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
ngx_http_core_srv_conf_t *scf = conf;
char *err;
ngx_str_t *value;
ngx_str_t *value, size;
ngx_uint_t n;
struct hostent *h;
ngx_http_listen_t *ls;
@ -2050,6 +2046,8 @@ ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
ls->file_name = cf->conf_file->file.name;
ls->line = cf->conf_file->line;
ls->conf.backlog = -1;
ls->conf.rcvbuf = -1;
ls->conf.sndbuf = -1;
if (inet_upstream.host.len) {
inet_upstream.host.data[inet_upstream.host.len] = '\0';
@ -2100,8 +2098,8 @@ ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
continue;
}
if (ngx_strncmp(value[n].data, "bl=", 3) == 0) {
ls->conf.backlog = ngx_atoi(value[n].data + 3, value[n].len - 3);
if (ngx_strncmp(value[n].data, "backlog=", 8) == 0) {
ls->conf.backlog = ngx_atoi(value[n].data + 8, value[n].len - 8);
ls->conf.bind = 1;
if (ls->conf.backlog == NGX_ERROR || ls->conf.backlog == 0) {
@ -2113,9 +2111,41 @@ ngx_http_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
continue;
}
if (ngx_strncmp(value[n].data, "af=", 3) == 0) {
if (ngx_strncmp(value[n].data, "rcvbuf=", 7) == 0) {
size.len = value[n].len - 7;
size.data = value[n].data + 7;
ls->conf.rcvbuf = ngx_parse_size(&size);
ls->conf.bind = 1;
if (ls->conf.rcvbuf == NGX_ERROR) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid rcvbuf \"%V\"", &value[n]);
return NGX_CONF_ERROR;
}
continue;
}
if (ngx_strncmp(value[n].data, "sndbuf=", 7) == 0) {
size.len = value[n].len - 7;
size.data = value[n].data + 7;
ls->conf.sndbuf = ngx_parse_size(&size);
ls->conf.bind = 1;
if (ls->conf.sndbuf == NGX_ERROR) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid sndbuf \"%V\"", &value[n]);
return NGX_CONF_ERROR;
}
continue;
}
if (ngx_strncmp(value[n].data, "accept_filter=", 14) == 0) {
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
ls->conf.accept_filter = (char *) &value[n].data[3];
ls->conf.accept_filter = (char *) &value[n].data[14];
ls->conf.bind = 1;
#else
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

2
src/http/ngx_http_core_module.h
View File

@ -18,6 +18,8 @@ typedef struct {
unsigned bind:1;
int backlog;
int rcvbuf;
int sndbuf;
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
char *accept_filter;

6
src/http/ngx_http_log_module.c
View File

@ -309,11 +309,11 @@ ngx_http_log_time(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
static u_char *
ngx_http_log_msec(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
{
struct timeval tv;
ngx_time_t *tp;
ngx_gettimeofday(&tv);
tp = ngx_timeofday();
return ngx_sprintf(buf, "%l.%03l", tv.tv_sec, tv.tv_usec / 1000);
return ngx_sprintf(buf, "%T.%03M", tp->sec, tp->msec);
}

9
src/http/ngx_http_request.c
View File

@ -163,15 +163,8 @@ ngx_http_init_connection(ngx_connection_t *c)
/* the deferred accept(), rtsig, aio, iocp */
if (ngx_accept_mutex) {
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
ngx_http_close_connection(c);
return;
}
ngx_post_event(rev);
ngx_mutex_unlock(ngx_posted_events_mutex);
ngx_post_event(rev, &ngx_posted_events);
#if (NGX_STAT_STUB)
ngx_atomic_fetch_add(ngx_stat_reading, 1);

74
src/http/ngx_http_upstream.c
View File

@ -66,6 +66,8 @@ static size_t ngx_http_upstream_log_status_getlen(ngx_http_request_t *r,
uintptr_t data);
static u_char *ngx_http_upstream_log_status(ngx_http_request_t *r,
u_char *buf, ngx_http_log_op_t *op);
static u_char *ngx_http_upstream_log_response_time(ngx_http_request_t *r,
u_char *buf, ngx_http_log_op_t *op);
static u_char *ngx_http_upstream_log_error(ngx_http_request_t *r, u_char *buf,
size_t len);
@ -204,6 +206,8 @@ static ngx_http_log_op_name_t ngx_http_upstream_log_fmt_ops[] = {
{ ngx_string("upstream_status"), 0, NULL,
ngx_http_upstream_log_status_getlen,
ngx_http_upstream_log_status },
{ ngx_string("upstream_response_time"), NGX_TIME_T_LEN + 4, NULL, NULL,
ngx_http_upstream_log_response_time },
{ ngx_null_string, 0, NULL, NULL, NULL }
};
@ -217,6 +221,7 @@ char *ngx_http_upstream_header_errors[] = {
void
ngx_http_upstream_init(ngx_http_request_t *r)
{
ngx_time_t *tp;
ngx_connection_t *c;
ngx_http_upstream_t *u;
ngx_http_core_loc_conf_t *clcf;
@ -286,6 +291,10 @@ ngx_http_upstream_init(ngx_http_request_t *r)
ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
tp = ngx_timeofday();
u->state->response_time = tp->sec * 1000 + tp->msec;
ngx_http_upstream_connect(r, u);
}
@ -978,6 +987,8 @@ ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
ngx_list_part_t *part;
ngx_table_elt_t *h;
ngx_event_pipe_t *p;
ngx_pool_cleanup_t *cl;
ngx_pool_cleanup_file_t *clf;
ngx_http_core_loc_conf_t *clcf;
ngx_http_upstream_header_t *hh;
ngx_http_upstream_main_conf_t *umcf;
@ -1033,6 +1044,20 @@ ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
u->header_sent = 1;
if (r->request_body->temp_file) {
for (cl = r->pool->cleanup; cl; cl = cl->next) {
if (cl->handler == ngx_pool_cleanup_file) {
clf = cl->data;
if (clf->fd == r->request_body->temp_file->file.fd) {
cl->handler(clf);
cl->handler = NULL;
break;
}
}
}
}
/* TODO: preallocate event_pipe bufs, look "Content-Length" */
#if 0
@ -1404,9 +1429,17 @@ static void
ngx_http_upstream_finalize_request(ngx_http_request_t *r,
ngx_http_upstream_t *u, ngx_int_t rc)
{
ngx_time_t *tp;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"finalize http upstream request: %i", rc);
if (u->state->response_time) {
tp = ngx_timeofday();
u->state->response_time = tp->sec * 1000 + tp->msec
- u->state->response_time;
}
u->finalize_request(r, rc);
if (u->peer.connection) {
@ -1419,8 +1452,7 @@ ngx_http_upstream_finalize_request(ngx_http_request_t *r,
u->peer.connection = NULL;
if (u->header_sent
&& (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
if (u->header_sent && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
{
rc = 0;
}
@ -1782,6 +1814,44 @@ ngx_http_upstream_log_status(ngx_http_request_t *r, u_char *buf,
}
static u_char *
ngx_http_upstream_log_response_time(ngx_http_request_t *r, u_char *buf,
ngx_http_log_op_t *op)
{
ngx_uint_t i;
ngx_http_upstream_t *u;
ngx_http_upstream_state_t *state;
u = r->upstream;
if (u == NULL) {
*buf = '-';
return buf + 1;
}
i = 0;
state = u->states.elts;
for ( ;; ) {
if (state[i].status == 0) {
*buf++ = '-';
} else {
buf = ngx_sprintf(buf, "%d.%03d",
state[i].response_time / 1000,
state[i].response_time % 1000);
}
if (++i == u->states.nelts) {
return buf;
}
*buf++ = ',';
*buf++ = ' ';
}
}
static u_char *
ngx_http_upstream_log_error(ngx_http_request_t *r, u_char *buf, size_t len)
{

6
src/http/ngx_http_upstream.h
View File

@ -29,12 +29,12 @@
typedef struct {
time_t bl_time;
ngx_msec_t bl_time;
ngx_uint_t bl_state;
ngx_uint_t status;
time_t time;
ngx_msec_t response_time;
ngx_str_t *peer;
} ngx_http_upstream_state_t;

3
src/imap/ngx_imap_core_module.c
View File

@ -411,6 +411,9 @@ ngx_imap_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
}
ls->backlog = -1;
ls->rcvbuf = -1;
ls->sndbuf = -1;
ls->addr_ntop = 1;
ls->handler = ngx_imap_init_connection;
ls->pool_size = 256;

56
src/imap/ngx_imap_ssl_module.c
View File

@ -17,6 +17,15 @@
static void *ngx_imap_ssl_create_conf(ngx_conf_t *cf);
static char *ngx_imap_ssl_merge_conf(ngx_conf_t *cf, void *parent, void *child);
#if !defined (SSL_OP_CIPHER_SERVER_PREFERENCE)
static char *ngx_imap_ssl_nosupported(ngx_conf_t *cf, ngx_command_t *cmd,
void *conf);
static char ngx_imap_ssl_openssl097[] = "OpenSSL 0.9.7 and higher";
#endif
static ngx_conf_bitmask_t ngx_imap_ssl_protocols[] = {
{ ngx_string("SSLv2"), NGX_SSL_SSLv2 },
@ -50,7 +59,7 @@ static ngx_command_t ngx_imap_ssl_commands[] = {
NULL },
{ ngx_string("ssl_protocols"),
NGX_IMAP_MAIN_CONF|NGX_IMAP_SRV_CONF|NGX_CONF_TAKE1,
NGX_IMAP_MAIN_CONF|NGX_IMAP_SRV_CONF|NGX_CONF_1MORE,
ngx_conf_set_bitmask_slot,
NGX_IMAP_SRV_CONF_OFFSET,
offsetof(ngx_imap_ssl_conf_t, protocols),
@ -65,10 +74,15 @@ static ngx_command_t ngx_imap_ssl_commands[] = {
{ ngx_string("ssl_prefer_server_ciphers"),
NGX_IMAP_MAIN_CONF|NGX_IMAP_SRV_CONF|NGX_CONF_FLAG,
#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
ngx_conf_set_flag_slot,
NGX_IMAP_SRV_CONF_OFFSET,
offsetof(ngx_imap_ssl_conf_t, prefer_server_ciphers),
NULL },
#else
ngx_imap_ssl_nosupported, 0, 0, ngx_imap_ssl_openssl097 },
#endif
ngx_null_command
};
@ -138,6 +152,8 @@ ngx_imap_ssl_merge_conf(ngx_conf_t *cf, void *parent, void *child)
ngx_imap_ssl_conf_t *prev = parent;
ngx_imap_ssl_conf_t *conf = child;
ngx_pool_cleanup_t *cln;
ngx_conf_merge_value(conf->enable, prev->enable, 0);
if (conf->enable == 0) {
@ -166,20 +182,25 @@ ngx_imap_ssl_merge_conf(ngx_conf_t *cf, void *parent, void *child)
return NGX_CONF_ERROR;
}
if (ngx_pool_cleanup_add(cf->pool, ngx_ssl_cleanup_ctx, &conf->ssl) == NULL)
{
cln = ngx_pool_cleanup_add(cf->pool, 0);
if (cln == NULL) {
return NGX_CONF_ERROR;
}
if (ngx_ssl_certificate(&conf->ssl, conf->certificate.data,
conf->certificate_key.data) != NGX_OK)
cln->handler = ngx_ssl_cleanup_ctx;
cln->data = &conf->ssl;
if (ngx_ssl_certificate(cf, &conf->ssl, &conf->certificate,
&conf->certificate_key)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
if (conf->ciphers.len) {
if (SSL_CTX_set_cipher_list(conf->ssl.ctx,
(const char *) conf->ciphers.data) == 0)
(const char *) conf->ciphers.data)
== 0)
{
ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
"SSL_CTX_set_cipher_list(\"%V\") failed",
@ -187,6 +208,14 @@ ngx_imap_ssl_merge_conf(ngx_conf_t *cf, void *parent, void *child)
}
}
#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
if (conf->prefer_server_ciphers) {
SSL_CTX_set_options(conf->ssl.ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);
}
#endif
if (ngx_ssl_generate_rsa512_key(&conf->ssl) != NGX_OK) {
return NGX_CONF_ERROR;
}
@ -198,3 +227,18 @@ ngx_imap_ssl_merge_conf(ngx_conf_t *cf, void *parent, void *child)
return NGX_CONF_OK;
}
#if !defined (SSL_OP_CIPHER_SERVER_PREFERENCE)
static char *
ngx_imap_ssl_nosupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"%V\" directive is available only in %s,",
&cmd->name, cmd->post);
return NGX_CONF_ERROR;
}
#endif

4
src/os/unix/ngx_atomic.h
View File

@ -33,6 +33,8 @@ ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add);
/* the code in src/os/unix/ngx_sunpro_x86.il */
#define ngx_memory_barrier() __asm (".volatile"); __asm (".nonvolatile")
#else /* ( __GNUC__ || __INTEL_COMPILER ) */
@ -64,6 +66,8 @@ ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add);
/* the code in src/os/unix/ngx_sunpro_amd64.il */
#define ngx_memory_barrier() __asm (".volatile"); __asm (".nonvolatile")
#else /* ( __GNUC__ || __INTEL_COMPILER ) */

3
src/os/unix/ngx_channel.c
View File

@ -207,6 +207,9 @@ ngx_add_channel_event(ngx_cycle_t *cycle, ngx_fd_t fd, ngx_int_t event,
wev->own_lock = &c->lock;
#endif
rev->channel = 1;
wev->channel = 1;
ev = (event == NGX_READ_EVENT) ? rev : wev;
ev->handler = handler;

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

@ -51,7 +51,8 @@ void **ngx_tls; /* the threads tls's array */
static int errno0; /* the main thread's errno */
static int *errnos; /* the threads errno's array */
int *__error()
int *
__error()
{
int tid;
@ -72,7 +73,8 @@ int *__error()
extern int __isthreaded;
void _spinlock(ngx_atomic_t *lock)
void
_spinlock(ngx_atomic_t *lock)
{
ngx_int_t tries;
@ -107,7 +109,8 @@ void _spinlock(ngx_atomic_t *lock)
#ifndef _spinunlock
void _spinunlock(ngx_atomic_t *lock)
void
_spinunlock(ngx_atomic_t *lock)
{
*lock = 0;
}
@ -115,8 +118,9 @@ void _spinunlock(ngx_atomic_t *lock)
#endif
ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
ngx_log_t *log)
ngx_err_t
ngx_create_thread(ngx_tid_t *tid, ngx_thread_value_t (*func)(void *arg),
void *arg, ngx_log_t *log)
{
ngx_pid_t id;
ngx_err_t err;
@ -174,7 +178,8 @@ ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
}
ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
ngx_int_t
ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
{
char *red_zone, *zone;
size_t len;
@ -264,7 +269,8 @@ ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
}
ngx_tid_t ngx_thread_self()
ngx_tid_t
ngx_thread_self()
{
ngx_int_t tid;
@ -278,7 +284,8 @@ ngx_tid_t ngx_thread_self()
}
ngx_err_t ngx_thread_key_create(ngx_tls_key_t *key)
ngx_err_t
ngx_thread_key_create(ngx_tls_key_t *key)
{
if (nkeys >= NGX_THREAD_KEYS_MAX) {
return NGX_ENOMEM;
@ -290,7 +297,8 @@ ngx_err_t ngx_thread_key_create(ngx_tls_key_t *key)
}
ngx_err_t ngx_thread_set_tls(ngx_tls_key_t key, void *value)
ngx_err_t
ngx_thread_set_tls(ngx_tls_key_t key, void *value)
{
if (key >= NGX_THREAD_KEYS_MAX) {
return NGX_EINVAL;
@ -301,7 +309,8 @@ ngx_err_t ngx_thread_set_tls(ngx_tls_key_t key, void *value)
}
ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
ngx_mutex_t *
ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
{
ngx_mutex_t *m;
union semun op;
@ -342,7 +351,8 @@ ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
}
void ngx_mutex_destroy(ngx_mutex_t *m)
void
ngx_mutex_destroy(ngx_mutex_t *m)
{
if (semctl(m->semid, 0, IPC_RMID) == -1) {
ngx_log_error(NGX_LOG_ALERT, m->log, ngx_errno,
@ -353,7 +363,8 @@ void ngx_mutex_destroy(ngx_mutex_t *m)
}
ngx_int_t ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try)
ngx_int_t
ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try)
{
uint32_t lock, old;
ngx_uint_t tries;
@ -414,7 +425,7 @@ ngx_int_t ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try)
"%D threads wait for mutex %p, "
"while only %ui threads are available",
lock & ~NGX_MUTEX_LOCK_BUSY, m, nthreads);
return NGX_ERROR;
ngx_abort();
}
if (ngx_atomic_cmp_set(&m->lock, old, lock)) {
@ -436,7 +447,7 @@ ngx_int_t ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try)
if (semop(m->semid, &op, 1) == -1) {
ngx_log_error(NGX_LOG_ALERT, m->log, ngx_errno,
"semop() failed while waiting on mutex %p", m);
return NGX_ERROR;
ngx_abort();
}
ngx_log_debug2(NGX_LOG_DEBUG_MUTEX, m->log, 0,
@ -483,13 +494,14 @@ ngx_int_t ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try)
}
ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
void
ngx_mutex_unlock(ngx_mutex_t *m)
{
uint32_t lock, old;
struct sembuf op;
if (!ngx_threaded) {
return NGX_OK;
return;
}
old = m->lock;
@ -497,7 +509,7 @@ ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
if (!(old & NGX_MUTEX_LOCK_BUSY)) {
ngx_log_error(NGX_LOG_ALERT, m->log, 0,
"trying to unlock the free mutex %p", m);
return NGX_ERROR;
ngx_abort();
}
/* free the mutex */
@ -521,7 +533,7 @@ ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
"mutex %p is unlocked", m);
return NGX_OK;
return;
}
/* check whether we need to wake up a waiting thread */
@ -558,7 +570,7 @@ ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
if (semop(m->semid, &op, 1) == -1) {
ngx_log_error(NGX_LOG_ALERT, m->log, ngx_errno,
"semop() failed while waking up on mutex %p", m);
return NGX_ERROR;
ngx_abort();
}
break;
@ -570,11 +582,12 @@ ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0,
"mutex %p is unlocked", m);
return NGX_OK;
return;
}
ngx_cond_t *ngx_cond_init(ngx_log_t *log)
ngx_cond_t *
ngx_cond_init(ngx_log_t *log)
{
ngx_cond_t *cv;
@ -592,7 +605,8 @@ ngx_cond_t *ngx_cond_init(ngx_log_t *log)
}
void ngx_cond_destroy(ngx_cond_t *cv)
void
ngx_cond_destroy(ngx_cond_t *cv)
{
if (close(cv->kq) == -1) {
ngx_log_error(NGX_LOG_ALERT, cv->log, ngx_errno,
@ -603,7 +617,8 @@ void ngx_cond_destroy(ngx_cond_t *cv)
}
ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
ngx_int_t
ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
{
int n;
ngx_err_t err;
@ -647,9 +662,7 @@ ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
cv->tid = ngx_thread_self();
}
if (ngx_mutex_unlock(m) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_unlock(m);
ngx_log_debug3(NGX_LOG_DEBUG_CORE, cv->log, 0,
"cv %p wait, kq:%d, signo:%d", cv, cv->kq, cv->signo);
@ -703,15 +716,14 @@ ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
ngx_log_debug1(NGX_LOG_DEBUG_CORE, cv->log, 0, "cv %p is waked up", cv);
if (ngx_mutex_lock(m) == NGX_ERROR) {
return NGX_ERROR;
}
ngx_mutex_lock(m);
return NGX_OK;
}
ngx_int_t ngx_cond_signal(ngx_cond_t *cv)
ngx_int_t
ngx_cond_signal(ngx_cond_t *cv)
{
ngx_err_t err;

10
src/os/unix/ngx_freebsd_rfork_thread.h
View File

@ -55,7 +55,8 @@ extern char *ngx_freebsd_kern_usrstack;
extern size_t ngx_thread_stack_size;
static ngx_inline ngx_int_t ngx_gettid()
static ngx_inline ngx_int_t
ngx_gettid()
{
char *sp;
@ -97,7 +98,8 @@ ngx_err_t ngx_thread_set_tls(ngx_tls_key_t key, void *value);
#define ngx_thread_set_tls_n "the tls key setting"
static void *ngx_thread_get_tls(ngx_tls_key_t key)
static void *
ngx_thread_get_tls(ngx_tls_key_t key)
{
if (key >= NGX_THREAD_KEYS_MAX) {
return NULL;
@ -108,9 +110,9 @@ static void *ngx_thread_get_tls(ngx_tls_key_t key)
#define ngx_mutex_trylock(m) ngx_mutex_dolock(m, 1)
#define ngx_mutex_lock(m) ngx_mutex_dolock(m, 0)
#define ngx_mutex_lock(m) (void) ngx_mutex_dolock(m, 0)
ngx_int_t ngx_mutex_dolock(ngx_mutex_t *m, ngx_int_t try);
ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m);
void ngx_mutex_unlock(ngx_mutex_t *m);
typedef int (*ngx_rfork_thread_func_pt)(void *arg);

3
src/os/unix/ngx_gcc_atomic_amd64.h
View File

@ -72,3 +72,6 @@ ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
return add;
}
#define ngx_memory_barrier() __asm__ volatile ("" ::: "memory")

7
src/os/unix/ngx_gcc_atomic_ppc.h
View File

@ -64,3 +64,10 @@ ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
return res;
}
#if (NGX_SMP)
#define ngx_memory_barrier() __asm__ volatile ("sync\n" ::: "memory")
#else
#define ngx_memory_barrier() __asm__ volatile ("" ::: "memory")
#endif

10
src/os/unix/ngx_gcc_atomic_sparc64.h
View File

@ -67,3 +67,13 @@ ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
old = res;
}
}
#if (NGX_SMP)
#define ngx_memory_barrier() \
__asm__ volatile ( \
"membar #LoadLoad | #LoadStore | #StoreStore | #StoreLoad" \
::: "memory")
#else
#define ngx_memory_barrier() __asm__ volatile ("" ::: "memory")
#endif

8
src/os/unix/ngx_gcc_atomic_x86.h
View File

@ -101,3 +101,11 @@ ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
}
#endif
/*
* on x86 the write operations go in a program order, so we need only
* to disable the gcc reorder optimizations
*/
#define ngx_memory_barrier() __asm__ volatile ("" ::: "memory")

5
src/os/unix/ngx_linux_config.h
View File

@ -98,11 +98,6 @@ extern ssize_t sendfile(int s, int fd, int32_t *offset, size_t size);
#endif
#ifndef NGX_HAVE_SELECT_CHANGE_TIMEOUT
#define NGX_HAVE_SELECT_CHANGE_TIMEOUT 1
#endif
#define NGX_HAVE_OS_SPECIFIC_INIT 1

2
src/os/unix/ngx_posix_init.c
View File

@ -50,7 +50,7 @@ ngx_os_init(ngx_log_t *log)
return NGX_ERROR;
}
ngx_max_sockets = rlmt.rlim_cur;
ngx_max_sockets = (ngx_int_t) rlmt.rlim_cur;
#if (NGX_HAVE_INHERITED_NONBLOCK)
ngx_inherited_nonblocking = 1;

7
src/os/unix/ngx_process.c
View File

@ -282,7 +282,6 @@ void
ngx_signal_handler(int signo)
{
char *action;
struct timeval tv;
ngx_int_t ignore;
ngx_err_t err;
ngx_signal_t *sig;
@ -297,8 +296,7 @@ ngx_signal_handler(int signo)
}
}
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
ngx_time_update(0, 0);
action = "";
@ -456,6 +454,7 @@ ngx_process_get_status(void)
if (err == NGX_ECHILD) {
ngx_log_error(NGX_LOG_INFO, ngx_cycle->log, errno,
"waitpid() failed");
return;
}
#endif
@ -527,6 +526,6 @@ ngx_debug_point(void)
break;
case NGX_DEBUG_POINTS_ABORT:
abort();
ngx_abort();
}
}

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

@ -21,7 +21,7 @@ static void ngx_worker_process_init(ngx_cycle_t *cycle, ngx_uint_t priority);
static void ngx_channel_handler(ngx_event_t *ev);
#if (NGX_THREADS)
static void ngx_wakeup_worker_threads(ngx_cycle_t *cycle);
static void *ngx_worker_thread_cycle(void *data);
static ngx_thread_value_t ngx_worker_thread_cycle(void *data);
#endif
#if 0
static void ngx_garbage_collector_cycle(ngx_cycle_t *cycle, void *data);
@ -69,7 +69,6 @@ ngx_master_process_cycle(ngx_cycle_t *cycle)
ngx_int_t i;
ngx_uint_t n;
sigset_t set;
struct timeval tv;
struct itimerval itv;
ngx_uint_t live;
ngx_msec_t delay;
@ -145,8 +144,7 @@ ngx_master_process_cycle(ngx_cycle_t *cycle)
sigsuspend(&set);
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
ngx_time_update(0, 0);
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "wake up");
@ -275,7 +273,7 @@ ngx_single_process_cycle(ngx_cycle_t *cycle)
for ( ;; ) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");
ngx_process_events(cycle);
ngx_process_events_and_timers(cycle);
if (ngx_terminate || ngx_quit) {
ngx_master_exit(cycle);
@ -645,6 +643,8 @@ ngx_master_exit(ngx_cycle_t *cycle)
static void
ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
{
ngx_uint_t i;
ngx_connection_t *c;
#if (NGX_THREADS)
ngx_int_t n;
ngx_err_t err;
@ -657,11 +657,6 @@ ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
#if (NGX_THREADS)
if (ngx_time_mutex_init(cycle->log) == NGX_ERROR) {
/* fatal */
exit(2);
}
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
if (ngx_threads_n) {
@ -731,7 +726,7 @@ ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");
ngx_process_events(cycle);
ngx_process_events_and_timers(cycle);
if (ngx_terminate) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
@ -740,6 +735,21 @@ ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
ngx_wakeup_worker_threads(cycle);
#endif
c = cycle->connections;
for (i = 0; i < cycle->connection_n; i++) {
if (c[i].fd != -1
&& c[i].read
&& !c[i].read->accept
&& !c[i].read->channel)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"open socket #%d left in %ui connection, "
"aborting",
c[i].fd, i);
ngx_abort();
}
}
/*
* we do not destroy cycle->pool here because a signal handler
* that uses cycle->log can be called at this point
@ -1054,7 +1064,7 @@ ngx_wakeup_worker_threads(ngx_cycle_t *cycle)
}
static void *
static ngx_thread_value_t
ngx_worker_thread_cycle(void *data)
{
ngx_thread_t *thr = data;
@ -1075,7 +1085,7 @@ ngx_worker_thread_cycle(void *data)
if (err) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
ngx_thread_sigmask_n " failed");
return (void *) 1;
return (ngx_thread_value_t) 1;
}
ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0,
@ -1085,25 +1095,23 @@ ngx_worker_thread_cycle(void *data)
tls = ngx_calloc(sizeof(ngx_core_tls_t), cycle->log);
if (tls == NULL) {
return (void *) 1;
return (ngx_thread_value_t) 1;
}
err = ngx_thread_set_tls(ngx_core_tls_key, tls);
if (err != 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
ngx_thread_set_tls_n " failed");
return (void *) 1;
return (ngx_thread_value_t) 1;
}
if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
return (void *) 1;
}
ngx_mutex_lock(ngx_posted_events_mutex);
for ( ;; ) {
thr->state = NGX_THREAD_FREE;
if (ngx_cond_wait(thr->cv, ngx_posted_events_mutex) == NGX_ERROR) {
return (void *) 1;
return (ngx_thread_value_t) 1;
}
if (ngx_terminate) {
@ -1115,22 +1123,22 @@ ngx_worker_thread_cycle(void *data)
"thread " NGX_TID_T_FMT " is done",
ngx_thread_self());
return (void *) 0;
return (ngx_thread_value_t) 0;
}
thr->state = NGX_THREAD_BUSY;
if (ngx_event_thread_process_posted(cycle) == NGX_ERROR) {
return (void *) 1;
return (ngx_thread_value_t) 1;
}
if (ngx_event_thread_process_posted(cycle) == NGX_ERROR) {
return (void *) 1;
return (ngx_thread_value_t) 1;
}
if (ngx_process_changes) {
if (ngx_process_changes(cycle, 1) == NGX_ERROR) {
return (void *) 1;
return (ngx_thread_value_t) 1;
}
}
}
@ -1185,7 +1193,7 @@ ngx_garbage_collector_cycle(ngx_cycle_t *cycle, void *data)
ngx_add_timer(ev, 60 * 60 * 1000);
ngx_process_events(cycle);
ngx_process_events_and_timers(cycle);
}
}

49
src/os/unix/ngx_pthread_thread.c
View File

@ -15,8 +15,9 @@ static ngx_uint_t max_threads;
static pthread_attr_t thr_attr;
ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
ngx_log_t *log)
ngx_err_t
ngx_create_thread(ngx_tid_t *tid, ngx_thread_value_t (*func)(void *arg),
void *arg, ngx_log_t *log)
{
int err;
@ -42,7 +43,8 @@ ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
}
ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
ngx_int_t
ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
{
int err;
@ -70,7 +72,8 @@ ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
}
ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
ngx_mutex_t *
ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
{
int err;
ngx_mutex_t *m;
@ -94,7 +97,8 @@ ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
}
void ngx_mutex_destroy(ngx_mutex_t *m)
void
ngx_mutex_destroy(ngx_mutex_t *m)
{
int err;
@ -109,12 +113,13 @@ void ngx_mutex_destroy(ngx_mutex_t *m)
}
ngx_int_t ngx_mutex_lock(ngx_mutex_t *m)
void
ngx_mutex_lock(ngx_mutex_t *m)
{
int err;
if (!ngx_threaded) {
return NGX_OK;
return;
}
ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "lock mutex %p", m);
@ -124,16 +129,17 @@ ngx_int_t ngx_mutex_lock(ngx_mutex_t *m)
if (err != 0) {
ngx_log_error(NGX_LOG_ALERT, m->log, err,
"pthread_mutex_lock(%p) failed", m);
return NGX_ERROR;
ngx_abort();
}
ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);
return NGX_OK;
return;
}
ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m)
ngx_int_t
ngx_mutex_trylock(ngx_mutex_t *m)
{
int err;
@ -152,7 +158,7 @@ ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m)
if (err != 0) {
ngx_log_error(NGX_LOG_ALERT, m->log, err,
"pthread_mutex_trylock(%p) failed", m);
return NGX_ERROR;
ngx_abort();
}
ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is locked", m);
@ -161,12 +167,13 @@ ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m)
}
ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
void
ngx_mutex_unlock(ngx_mutex_t *m)
{
int err;
if (!ngx_threaded) {
return NGX_OK;
return;
}
ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "unlock mutex %p", m);
@ -176,16 +183,17 @@ ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m)
if (err != 0) {
ngx_log_error(NGX_LOG_ALERT, m->log, err,
"pthread_mutex_unlock(%p) failed", m);
return NGX_ERROR;
ngx_abort();
}
ngx_log_debug1(NGX_LOG_DEBUG_MUTEX, m->log, 0, "mutex %p is unlocked", m);
return NGX_OK;
return;
}
ngx_cond_t *ngx_cond_init(ngx_log_t *log)
ngx_cond_t *
ngx_cond_init(ngx_log_t *log)
{
int err;
ngx_cond_t *cv;
@ -209,7 +217,8 @@ ngx_cond_t *ngx_cond_init(ngx_log_t *log)
}
void ngx_cond_destroy(ngx_cond_t *cv)
void
ngx_cond_destroy(ngx_cond_t *cv)
{
int err;
@ -224,7 +233,8 @@ void ngx_cond_destroy(ngx_cond_t *cv)
}
ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
ngx_int_t
ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
{
int err;
@ -246,7 +256,8 @@ ngx_int_t ngx_cond_wait(ngx_cond_t *cv, ngx_mutex_t *m)
}
ngx_int_t ngx_cond_signal(ngx_cond_t *cv)
ngx_int_t
ngx_cond_signal(ngx_cond_t *cv)
{
int err;

5
src/os/unix/ngx_socket.c
View File

@ -13,7 +13,7 @@
* while fcntl(F_SETFL, ~O_NONBLOCK) needs to learn before
* the previous state using fcntl(F_GETFL).
*
* ioctl() and fcntl() are syscalls on at least FreeBSD 2.x, Linux 2.2
* ioctl() and fcntl() are syscalls at least in FreeBSD 2.x, Linux 2.2
* and Solaris 7.
*
* ioctl() in Linux 2.4 and 2.6 uses BKL, however, fcntl(F_SETFL) uses it too.
@ -73,6 +73,7 @@ ngx_tcp_push(ngx_socket_t s)
#elif (NGX_LINUX)
int
ngx_tcp_nopush(ngx_socket_t s)
{
@ -84,6 +85,7 @@ ngx_tcp_nopush(ngx_socket_t s)
(const void *) &cork, sizeof(int));
}
int
ngx_tcp_push(ngx_socket_t s)
{
@ -103,6 +105,7 @@ ngx_tcp_nopush(ngx_socket_t s)
return 0;
}
int
ngx_tcp_push(ngx_socket_t s)
{

6
src/os/unix/ngx_sunpro_atomic_sparc64.h
View File

@ -50,3 +50,9 @@ ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
old = res;
}
}
#define ngx_memory_barrier() \
__asm (".volatile"); \
__asm ("membar #LoadLoad | #LoadStore | #StoreStore | #StoreLoad"); \
__asm (".nonvolatile")

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

@ -66,8 +66,8 @@ typedef struct {
ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m);
ngx_int_t ngx_mutex_lock(ngx_mutex_t *m);
ngx_int_t ngx_mutex_unlock(ngx_mutex_t *m);
void ngx_mutex_lock(ngx_mutex_t *m);
void ngx_mutex_unlock(ngx_mutex_t *m);
#endif
@ -90,10 +90,11 @@ extern ngx_int_t ngx_threads_n;
extern volatile ngx_thread_t ngx_threads[NGX_MAX_THREADS];
ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle);
ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
ngx_log_t *log);
typedef void * ngx_thread_value_t;
ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle);
ngx_err_t ngx_create_thread(ngx_tid_t *tid,
ngx_thread_value_t (*func)(void *arg), void *arg, ngx_log_t *log);
ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags);
void ngx_mutex_destroy(ngx_mutex_t *m);
@ -113,7 +114,7 @@ ngx_int_t ngx_cond_signal(ngx_cond_t *cv);
#define NGX_TID_T_FMT "%d"
#define ngx_mutex_trylock(m) NGX_OK
#define ngx_mutex_lock(m) NGX_OK
#define ngx_mutex_lock(m)
#define ngx_mutex_unlock(m)
#define ngx_cond_signal(cv)

36
src/os/unix/ngx_time.c
View File

@ -8,20 +8,16 @@
#include <ngx_core.h>
void ngx_localtime(ngx_tm_t *tm)
void
ngx_localtime(time_t s, ngx_tm_t *tm)
{
#if (NGX_HAVE_LOCALTIME_R)
time_t now;
now = ngx_time();
(void) localtime_r(&now, tm);
(void) localtime_r(&s, tm);
#else
time_t now;
ngx_tm_t *t;
now = ngx_time();
t = localtime(&now);
t = localtime(&s);
*tm = *t;
#endif
@ -31,40 +27,32 @@ void ngx_localtime(ngx_tm_t *tm)
}
void ngx_libc_localtime(struct tm *tm)
void
ngx_libc_localtime(time_t s, struct tm *tm)
{
#if (NGX_HAVE_LOCALTIME_R)
time_t now;
now = ngx_time();
(void) localtime_r(&now, tm);
(void) localtime_r(&s, tm);
#else
time_t now;
struct tm *t;
now = ngx_time();
t = localtime(&now);
t = localtime(&s);
*tm = *t;
#endif
}
void ngx_libc_gmtime(struct tm *tm)
void
ngx_libc_gmtime(time_t s, struct tm *tm)
{
#if (NGX_HAVE_LOCALTIME_R)
time_t now;
now = ngx_time();
(void) gmtime_r(&now, tm);
(void) gmtime_r(&s, tm);
#else
time_t now;
struct tm *t;
now = ngx_time();
t = gmtime(&now);
t = gmtime(&s);
*tm = *t;
#endif

6
src/os/unix/ngx_time.h
View File

@ -52,9 +52,9 @@ typedef struct tm ngx_tm_t;
#endif
void ngx_localtime(ngx_tm_t *tm);
void ngx_libc_localtime(struct tm *tm);
void ngx_libc_gmtime(struct tm *tm);
void ngx_localtime(time_t s, ngx_tm_t *tm);
void ngx_libc_localtime(time_t s, struct tm *tm);
void ngx_libc_gmtime(time_t s, struct tm *tm);
#define ngx_gettimeofday(tp) (void) gettimeofday(tp, NULL);
#define ngx_msleep(ms) (void) usleep(ms * 1000)

3
src/os/win32/ngx_atomic.h
View File

@ -41,6 +41,9 @@ typedef volatile ngx_atomic_uint_t ngx_atomic_t;
#define ngx_atomic_fetch_add(p, add) InterlockedExchangeAdd((long *) p, add)
#define ngx_memory_barrier()
void ngx_spinlock(ngx_atomic_t *lock, ngx_uint_t spin);
#define ngx_trylock(lock) (*(lock) == 0 && ngx_atomic_cmp_set(lock, 0, 1))

8
src/os/win32/ngx_process_cycle.c
View File

@ -10,7 +10,7 @@
#include <nginx.h>
static void *ngx_worker_thread_cycle(void *data);
static ngx_thread_value_t __stdcall ngx_worker_thread_cycle(void *data);
static long __stdcall ngx_window_procedure(HWND window, u_int message,
u_int wparam, long lparam);
@ -202,7 +202,7 @@ ngx_single_process_cycle(ngx_cycle_t *cycle)
}
static void *
static ngx_thread_value_t __stdcall
ngx_worker_thread_cycle(void *data)
{
ngx_cycle_t *cycle;
@ -212,10 +212,10 @@ ngx_worker_thread_cycle(void *data)
while (!ngx_quit) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");
ngx_process_events(cycle);
ngx_process_events_and_timers(cycle);
}
return NULL;
return 0;
}

31
src/os/win32/ngx_thread.c
View File

@ -14,13 +14,13 @@ ngx_int_t ngx_threads_n;
static size_t stack_size;
ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
ngx_log_t *log)
ngx_err_t
ngx_create_thread(ngx_tid_t *tid,
ngx_thread_value_t (__stdcall *func)(void *arg), void *arg, ngx_log_t *log)
{
ngx_err_t err;
*tid = CreateThread(NULL, stack_size,
(LPTHREAD_START_ROUTINE) func, arg, 0, NULL);
*tid = CreateThread(NULL, stack_size, func, arg, 0, NULL);
if (*tid != NULL) {
return 0;
@ -32,7 +32,8 @@ ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg), void *arg,
}
ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
ngx_int_t
ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
{
stack_size = size;
@ -40,7 +41,8 @@ ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle)
}
ngx_err_t ngx_thread_key_create(ngx_tls_key_t *key)
ngx_err_t
ngx_thread_key_create(ngx_tls_key_t *key)
{
*key = TlsAlloc();
@ -52,7 +54,8 @@ ngx_err_t ngx_thread_key_create(ngx_tls_key_t *key)
}
ngx_err_t ngx_thread_set_tls(ngx_tls_key_t *key, void *data)
ngx_err_t
ngx_thread_set_tls(ngx_tls_key_t *key, void *data)
{
if (TlsSetValue(*key, data) == 0) {
return ngx_errno;
@ -62,7 +65,8 @@ ngx_err_t ngx_thread_set_tls(ngx_tls_key_t *key, void *data)
}
ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
ngx_mutex_t *
ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
{
return (ngx_mutex_t *) 1;
}
@ -70,15 +74,22 @@ ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags)
/* STUB */
ngx_int_t
void
ngx_mutex_lock(ngx_mutex_t *m) {
return NGX_OK;
return;
}
ngx_int_t
ngx_mutex_trylock(ngx_mutex_t *m) {
return NGX_OK;
}
void
ngx_mutex_unlock(ngx_mutex_t *m) {
return;
}
/**/

10
src/os/win32/ngx_thread.h
View File

@ -14,6 +14,7 @@
typedef HANDLE ngx_tid_t;
typedef DWORD ngx_tls_key_t;
typedef DWORD ngx_thread_value_t;
typedef struct {
@ -22,8 +23,8 @@ typedef struct {
} ngx_mutex_t;
ngx_err_t ngx_create_thread(ngx_tid_t *tid, void* (*func)(void *arg),
void *arg, ngx_log_t *log);
ngx_err_t ngx_create_thread(ngx_tid_t *tid,
ngx_thread_value_t (__stdcall *func)(void *arg), void *arg, ngx_log_t *log);
ngx_int_t ngx_init_threads(int n, size_t size, ngx_cycle_t *cycle);
ngx_err_t ngx_thread_key_create(ngx_tls_key_t *key);
@ -41,14 +42,13 @@ ngx_err_t ngx_thread_set_tls(ngx_tls_key_t *key, void *data);
ngx_mutex_t *ngx_mutex_init(ngx_log_t *log, ngx_uint_t flags);
ngx_int_t ngx_mutex_lock(ngx_mutex_t *m);
void ngx_mutex_lock(ngx_mutex_t *m);
ngx_int_t ngx_mutex_trylock(ngx_mutex_t *m);
void ngx_mutex_unlock(ngx_mutex_t *m);
/* STUB */
#define NGX_MUTEX_LIGHT 0
#define ngx_mutex_unlock(m)
/**/

20
src/os/win32/ngx_time.c
View File

@ -8,7 +8,8 @@
#include <ngx_core.h>
void ngx_gettimeofday(struct timeval *tp)
void
ngx_gettimeofday(struct timeval *tp)
{
uint64_t intervals;
FILETIME ft;
@ -36,29 +37,28 @@ void ngx_gettimeofday(struct timeval *tp)
}
void ngx_libc_localtime(struct tm *tm)
void
ngx_libc_localtime(time_t s, struct tm *tm)
{
time_t now;
struct tm *t;
now = ngx_time();
t = localtime(&now);
t = localtime(&s);
*tm = *t;
}
void ngx_libc_gmtime(struct tm *tm)
void
ngx_libc_gmtime(time_t s, struct tm *tm)
{
time_t now;
struct tm *t;
now = ngx_time();
t = gmtime(&now);
t = gmtime(&s);
*tm = *t;
}
ngx_int_t ngx_gettimezone(void)
ngx_int_t
ngx_gettimezone(void)
{
TIME_ZONE_INFORMATION tz;

4
src/os/win32/ngx_time.h
View File

@ -40,8 +40,8 @@ typedef FILETIME ngx_mtime_t;
#define NGX_HAVE_GETTIMEZONE 1
ngx_int_t ngx_gettimezone(void);
void ngx_libc_localtime(struct tm *tm);
void ngx_libc_gmtime(struct tm *tm);
void ngx_libc_localtime(time_t s, struct tm *tm);
void ngx_libc_gmtime(time_t s, struct tm *tm);
void ngx_gettimeofday(struct timeval *tp);

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

@ -8,6 +8,10 @@
#define _NGX_WIN32_CONFIG_H_INCLUDED_
#define WIN32 0x0400
#define _WIN32_WINNT 0x0400
#define STRICT
#define WIN32_LEAN_AND_MEAN