src/event/modules/ngx_poll_module.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_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  13 static void ngx_poll_done(ngx_cycle_t *cycle);
  14 static ngx_int_t ngx_poll_add_event(ngx_event_t *ev, ngx_int_t event,
  15     ngx_uint_t flags);
  16 static ngx_int_t ngx_poll_del_event(ngx_event_t *ev, ngx_int_t event,
  17     ngx_uint_t flags);
  18 static ngx_int_t ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  19     ngx_uint_t flags);
  20 static char *ngx_poll_init_conf(ngx_cycle_t *cycle, void *conf);
  21
  22
  23 static struct pollfd  *event_list;
  24 static ngx_int_t       nevents;
  25
  26
  27 static ngx_str_t    poll_name = ngx_string("poll");
  28
  29 ngx_event_module_t  ngx_poll_module_ctx = {
  30     &poll_name,
  31     NULL,                                  /* create configuration */
  32     ngx_poll_init_conf,                    /* init configuration */
  33
  34     {
  35         ngx_poll_add_event,                /* add an event */
  36         ngx_poll_del_event,                /* delete an event */
  37         ngx_poll_add_event,                /* enable an event */
  38         ngx_poll_del_event,                /* disable an event */
  39         NULL,                              /* add an connection */
  40         NULL,                              /* delete an connection */
  41         NULL,                              /* process the changes */
  42         ngx_poll_process_events,           /* process the events */
  43         ngx_poll_init,                     /* init the events */
  44         ngx_poll_done                      /* done the events */
  45     }
  46
  47 };
  48
  49 ngx_module_t  ngx_poll_module = {
  50     NGX_MODULE_V1,
  51     &ngx_poll_module_ctx,                  /* module context */
  52     NULL,                                  /* module directives */
  53     NGX_EVENT_MODULE,                      /* module type */
  54     NULL,                                  /* init master */
  55     NULL,                                  /* init module */
  56     NULL,                                  /* init process */
  57     NULL,                                  /* init thread */
  58     NULL,                                  /* exit thread */
  59     NULL,                                  /* exit process */
  60     NULL,                                  /* exit master */
  61     NGX_MODULE_V1_PADDING
  62 };
  63
  64
  65
  66 static ngx_int_t
  67 ngx_poll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  68 {
  69     struct pollfd   *list;
  70
  71     if (event_list == NULL) {
  72         nevents = 0;
  73     }
  74
  75     if (ngx_process == NGX_PROCESS_WORKER
  76         || cycle->old_cycle == NULL
  77         || cycle->old_cycle->connection_n < cycle->connection_n)
  78     {
  79         list = ngx_alloc(sizeof(struct pollfd) * cycle->connection_n,
  80                          cycle->log);
  81         if (list == NULL) {
  82             return NGX_ERROR;
  83         }
  84
  85         if (event_list) {
  86             ngx_memcpy(list, event_list, sizeof(ngx_event_t *) * nevents);
  87             ngx_free(event_list);
  88         }
  89
  90         event_list = list;
  91     }
  92
  93     ngx_io = ngx_os_io;
  94
  95     ngx_event_actions = ngx_poll_module_ctx.actions;
  96
  97     ngx_event_flags = NGX_USE_LEVEL_EVENT|NGX_USE_FD_EVENT;
  98
  99     return NGX_OK;
 100 }
 101
 102
 103 static void
 104 ngx_poll_done(ngx_cycle_t *cycle)
 105 {
 106     ngx_free(event_list);
 107
 108     event_list = NULL;
 109 }
 110
 111
 112 static ngx_int_t
 113 ngx_poll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
 114 {
 115     ngx_event_t       *e;
 116     ngx_connection_t  *c;
 117
 118     c = ev->data;
 119
 120     ev->active = 1;
 121
 122     if (ev->index != NGX_INVALID_INDEX) {
 123         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
 124                       "poll event fd:%d ev:%i is already set", c->fd, event);
 125         return NGX_OK;
 126     }
 127
 128     if (event == NGX_READ_EVENT) {
 129         e = c->write;
 130 #if (NGX_READ_EVENT != POLLIN)
 131         event = POLLIN;
 132 #endif
 133
 134     } else {
 135         e = c->read;
 136 #if (NGX_WRITE_EVENT != POLLOUT)
 137         event = POLLOUT;
 138 #endif
 139     }
 140
 141     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
 142                    "poll add event: fd:%d ev:%i", c->fd, event);
 143
 144     if (e == NULL || e->index == NGX_INVALID_INDEX) {
 145         event_list[nevents].fd = c->fd;
 146         event_list[nevents].events = (short) event;
 147         event_list[nevents].revents = 0;
 148
 149         ev->index = nevents;
 150         nevents++;
 151
 152     } else {
 153         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
 154                        "poll add index: %i", e->index);
 155
 156         event_list[e->index].events |= (short) event;
 157         ev->index = e->index;
 158     }
 159
 160     return NGX_OK;
 161 }
 162
 163
 164 static ngx_int_t
 165 ngx_poll_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
 166 {
 167     ngx_event_t       *e;
 168     ngx_connection_t  *c;
 169
 170     c = ev->data;
 171
 172     ev->active = 0;
 173
 174     if (ev->index == NGX_INVALID_INDEX) {
 175         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
 176                       "poll event fd:%d ev:%i is already deleted",
 177                       c->fd, event);
 178         return NGX_OK;
 179     }
 180
 181     if (event == NGX_READ_EVENT) {
 182         e = c->write;
 183 #if (NGX_READ_EVENT != POLLIN)
 184         event = POLLIN;
 185 #endif
 186
 187     } else {
 188         e = c->read;
 189 #if (NGX_WRITE_EVENT != POLLOUT)
 190         event = POLLOUT;
 191 #endif
 192     }
 193
 194     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
 195                    "poll del event: fd:%d ev:%i", c->fd, event);
 196
 197     if (e == NULL || e->index == NGX_INVALID_INDEX) {
 198         nevents--;
 199
 200         if (ev->index < (ngx_uint_t) nevents) {
 201
 202             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
 203                            "index: copy event %ui to %i", nevents, ev->index);
 204
 205             event_list[ev->index] = event_list[nevents];
 206
 207             c = ngx_cycle->files[event_list[nevents].fd];
 208
 209             if (c->fd == -1) {
 210                 ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
 211                               "unexpected last event");
 212
 213             } else {
 214                 if (c->read->index == (ngx_uint_t) nevents) {
 215                     c->read->index = ev->index;
 216                 }
 217
 218                 if (c->write->index == (ngx_uint_t) nevents) {
 219                     c->write->index = ev->index;
 220                 }
 221             }
 222         }
 223
 224     } else {
 225         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
 226                        "poll del index: %i", e->index);
 227
 228         event_list[e->index].events &= (short) ~event;
 229     }
 230
 231     ev->index = NGX_INVALID_INDEX;
 232
 233     return NGX_OK;
 234 }
 235
 236
 237 static ngx_int_t
 238 ngx_poll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
 239 {
 240     int                 ready, revents;
 241     ngx_err_t           err;
 242     ngx_int_t           i, nready;
 243     ngx_uint_t          found, level;
 244     ngx_event_t        *ev, **queue;
 245     ngx_connection_t   *c;
 246
 247     /* NGX_TIMER_INFINITE == INFTIM */
 248
 249 #if (NGX_DEBUG0)
 250     if (cycle->log->log_level & NGX_LOG_DEBUG_ALL) {
 251         for (i = 0; i < nevents; i++) {
 252             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 253                            "poll: %d: fd:%d ev:%04Xd",
 254                            i, event_list[i].fd, event_list[i].events);
 255         }
 256     }
 257 #endif
 258
 259     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %M", timer);
 260
 261     ready = poll(event_list, (u_int) nevents, (int) timer);
 262
 263     if (ready == -1) {
 264         err = ngx_errno;
 265     } else {
 266         err = 0;
 267     }
 268
 269     if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
 270         ngx_time_update();
 271     }
 272
 273     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 274                    "poll ready %d of %d", ready, nevents);
 275
 276     if (err) {
 277         if (err == NGX_EINTR) {
 278
 279             if (ngx_event_timer_alarm) {
 280                 ngx_event_timer_alarm = 0;
 281                 return NGX_OK;
 282             }
 283
 284             level = NGX_LOG_INFO;
 285
 286         } else {
 287             level = NGX_LOG_ALERT;
 288         }
 289
 290         ngx_log_error(level, cycle->log, err, "poll() failed");
 291         return NGX_ERROR;
 292     }
 293
 294     if (ready == 0) {
 295         if (timer != NGX_TIMER_INFINITE) {
 296             return NGX_OK;
 297         }
 298
 299         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
 300                       "poll() returned no events without timeout");
 301         return NGX_ERROR;
 302     }
 303
 304     ngx_mutex_lock(ngx_posted_events_mutex);
 305
 306     nready = 0;
 307
 308     for (i = 0; i < nevents && ready; i++) {
 309
 310         revents = event_list[i].revents;
 311
 312 #if 1
 313         ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 314                        "poll: %d: fd:%d ev:%04Xd rev:%04Xd",
 315                        i, event_list[i].fd, event_list[i].events, revents);
 316 #else
 317         if (revents) {
 318             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 319                            "poll: %d: fd:%d ev:%04Xd rev:%04Xd",
 320                            i, event_list[i].fd, event_list[i].events, revents);
 321         }
 322 #endif
 323
 324         if (revents & POLLNVAL) {
 325             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
 326                           "poll() error fd:%d ev:%04Xd rev:%04Xd",
 327                           event_list[i].fd, event_list[i].events, revents);
 328         }
 329
 330         if (revents & ~(POLLIN|POLLOUT|POLLERR|POLLHUP|POLLNVAL)) {
 331             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
 332                           "strange poll() events fd:%d ev:%04Xd rev:%04Xd",
 333                           event_list[i].fd, event_list[i].events, revents);
 334         }
 335
 336         if (event_list[i].fd == -1) {
 337             /*
 338              * the disabled event, a workaround for our possible bug,
 339              * see the comment below
 340              */
 341             continue;
 342         }
 343
 344         c = ngx_cycle->files[event_list[i].fd];
 345
 346         if (c->fd == -1) {
 347             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "unexpected event");
 348
 349             /*
 350              * it is certainly our fault and it should be investigated,
 351              * in the meantime we disable this event to avoid a CPU spinning
 352              */
 353
 354             if (i == nevents - 1) {
 355                 nevents--;
 356             } else {
 357                 event_list[i].fd = -1;
 358             }
 359
 360             continue;
 361         }
 362
 363         if ((revents & (POLLERR|POLLHUP|POLLNVAL))
 364              && (revents & (POLLIN|POLLOUT)) == 0)
 365         {
 366             /*
 367              * if the error events were returned without POLLIN or POLLOUT,
 368              * then add these flags to handle the events at least in one
 369              * active handler
 370              */
 371
 372             revents |= POLLIN|POLLOUT;
 373         }
 374
 375         found = 0;
 376
 377         if (revents & POLLIN) {
 378             found = 1;
 379
 380             ev = c->read;
 381
 382             if ((flags & NGX_POST_THREAD_EVENTS) && !ev->accept) {
 383                 ev->posted_ready = 1;
 384
 385             } else {
 386                 ev->ready = 1;
 387             }
 388
 389             queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
 390                                                    &ngx_posted_events);
 391             ngx_locked_post_event(ev, queue);
 392         }
 393
 394         if (revents & POLLOUT) {
 395             found = 1;
 396             ev = c->write;
 397
 398             if (flags & NGX_POST_THREAD_EVENTS) {
 399                 ev->posted_ready = 1;
 400
 401             } else {
 402                 ev->ready = 1;
 403             }
 404
 405             ngx_locked_post_event(ev, &ngx_posted_events);
 406         }
 407
 408         if (found) {
 409             ready--;
 410             continue;
 411         }
 412     }
 413
 414     ngx_mutex_unlock(ngx_posted_events_mutex);
 415
 416     if (ready != 0) {
 417         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "poll ready != events");
 418     }
 419
 420     return nready;
 421 }
 422
 423
 424 static char *
 425 ngx_poll_init_conf(ngx_cycle_t *cycle, void *conf)
 426 {
 427     ngx_event_conf_t  *ecf;
 428
 429     ecf = ngx_event_get_conf(cycle->conf_ctx, ngx_event_core_module);
 430
 431     if (ecf->use != ngx_poll_module.ctx_index) {
 432         return NGX_CONF_OK;
 433     }
 434
 435 #if (NGX_THREADS)
 436
 437     ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
 438                   "poll() is not supported in the threaded mode");
 439     return NGX_CONF_ERROR;
 440
 441 #else
 442
 443     return NGX_CONF_OK;
 444
 445 #endif
 446 }