nginx/src/event/ngx_event_accept.c

   1
   2 /*
   3  * Copyright (C) Igor Sysoev
   4  */
   5
   6
   7 #include <ngx_config.h>
   8 #include <ngx_core.h>
   9 #include <ngx_event.h>
  10
  11
  12 static ngx_int_t ngx_enable_accept_events(ngx_cycle_t *cycle);
  13 static ngx_int_t ngx_disable_accept_events(ngx_cycle_t *cycle);
  14 static void ngx_close_accepted_connection(ngx_connection_t *c);
  15
  16
  17 void
  18 ngx_event_accept(ngx_event_t *ev)
  19 {
  20     socklen_t          socklen;
  21     ngx_err_t          err;
  22     ngx_log_t         *log;
  23     ngx_socket_t       s;
  24     ngx_event_t       *rev, *wev;
  25     ngx_listening_t   *ls;
  26     ngx_connection_t  *c, *lc;
  27     ngx_event_conf_t  *ecf;
  28     u_char             sa[NGX_SOCKADDRLEN];
  29
  30     ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);
  31
  32     if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
  33         ev->available = 1;
  34
  35     } else if (!(ngx_event_flags & NGX_USE_KQUEUE_EVENT)) {
  36         ev->available = ecf->multi_accept;
  37     }
  38
  39     lc = ev->data;
  40     ls = lc->listening;
  41     ev->ready = 0;
  42
  43     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  44                    "accept on %V, ready: %d", &ls->addr_text, ev->available);
  45
  46     do {
  47         socklen = NGX_SOCKADDRLEN;
  48
  49         s = accept(lc->fd, (struct sockaddr *) sa, &socklen);
  50
  51         if (s == -1) {
  52             err = ngx_socket_errno;
  53
  54             if (err == NGX_EAGAIN) {
  55                 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, err,
  56                                "accept() not ready");
  57                 return;
  58             }
  59
  60             ngx_log_error((err == NGX_ECONNABORTED) ? NGX_LOG_ERR:
  61                                                       NGX_LOG_ALERT,
  62                           ev->log, err, "accept() failed");
  63
  64             if (err == NGX_ECONNABORTED) {
  65                 if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  66                     ev->available--;
  67                 }
  68
  69                 if (ev->available) {
  70                     continue;
  71                 }
  72             }
  73
  74             return;
  75         }
  76
  77 #if (NGX_STAT_STUB)
  78         ngx_atomic_fetch_add(ngx_stat_accepted, 1);
  79 #endif
  80
  81         ngx_accept_disabled = ngx_cycle->connection_n / 8
  82                               - ngx_cycle->free_connection_n;
  83
  84         c = ngx_get_connection(s, ev->log);
  85
  86         if (c == NULL) {
  87             if (ngx_close_socket(s) == -1) {
  88                 ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
  89                               ngx_close_socket_n " failed");
  90             }
  91
  92             return;
  93         }
  94
  95 #if (NGX_STAT_STUB)
  96         ngx_atomic_fetch_add(ngx_stat_active, 1);
  97 #endif
  98
  99         c->pool = ngx_create_pool(ls->pool_size, ev->log);
 100         if (c->pool == NULL) {
 101             ngx_close_accepted_connection(c);
 102             return;
 103         }
 104
 105         c->sockaddr = ngx_palloc(c->pool, socklen);
 106         if (c->sockaddr == NULL) {
 107             ngx_close_accepted_connection(c);
 108             return;
 109         }
 110
 111         ngx_memcpy(c->sockaddr, sa, socklen);
 112
 113         log = ngx_palloc(c->pool, sizeof(ngx_log_t));
 114         if (log == NULL) {
 115             ngx_close_accepted_connection(c);
 116             return;
 117         }
 118
 119         /* set a blocking mode for aio and non-blocking mode for others */
 120
 121         if (ngx_inherited_nonblocking) {
 122             if (ngx_event_flags & NGX_USE_AIO_EVENT) {
 123                 if (ngx_blocking(s) == -1) {
 124                     ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
 125                                   ngx_blocking_n " failed");
 126                     ngx_close_accepted_connection(c);
 127                     return;
 128                 }
 129             }
 130
 131         } else {
 132             if (!(ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT))) {
 133                 if (ngx_nonblocking(s) == -1) {
 134                     ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
 135                                   ngx_nonblocking_n " failed");
 136                     ngx_close_accepted_connection(c);
 137                     return;
 138                 }
 139             }
 140         }
 141
 142         *log = ls->log;
 143
 144         c->recv = ngx_recv;
 145         c->send = ngx_send;
 146         c->recv_chain = ngx_recv_chain;
 147         c->send_chain = ngx_send_chain;
 148
 149         c->log = log;
 150         c->pool->log = log;
 151
 152         c->socklen = socklen;
 153         c->listening = ls;
 154         c->local_sockaddr = ls->sockaddr;
 155         c->local_socklen = ls->socklen;
 156
 157         c->unexpected_eof = 1;
 158
 159         rev = c->read;
 160         wev = c->write;
 161
 162         wev->ready = 1;
 163
 164         if (ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT)) {
 165             /* rtsig, aio, iocp */
 166             rev->ready = 1;
 167         }
 168
 169         if (ev->deferred_accept) {
 170             rev->ready = 1;
 171 #if (NGX_HAVE_KQUEUE)
 172             rev->available = 1;
 173 #endif
 174         }
 175
 176         rev->log = log;
 177         wev->log = log;
 178
 179         /*
 180          * TODO: MT: - ngx_atomic_fetch_add()
 181          *             or protection by critical section or light mutex
 182          *
 183          * TODO: MP: - allocated in a shared memory
 184          *           - ngx_atomic_fetch_add()
 185          *             or protection by critical section or light mutex
 186          */
 187
 188         c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
 189
 190 #if (NGX_STAT_STUB)
 191         ngx_atomic_fetch_add(ngx_stat_handled, 1);
 192 #endif
 193
 194 #if (NGX_THREADS)
 195         rev->lock = &c->lock;
 196         wev->lock = &c->lock;
 197         rev->own_lock = &c->lock;
 198         wev->own_lock = &c->lock;
 199 #endif
 200
 201         if (ls->addr_ntop) {
 202             c->addr_text.data = ngx_pnalloc(c->pool, ls->addr_text_max_len);
 203             if (c->addr_text.data == NULL) {
 204                 ngx_close_accepted_connection(c);
 205                 return;
 206             }
 207
 208             c->addr_text.len = ngx_sock_ntop(c->sockaddr, c->addr_text.data,
 209                                              ls->addr_text_max_len, 0);
 210             if (c->addr_text.len == 0) {
 211                 ngx_close_accepted_connection(c);
 212                 return;
 213             }
 214         }
 215
 216 #if (NGX_DEBUG)
 217         {
 218
 219         in_addr_t            i;
 220         ngx_event_debug_t   *dc;
 221         struct sockaddr_in  *sin;
 222
 223         sin = (struct sockaddr_in *) sa;
 224         dc = ecf->debug_connection.elts;
 225         for (i = 0; i < ecf->debug_connection.nelts; i++) {
 226             if ((sin->sin_addr.s_addr & dc[i].mask) == dc[i].addr) {
 227                 log->log_level = NGX_LOG_DEBUG_CONNECTION|NGX_LOG_DEBUG_ALL;
 228                 break;
 229             }
 230         }
 231
 232         }
 233 #endif
 234
 235         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, log, 0,
 236                        "*%d accept: %V fd:%d", c->number, &c->addr_text, s);
 237
 238         if (ngx_add_conn && (ngx_event_flags & NGX_USE_EPOLL_EVENT) == 0) {
 239             if (ngx_add_conn(c) == NGX_ERROR) {
 240                 ngx_close_accepted_connection(c);
 241                 return;
 242             }
 243         }
 244
 245         log->data = NULL;
 246         log->handler = NULL;
 247
 248         ls->handler(c);
 249
 250         if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
 251             ev->available--;
 252         }
 253
 254     } while (ev->available);
 255 }
 256
 257
 258 ngx_int_t
 259 ngx_trylock_accept_mutex(ngx_cycle_t *cycle)
 260 {
 261     if (ngx_shmtx_trylock(&ngx_accept_mutex)) {
 262
 263         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 264                        "accept mutex locked");
 265
 266         if (ngx_accept_mutex_held
 267             && ngx_accept_events == 0
 268             && !(ngx_event_flags & NGX_USE_RTSIG_EVENT))
 269         {
 270             return NGX_OK;
 271         }
 272
 273         if (ngx_enable_accept_events(cycle) == NGX_ERROR) {
 274             ngx_shmtx_unlock(&ngx_accept_mutex);
 275             return NGX_ERROR;
 276         }
 277
 278         ngx_accept_events = 0;
 279         ngx_accept_mutex_held = 1;
 280
 281         return NGX_OK;
 282     }
 283
 284     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 285                    "accept mutex lock failed: %ui", ngx_accept_mutex_held);
 286
 287     if (ngx_accept_mutex_held) {
 288         if (ngx_disable_accept_events(cycle) == NGX_ERROR) {
 289             return NGX_ERROR;
 290         }
 291
 292         ngx_accept_mutex_held = 0;
 293     }
 294
 295     return NGX_OK;
 296 }
 297
 298
 299 static ngx_int_t
 300 ngx_enable_accept_events(ngx_cycle_t *cycle)
 301 {
 302     ngx_uint_t         i;
 303     ngx_listening_t   *ls;
 304     ngx_connection_t  *c;
 305
 306     ls = cycle->listening.elts;
 307     for (i = 0; i < cycle->listening.nelts; i++) {
 308
 309         c = ls[i].connection;
 310
 311         if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
 312
 313             if (ngx_add_conn(c) == NGX_ERROR) {
 314                 return NGX_ERROR;
 315             }
 316
 317         } else {
 318             if (ngx_add_event(c->read, NGX_READ_EVENT, 0) == NGX_ERROR) {
 319                 return NGX_ERROR;
 320             }
 321         }
 322     }
 323
 324     return NGX_OK;
 325 }
 326
 327
 328 static ngx_int_t
 329 ngx_disable_accept_events(ngx_cycle_t *cycle)
 330 {
 331     ngx_uint_t         i;
 332     ngx_listening_t   *ls;
 333     ngx_connection_t  *c;
 334
 335     ls = cycle->listening.elts;
 336     for (i = 0; i < cycle->listening.nelts; i++) {
 337
 338         c = ls[i].connection;
 339
 340         if (!c->read->active) {
 341             continue;
 342         }
 343
 344         if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
 345             if (ngx_del_conn(c, NGX_DISABLE_EVENT) == NGX_ERROR) {
 346                 return NGX_ERROR;
 347             }
 348
 349         } else {
 350             if (ngx_del_event(c->read, NGX_READ_EVENT, NGX_DISABLE_EVENT)
 351                 == NGX_ERROR)
 352             {
 353                 return NGX_ERROR;
 354             }
 355         }
 356     }
 357
 358     return NGX_OK;
 359 }
 360
 361
 362 static void
 363 ngx_close_accepted_connection(ngx_connection_t *c)
 364 {
 365     ngx_socket_t  fd;
 366
 367     ngx_free_connection(c);
 368
 369     fd = c->fd;
 370     c->fd = (ngx_socket_t) -1;
 371
 372     if (ngx_close_socket(fd) == -1) {
 373         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_socket_errno,
 374                       ngx_close_socket_n " failed");
 375     }
 376
 377     if (c->pool) {
 378         ngx_destroy_pool(c->pool);
 379     }
 380
 381 #if (NGX_STAT_STUB)
 382     ngx_atomic_fetch_add(ngx_stat_active, -1);
 383 #endif
 384 }
 385
 386
 387 u_char *
 388 ngx_accept_log_error(ngx_log_t *log, u_char *buf, size_t len)
 389 {
 390     return ngx_snprintf(buf, len, " while accepting new connection on %V",
 391                         log->data);
 392 }