case "$NGX_PLATFORM" in
*:sun4u)
- # "-mcpu=v9" enables the "casxa" assembler instruction
+ # "-mcpu=v9" enables the "casa" assembler instruction
CFLAGS="$CFLAGS -mcpu=v9"
;;
# 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"
;;
# 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"
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"
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 ?
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
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
# 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
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
# 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"
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
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
# 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"
<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">
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,
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;
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);
#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"
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;
}
#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
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
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;
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;
}
#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,
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;
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 */
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;
}
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;
+ continue;
}
- /* 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);
}
}
+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)
{
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);
* before we clean the connection
*/
- if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_OK) {
-
- if (c->read->prev) {
- ngx_delete_posted_event(c->read);
- }
+ ngx_mutex_lock(ngx_posted_events_mutex);
- if (c->write->prev) {
- ngx_delete_posted_event(c->write);
- }
+ if (c->read->prev) {
+ ngx_delete_posted_event(c->read);
+ }
- c->read->closed = 1;
- c->write->closed = 1;
+ if (c->write->prev) {
+ ngx_delete_posted_event(c->write);
+ }
- if (c->single_connection) {
- ngx_unlock(&c->lock);
- c->read->locked = 0;
- c->write->locked = 0;
- }
+ c->read->closed = 1;
+ c->write->closed = 1;
- ngx_mutex_unlock(ngx_posted_events_mutex);
+ 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) {
int family;
int type;
+
int backlog;
+ int rcvbuf;
+ int sndbuf;
/* handler of accepted connection */
ngx_connection_handler_pt handler;
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;
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);
#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;
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;
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;
}
}
- 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);
}
}
}
}
-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;
#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;
}
-void ngx_delete_pidfile(ngx_cycle_t *cycle)
+void
+ngx_delete_pidfile(ngx_cycle_t *cycle)
{
u_char *name;
ngx_core_conf_t *ccf;
#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;
}
-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;
ngx_flag_t daemon;
ngx_flag_t master;
+ ngx_msec_t timer_resolution;
+
ngx_int_t worker_processes;
ngx_int_t debug_points;
{
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;
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
"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;
}
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;
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;
}
{
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);
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);
#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];
scale = 1;
}
- size = ngx_atoi(line->data, len);
+ size = ngx_atosz(line->data, len);
if (size == NGX_ERROR) {
return NGX_ERROR;
}
}
-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;
#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);
for ( ;; ) {
if (node->parent->right == node) {
node->parent->right = NULL;
+
} else {
node->parent->left = NULL;
}
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;
}
}
* 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)
#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_mutex_t *ngx_time_mutex;
-
-#else
+static ngx_uint_t slot = NGX_TIME_SLOTS;
+static ngx_atomic_t ngx_time_lock;
-#define NGX_TIME_SLOTS 1
-#define slot 0
+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;
-#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" };
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);
-}
-
-
-#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;
+ ngx_time_update(0, 0);
}
-#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;
-
- if (ngx_time() == s) {
- return;
- }
-
-#if (NGX_THREADS)
+ u_char *p0, *p1, *p2;
+ ngx_tm_t tm, gmt;
+ ngx_time_t *tp;
+ struct timeval tv;
- if (ngx_mutex_trylock(ngx_time_mutex) != NGX_OK) {
+ if (!ngx_trylock(&ngx_time_lock)) {
return;
}
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;
- p = cached_http_time[slot];
+ if (tp->sec == sec) {
+ ngx_unlock(&ngx_time_lock);
+ return;
+ }
+
+ tp->sec = sec;
- (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_gmtime(sec, &gmt);
- 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;
-
- p = cached_http_log_time[slot];
+ p2 = 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));
+ tp->gmtoff < 0 ? '-' : '+',
+ ngx_abs(tp->gmtoff / 60), ngx_abs(tp->gmtoff % 60));
- ngx_cached_http_log_time.data = p;
+ ngx_memory_barrier();
-#if (NGX_THREADS)
- ngx_mutex_unlock(ngx_time_mutex);
-#endif
+ 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);
}
#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))
-
-#define ngx_time() *ngx_cached_time
-extern volatile time_t *ngx_cached_time;
-
-#else
-
-#define ngx_time() ngx_cached_time
-extern volatile time_t ngx_cached_time;
-
-#endif
+extern volatile ngx_time_t *ngx_cached_time;
-extern ngx_thread_volatile ngx_str_t ngx_cached_err_log_time;
-extern ngx_thread_volatile ngx_str_t ngx_cached_http_time;
-extern ngx_thread_volatile ngx_str_t ngx_cached_http_log_time;
+#define ngx_time() ngx_cached_time->sec
+#define ngx_timeofday() (ngx_time_t *) ngx_cached_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_ */
#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 = {
#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;
}
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 */
} 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);
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;
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);
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;
}
}
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);
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];
revents |= POLLIN|POLLOUT;
}
- wev = c->write;
+ rev = c->read;
- if ((revents & POLLOUT) && wev->active) {
- wev->ready = 1;
+ if ((revents & POLLIN) && rev->active) {
- if (!ngx_threaded && !ngx_accept_mutex_held) {
- wev->handler(wev);
+ if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
+ rev->posted_ready = 1;
} else {
- ngx_post_event(wev);
+ rev->ready = 1;
}
- }
- /*
- * 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.
- */
+ if (flags & NGX_POST_EVENTS) {
+ queue = (ngx_event_t **) (rev->accept ?
+ &ngx_posted_accept_events : &ngx_posted_events);
- rev = c->read;
-
- if ((revents & POLLIN) && rev->active) {
- rev->ready = 1;
+ ngx_locked_post_event(rev, queue);
- if (!ngx_threaded && !ngx_accept_mutex_held) {
+ } 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;
}
} 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);
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;
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);
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);
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();
- return NGX_ERROR;
- }
+ if (err == NGX_EINTR) {
- if (events > 0) {
- if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
- ngx_accept_mutex_unlock();
- return NGX_ERROR;
- }
+ if (ngx_event_timer_alarm) {
+ ngx_event_timer_alarm = 0;
+ return NGX_OK;
+ }
+
+ level = NGX_LOG_INFO;
+
+ } else {
+ level = NGX_LOG_ALERT;
+ }
- lock = 1;
+ ngx_log_error(level, cycle->log, err, "epoll_wait() failed");
+ return NGX_ERROR;
+ }
- } 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++) {
revents |= EPOLLIN|EPOLLOUT;
}
- wev = c->write;
-
- if ((revents & EPOLLOUT) && wev->active) {
-
- if (ngx_threaded) {
- 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) {
+ if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
rev->posted_ready = 1;
- ngx_post_event(rev);
-
- continue;
+ } else {
+ rev->ready = 1;
}
- rev->ready = 1;
-
- if (!ngx_threaded && !ngx_accept_mutex_held) {
- rev->handler(rev);
-
- } else if (!rev->accept) {
- ngx_post_event(rev);
+ if (flags & NGX_POST_EVENTS) {
+ queue = (ngx_event_t **) (rev->accept ?
+ &ngx_posted_accept_events : &ngx_posted_events);
- } else if (ngx_accept_disabled <= 0) {
-
- ngx_mutex_unlock(ngx_posted_events_mutex);
+ ngx_locked_post_event(rev, queue);
+ } else {
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;
- }
}
}
- }
- if (accept_lock) {
- ngx_accept_mutex_unlock();
- }
+ wev = c->write;
- if (lock) {
- ngx_mutex_unlock(ngx_posted_events_mutex);
- }
+ if ((revents & EPOLLOUT) && wev->active) {
- ngx_event_expire_timers();
+ if (flags & NGX_POST_THREAD_EVENTS) {
+ wev->posted_ready = 1;
+
+ } else {
+ wev->ready = 1;
+ }
- if (ngx_posted_events) {
- if (ngx_threaded) {
- ngx_wakeup_worker_thread(cycle);
+ if (flags & NGX_POST_EVENTS) {
+ ngx_locked_post_event(wev, &ngx_posted_events);
- } else {
- ngx_event_process_posted(cycle);
+ } else {
+ wev->handler(wev);
+ }
}
}
+ ngx_mutex_unlock(ngx_posted_events_mutex);
+
return NGX_OK;
}
#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);
};
-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;
}
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;
}
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)
{
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;
}
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);
return NGX_ERROR;
}
- ngx_event_expire_timers();
-
return NGX_OK;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, err,
"iocp: aborted event %p", ev);
- ngx_event_expire_timers();
-
return NGX_OK;
}
ev->handler(ev);
- ngx_event_expire_timers();
-
return NGX_OK;
}
} 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);
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;
}
}
- nevents = kcf->events;
+ ngx_event_flags = 0;
- ngx_io = ngx_os_io;
+#if (NGX_HAVE_TIMER_EVENT)
- ngx_event_actions = ngx_kqueue_module_ctx.actions;
+ 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;
- ngx_event_flags = NGX_USE_ONESHOT_EVENT
-#if 1
#if (NGX_HAVE_CLEAR_EVENT)
- |NGX_USE_CLEAR_EVENT
+ ngx_event_flags |= NGX_USE_CLEAR_EVENT;
#else
- |NGX_USE_LEVEL_EVENT
-#endif
+ ngx_event_flags |= NGX_USE_LEVEL_EVENT;
#endif
+
#if (NGX_HAVE_LOWAT_EVENT)
- |NGX_USE_LOWAT_EVENT
+ ngx_event_flags |= NGX_USE_LOWAT_EVENT;
#endif
- |NGX_USE_KQUEUE_EVENT;
+
+ nevents = kcf->events;
+
+ ngx_io = ngx_os_io;
+
+ ngx_event_actions = ngx_kqueue_module_ctx.actions;
return NGX_OK;
}
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
ev->active = 0;
ev->disabled = 0;
- if (ngx_mutex_lock(list_mutex) == NGX_ERROR) {
- return NGX_ERROR;
- }
+ ngx_mutex_lock(list_mutex);
#if 1
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;
}
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);
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]);
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) {
#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;
ev->posted_errno = event_list[i].fflags;
}
- ngx_post_event(ev);
+ ngx_locked_post_event(ev, &ngx_posted_events);
continue;
}
continue;
}
- if (!ngx_threaded && !ngx_accept_mutex_held) {
- ev->handler(ev);
- continue;
- }
+ if (flags & NGX_POST_EVENTS) {
+ queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
+ &ngx_posted_events);
+ ngx_locked_post_event(ev, queue);
- 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;
}
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);
#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");
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;
}
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;
}
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
}
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;
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");
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 */
}
#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);
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);
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);
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");
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) {
}
}
-#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;
}
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);
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;
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,
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;
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;
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);
c = ngx_cycle->files[si.si_fd];
if (c == NULL) {
- /* the stale event */
- ngx_accept_mutex_unlock();
+ /* the stale event */
return NGX_OK;
}
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 ((si.si_band & (POLLOUT|POLLHUP|POLLERR)) && wev->active) {
+ wev->ready = 1;
+ wev->handler(wev);
+ }
- if (!ngx_threaded && !ngx_accept_mutex_held) {
- wev->handler(wev);
+ } else if (signo == SIGALRM) {
- } else {
- ngx_post_event(wev);
- }
- }
- }
- }
+ return NGX_OK;
} else if (signo == SIGIO) {
- ngx_accept_mutex_unlock();
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"rt signal queue overflowed");
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;
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,
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];
{
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);
}
}
{
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);
}
}
}
* 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;
}
/*
- * 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 */
}
}
* 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,
-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);
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");
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;
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
+ event_index = index;
}
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;
ngx_select_done(ngx_cycle_t *cycle)
{
ngx_free(event_index);
-#if 0
- ngx_free(ready_index);
-#endif
event_index = NULL;
}
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;
#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) {
err = 0;
}
-#if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
-
- 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;
+ delta = ngx_current_msec;
- 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);
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");
-#else
- ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
- cycle->log, err, "select() failed");
-#endif
- ngx_accept_mutex_unlock();
return NGX_ERROR;
}
+#else
+
+ 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;
+ }
- if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
- ngx_accept_mutex_unlock();
+ ngx_log_error(level, cycle->log, err, "select() failed");
return NGX_ERROR;
}
- lock = 1;
+#endif
+
+ if (nevents == 0) {
+ return NGX_OK;
+ }
+
+ ngx_mutex_lock(ngx_posted_events_mutex);
+
nready = 0;
for (i = 0; i < nevents; i++) {
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;
}
/* 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
}
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;
};
+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)
{
{
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);
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");
#endif
+ *ngx_connection_counter = 1;
+
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"counter: %p, %d",
ngx_connection_counter, *ngx_connection_counter);
}
+#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)
{
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);
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);
}
#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) {
unsigned closed:1;
+ /* to test on worker exit */
+ unsigned channel:1;
+
#if (NGX_THREADS)
unsigned locked:1;
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;
/*
* 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
*/
#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
+
/*
#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;
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);
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;
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);
* 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",
}
-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);
}
-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;
if (wakeup == NULL) {
ngx_mutex_unlock(bl->mutex);
- return NGX_OK;
+ return;
}
if (ctx->md5) {
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);
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--;
}
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;
}
-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;
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_ */
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");
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]);
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) {
+ if (ngx_conf_full_name(cf->cycle, cert) == NGX_ERROR) {
+ return NGX_ERROR;
+ }
+
+ 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_certificate_chain_file(\"%s\") failed",
- cert);
+ cert->data);
return NGX_ERROR;
}
- if (SSL_CTX_use_PrivateKey_file(ssl->ctx, (char *) key, SSL_FILETYPE_PEM)
- == 0)
+ 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);
+ "SSL_CTX_use_PrivateKey_file(\"%s\") failed", key->data);
return NGX_ERROR;
}
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;
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;
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;
}
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);
#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)
#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);
#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
}
-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;
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);
#else
-void ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
+void
+ngx_wakeup_worker_thread(ngx_cycle_t *cycle)
{
}
#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); \
- }
+#if (NGX_THREADS)
+extern ngx_mutex_t *ngx_posted_events_mutex;
+#endif
-#define ngx_delete_posted_event(ev) \
- *(ev->prev) = ev->next; \
+
+#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->prev; \
+ ev->next->prev = &ev->next; \
} \
- ev->prev = NULL; \
+ \
+ 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, \
- "delete posted event %p", ev);
+ "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);
-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;
+#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);
-
-extern ngx_mutex_t *ngx_posted_events_mutex;
#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_ */
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;
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);
}
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;
/* 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));
#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);
#define NGX_TIMER_INFINITE (ngx_msec_t) -1
-#define NGX_TIMER_ERROR (ngx_msec_t) -2
#define NGX_TIMER_LAZY_DELAY 300
"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);
ngx_msec_t key;
ngx_msec_int_t diff;
- key = ngx_current_time + timer;
+ key = ngx_current_msec + timer;
if (ev->timer_set) {
"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);
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;
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);
*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,
}
tree = ngx_radix_tree_create(cf->pool, -1);
+
if (tree == NULL) {
return NGX_CONF_ERROR;
}
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;
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;
}
ctx->index.len = len;
+
+ /* 16 bytes are preallocation */
+
+ len += 16;
}
if (len > ctx->path.len) {
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) {
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);
{
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];
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) {
}
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);
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 },
};
+
static ngx_command_t ngx_http_ssl_commands[] = {
{ ngx_string("ssl"),
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),
{ 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
};
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) {
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;
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
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] == '/') {
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) {
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->fd = fd;
- cln->name = path.data;
- cln->log = r->pool->log;
+ cln->handler = ngx_pool_cleanup_file;
+ clnf = cln->data;
- 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);
#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;
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,
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;
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';
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) {
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,
unsigned bind:1;
int backlog;
+ int rcvbuf;
+ int sndbuf;
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
char *accept_filter;
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);
}
/* 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);
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);
{ 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 }
};
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;
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);
}
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;
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
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) {
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;
}
}
+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)
{
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;
}
ls->backlog = -1;
+ ls->rcvbuf = -1;
+ ls->sndbuf = -1;
+
ls->addr_ntop = 1;
ls->handler = ngx_imap_init_connection;
ls->pool_size = 256;
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 },
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),
{ 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
};
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) {
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",
}
}
+#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;
}
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
/* the code in src/os/unix/ngx_sunpro_x86.il */
+#define ngx_memory_barrier() __asm (".volatile"); __asm (".nonvolatile")
+
#else /* ( __GNUC__ || __INTEL_COMPILER ) */
/* the code in src/os/unix/ngx_sunpro_amd64.il */
+#define ngx_memory_barrier() __asm (".volatile"); __asm (".nonvolatile")
+
#else /* ( __GNUC__ || __INTEL_COMPILER ) */
wev->own_lock = &c->lock;
#endif
+ rev->channel = 1;
+ wev->channel = 1;
+
ev = (event == NGX_READ_EVENT) ? rev : wev;
ev->handler = handler;
static int errno0; /* the main thread's errno */
static int *errnos; /* the threads errno's array */
-int *__error()
+int *
+__error()
{
int tid;
extern int __isthreaded;
-void _spinlock(ngx_atomic_t *lock)
+void
+_spinlock(ngx_atomic_t *lock)
{
ngx_int_t tries;
#ifndef _spinunlock
-void _spinunlock(ngx_atomic_t *lock)
+void
+_spinunlock(ngx_atomic_t *lock)
{
*lock = 0;
}
#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;
}
-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;
}
-ngx_tid_t ngx_thread_self()
+ngx_tid_t
+ngx_thread_self()
{
ngx_int_t tid;
}
-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;
}
-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;
}
-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;
}
-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,
}
-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;
"%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)) {
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,
}
-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;
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 */
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 */
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;
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;
}
-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,
}
-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;
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);
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;
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;
#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;
#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);
return add;
}
+
+
+#define ngx_memory_barrier() __asm__ volatile ("" ::: "memory")
return res;
}
+
+
+#if (NGX_SMP)
+#define ngx_memory_barrier() __asm__ volatile ("sync\n" ::: "memory")
+#else
+#define ngx_memory_barrier() __asm__ volatile ("" ::: "memory")
+#endif
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
}
#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")
#endif
-#ifndef NGX_HAVE_SELECT_CHANGE_TIMEOUT
-#define NGX_HAVE_SELECT_CHANGE_TIMEOUT 1
-#endif
-
-
#define NGX_HAVE_OS_SPECIFIC_INIT 1
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;
ngx_signal_handler(int signo)
{
char *action;
- struct timeval tv;
ngx_int_t ignore;
ngx_err_t err;
ngx_signal_t *sig;
}
}
- ngx_gettimeofday(&tv);
- ngx_time_update(tv.tv_sec);
+ ngx_time_update(0, 0);
action = "";
if (err == NGX_ECHILD) {
ngx_log_error(NGX_LOG_INFO, ngx_cycle->log, errno,
"waitpid() failed");
+ return;
}
#endif
break;
case NGX_DEBUG_POINTS_ABORT:
- abort();
+ ngx_abort();
}
}
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);
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;
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");
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);
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;
#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) {
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");
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
}
-static void *
+static ngx_thread_value_t
ngx_worker_thread_cycle(void *data)
{
ngx_thread_t *thr = 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,
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) {
"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;
}
}
}
ngx_add_timer(ev, 60 * 60 * 1000);
- ngx_process_events(cycle);
+ ngx_process_events_and_timers(cycle);
}
}
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;
}
-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;
}
-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;
}
-void ngx_mutex_destroy(ngx_mutex_t *m)
+void
+ngx_mutex_destroy(ngx_mutex_t *m)
{
int err;
}
-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);
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;
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);
}
-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);
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;
}
-void ngx_cond_destroy(ngx_cond_t *cv)
+void
+ngx_cond_destroy(ngx_cond_t *cv)
{
int err;
}
-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;
}
-ngx_int_t ngx_cond_signal(ngx_cond_t *cv)
+ngx_int_t
+ngx_cond_signal(ngx_cond_t *cv)
{
int err;
* 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.
#elif (NGX_LINUX)
+
int
ngx_tcp_nopush(ngx_socket_t s)
{
(const void *) &cork, sizeof(int));
}
+
int
ngx_tcp_push(ngx_socket_t s)
{
return 0;
}
+
int
ngx_tcp_push(ngx_socket_t s)
{
old = res;
}
}
+
+
+#define ngx_memory_barrier() \
+ __asm (".volatile"); \
+ __asm ("membar #LoadLoad | #LoadStore | #StoreStore | #StoreLoad"); \
+ __asm (".nonvolatile")
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
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);
#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)
#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
}
-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
#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)
#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))
#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);
}
-static void *
+static ngx_thread_value_t __stdcall
ngx_worker_thread_cycle(void *data)
{
ngx_cycle_t *cycle;
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;
}
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;
}
-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;
}
-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();
}
-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;
}
-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;
}
/* 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;
+}
+
/**/
typedef HANDLE ngx_tid_t;
typedef DWORD ngx_tls_key_t;
+typedef DWORD ngx_thread_value_t;
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);
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)
/**/
#include <ngx_core.h>
-void ngx_gettimeofday(struct timeval *tp)
+void
+ngx_gettimeofday(struct timeval *tp)
{
uint64_t intervals;
FILETIME ft;
}
-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;
#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);
#define _NGX_WIN32_CONFIG_H_INCLUDED_
+#define WIN32 0x0400
+#define _WIN32_WINNT 0x0400
+
+
#define STRICT
#define WIN32_LEAN_AND_MEAN
projects / nginx.git / commitdiff