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