src/event/modules/ngx_devpoll_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 #if (TEST_BUILD_DEVPOLL)
  13
  14 /* Solaris declarations */
  15
  16 #define POLLREMOVE   0x0800
  17 #define DP_POLL      0xD001
  18
  19 struct dvpoll {
  20     struct pollfd  *dp_fds;
  21     int             dp_nfds;
  22     int             dp_timeout;
  23 };
  24
  25 #endif
  26
  27
  28 typedef struct {
  29     u_int  changes;
  30     u_int  events;
  31 } ngx_devpoll_conf_t;
  32
  33
  34 static int ngx_devpoll_init(ngx_cycle_t *cycle);
  35 static void ngx_devpoll_done(ngx_cycle_t *cycle);
  36 static int ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags);
  37 static int ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags);
  38 static int ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags);
  39 static int ngx_devpoll_process_events(ngx_cycle_t *cycle);
  40
  41 static void *ngx_devpoll_create_conf(ngx_cycle_t *cycle);
  42 static char *ngx_devpoll_init_conf(ngx_cycle_t *cycle, void *conf);
  43
  44 static int              dp = -1;
  45 static struct pollfd   *change_list, *event_list;
  46 static u_int            nchanges, max_changes, nevents;
  47
  48 static ngx_event_t    **change_index;
  49
  50
  51 static ngx_str_t      devpoll_name = ngx_string("/dev/poll");
  52
  53 static ngx_command_t  ngx_devpoll_commands[] = {
  54
  55     {ngx_string("devpoll_changes"),
  56      NGX_EVENT_CONF|NGX_CONF_TAKE1,
  57      ngx_conf_set_num_slot,
  58      0,
  59      offsetof(ngx_devpoll_conf_t, changes),
  60      NULL},
  61
  62     {ngx_string("devpoll_events"),
  63      NGX_EVENT_CONF|NGX_CONF_TAKE1,
  64      ngx_conf_set_num_slot,
  65      0,
  66      offsetof(ngx_devpoll_conf_t, events),
  67      NULL},
  68
  69     ngx_null_command
  70 };
  71
  72
  73 ngx_event_module_t  ngx_devpoll_module_ctx = {
  74     &devpoll_name,
  75     ngx_devpoll_create_conf,               /* create configuration */
  76     ngx_devpoll_init_conf,                 /* init configuration */
  77
  78     {
  79         ngx_devpoll_add_event,             /* add an event */
  80         ngx_devpoll_del_event,             /* delete an event */
  81         ngx_devpoll_add_event,             /* enable an event */
  82         ngx_devpoll_del_event,             /* disable an event */
  83         NULL,                              /* add an connection */
  84         NULL,                              /* delete an connection */
  85         NULL,                              /* process the changes */
  86         ngx_devpoll_process_events,        /* process the events */
  87         ngx_devpoll_init,                  /* init the events */
  88         ngx_devpoll_done,                  /* done the events */
  89     }
  90
  91 };
  92
  93 ngx_module_t  ngx_devpoll_module = {
  94     NGX_MODULE,
  95     &ngx_devpoll_module_ctx,               /* module context */
  96     ngx_devpoll_commands,                  /* module directives */
  97     NGX_EVENT_MODULE,                      /* module type */
  98     NULL,                                  /* init module */
  99     NULL                                   /* init process */
 100 };
 101
 102
 103 static int ngx_devpoll_init(ngx_cycle_t *cycle)
 104 {
 105     size_t               n;
 106     ngx_devpoll_conf_t  *dpcf;
 107
 108     dpcf = ngx_event_get_conf(cycle->conf_ctx, ngx_devpoll_module);
 109
 110     if (dp == -1) {
 111         dp = open("/dev/poll", O_RDWR);
 112
 113         if (dp == -1) {
 114             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
 115                           "open(/dev/poll) failed");
 116             return NGX_ERROR;
 117         }
 118     }
 119
 120     if (max_changes < dpcf->changes) {
 121         if (nchanges) {
 122             n = nchanges * sizeof(struct pollfd);
 123             if (write(dp, change_list, n) != (ssize_t) n) {
 124                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
 125                               "write(/dev/poll) failed");
 126                 return NGX_ERROR;
 127             }
 128
 129             nchanges = 0;
 130         }
 131
 132         if (change_list) {
 133             ngx_free(change_list);
 134         }
 135
 136         ngx_test_null(change_list,
 137                       ngx_alloc(sizeof(struct pollfd) * dpcf->changes,
 138                                 cycle->log),
 139                       NGX_ERROR);
 140
 141         if (change_index) {
 142             ngx_free(change_index);
 143         }
 144
 145         ngx_test_null(change_index,
 146                       ngx_alloc(sizeof(ngx_event_t *) * dpcf->changes,
 147                                 cycle->log),
 148                       NGX_ERROR);
 149     }
 150
 151     max_changes = dpcf->changes;
 152
 153     if (nevents < dpcf->events) {
 154         if (event_list) {
 155             ngx_free(event_list);
 156         }
 157
 158         ngx_test_null(event_list,
 159                       ngx_alloc(sizeof(struct pollfd) * dpcf->events,
 160                                 cycle->log),
 161                       NGX_ERROR);
 162     }
 163
 164     nevents = dpcf->events;
 165
 166     ngx_io = ngx_os_io;
 167
 168     ngx_event_actions = ngx_devpoll_module_ctx.actions;
 169
 170     ngx_event_flags = NGX_USE_LEVEL_EVENT;
 171
 172     return NGX_OK;
 173 }
 174
 175
 176 static void ngx_devpoll_done(ngx_cycle_t *cycle)
 177 {
 178     if (close(dp) == -1) {
 179         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
 180                       "close(/dev/poll) failed");
 181     }
 182
 183     dp = -1;
 184
 185     ngx_free(change_list);
 186     ngx_free(event_list);
 187     ngx_free(change_index);
 188
 189     change_list = NULL;
 190     event_list = NULL;
 191     change_index = NULL;
 192     max_changes = 0;
 193     nchanges = 0;
 194     nevents = 0;
 195 }
 196
 197
 198 static int ngx_devpoll_add_event(ngx_event_t *ev, int event, u_int flags)
 199 {
 200 #if (NGX_DEBUG)
 201     ngx_connection_t *c;
 202 #endif
 203
 204 #if (NGX_READ_EVENT != POLLIN)
 205     event = (event == NGX_READ_EVENT) ? POLLIN : POLLOUT;
 206 #endif
 207
 208 #if (NGX_DEBUG)
 209     c = ev->data;
 210     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
 211                    "devpoll add event: fd:%d ev:%04X", c->fd, event);
 212 #endif
 213
 214     ev->active = 1;
 215
 216     return ngx_devpoll_set_event(ev, event, 0);
 217 }
 218
 219
 220 static int ngx_devpoll_del_event(ngx_event_t *ev, int event, u_int flags)
 221 {
 222     ngx_event_t       *e;
 223     ngx_connection_t  *c;
 224
 225     c = ev->data;
 226
 227 #if (NGX_READ_EVENT != POLLIN)
 228     event = (event == NGX_READ_EVENT) ? POLLIN : POLLOUT;
 229 #endif
 230
 231     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
 232                    "devpoll del event: fd:%d ev:%04X", c->fd, event);
 233
 234     if (ngx_devpoll_set_event(ev, POLLREMOVE, flags) == NGX_ERROR) {
 235         return NGX_ERROR;
 236     }
 237
 238     ev->active = 0;
 239
 240     if (flags & NGX_CLOSE_EVENT) {
 241         return NGX_OK;
 242     }
 243
 244     /* restore the paired event if it exists */
 245
 246     if (event == POLLIN) {
 247         e = c->write;
 248         event = POLLOUT;
 249
 250     } else {
 251         e = c->read;
 252         event = POLLIN;
 253     }
 254
 255     if (e && e->active) {
 256         return ngx_devpoll_set_event(e, event, 0);
 257     }
 258
 259     return NGX_OK;
 260 }
 261
 262
 263 static int ngx_devpoll_set_event(ngx_event_t *ev, int event, u_int flags)
 264 {
 265     size_t             n;
 266     ngx_connection_t  *c;
 267
 268     c = ev->data;
 269
 270     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
 271                    "devpoll fd:%d ev:%04X fl:%04X", c->fd, event, flags);
 272
 273     if (nchanges >= max_changes) {
 274         ngx_log_error(NGX_LOG_WARN, ev->log, 0,
 275                       "/dev/pool change list is filled up");
 276
 277         n = nchanges * sizeof(struct pollfd);
 278         if (write(dp, change_list, n) != (ssize_t) n) {
 279             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
 280                           "write(/dev/poll) failed");
 281             return NGX_ERROR;
 282         }
 283
 284         nchanges = 0;
 285     }
 286
 287     change_list[nchanges].fd = c->fd;
 288     change_list[nchanges].events = event;
 289     change_list[nchanges].revents = 0;
 290
 291     change_index[nchanges] = ev;
 292     ev->index = nchanges;
 293
 294     nchanges++;
 295
 296     if (flags & NGX_CLOSE_EVENT) {
 297         n = nchanges * sizeof(struct pollfd);
 298         if (write(dp, change_list, n) != (ssize_t) n) {
 299             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
 300                           "write(/dev/poll) failed");
 301             return NGX_ERROR;
 302         }
 303
 304         nchanges = 0;
 305     }
 306
 307     return NGX_OK;
 308 }
 309
 310
 311 int ngx_devpoll_process_events(ngx_cycle_t *cycle)
 312 {
 313     int                 events;
 314     ngx_int_t           i;
 315     ngx_uint_t          j, lock, accept_lock, expire;
 316     size_t              n;
 317     ngx_msec_t          timer;
 318     ngx_err_t           err;
 319     ngx_cycle_t       **old_cycle;
 320     ngx_event_t        *rev, *wev;
 321     ngx_connection_t   *c;
 322     ngx_epoch_msec_t    delta;
 323     struct dvpoll       dvp;
 324     struct timeval      tv;
 325
 326     for ( ;; ) {
 327         timer = ngx_event_find_timer();
 328
 329         if (timer != 0) {
 330             break;
 331         }
 332
 333         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 334                        "devpoll expired timer");
 335
 336         ngx_event_expire_timers((ngx_msec_t)
 337                                     (ngx_elapsed_msec - ngx_old_elapsed_msec));
 338     }
 339
 340     /* NGX_TIMER_INFINITE == INFTIM */
 341
 342     if (timer == NGX_TIMER_INFINITE) {
 343         expire = 0;
 344
 345     } else {
 346         expire = 1;
 347     }
 348
 349     ngx_old_elapsed_msec = ngx_elapsed_msec;
 350     accept_lock = 0;
 351
 352     if (ngx_accept_mutex) {
 353         if (ngx_accept_disabled > 0) {
 354             ngx_accept_disabled--;
 355
 356         } else {
 357             if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {
 358                 return NGX_ERROR;
 359             }
 360
 361             if (ngx_accept_mutex_held) {
 362                 accept_lock = 1;
 363
 364             } else if (timer == NGX_TIMER_INFINITE
 365                        || timer > ngx_accept_mutex_delay)
 366             {
 367                 timer = ngx_accept_mutex_delay;
 368                 expire = 0;
 369             }
 370         }
 371     }
 372
 373     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 374                    "devpoll timer: %d", timer);
 375
 376     if (nchanges) {
 377         n = nchanges * sizeof(struct pollfd);
 378         if (write(dp, change_list, n) != (ssize_t) n) {
 379             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
 380                           "write(/dev/poll) failed");
 381             ngx_accept_mutex_unlock();
 382             return NGX_ERROR;
 383         }
 384     }
 385
 386     dvp.dp_fds = event_list;
 387     dvp.dp_nfds = nevents;
 388     dvp.dp_timeout = timer;
 389     events = ioctl(dp, DP_POLL, &dvp);
 390
 391     if (events == -1) {
 392         err = ngx_errno;
 393     } else {
 394         err = 0;
 395     }
 396
 397     nchanges = 0;
 398
 399     ngx_gettimeofday(&tv);
 400     ngx_time_update(tv.tv_sec);
 401
 402     delta = ngx_elapsed_msec;
 403     ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
 404                                           + tv.tv_usec / 1000 - ngx_start_msec;
 405
 406     if (err) {
 407         ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
 408                       cycle->log, err, "ioctl(DP_POLL) failed");
 409         ngx_accept_mutex_unlock();
 410         return NGX_ERROR;
 411     }
 412
 413     if (timer != NGX_TIMER_INFINITE) {
 414         delta = ngx_elapsed_msec - delta;
 415
 416         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 417                        "devpoll timer: %d, delta: %d", timer, (int) delta);
 418     } else {
 419         if (events == 0) {
 420             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
 421                           "ioctl(DP_POLL) returned no events without timeout");
 422             ngx_accept_mutex_unlock();
 423             return NGX_ERROR;
 424         }
 425     }
 426
 427     if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
 428         ngx_accept_mutex_unlock();
 429         return NGX_ERROR;
 430     }
 431
 432     lock = 1;
 433
 434     for (i = 0; i < events; i++) {
 435         c = &ngx_cycle->connections[event_list[i].fd];
 436
 437         if (c->fd == -1) {
 438             old_cycle = ngx_old_cycles.elts;
 439             for (j = 0; j < ngx_old_cycles.nelts; j++) {
 440                 if (old_cycle[j] == NULL) {
 441                     continue;
 442                 }
 443                 c = &old_cycle[j]->connections[event_list[i].fd];
 444                 if (c->fd != -1) {
 445                     break;
 446                 }
 447             }
 448         }
 449
 450         if (c->fd == -1) {
 451             ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, "unknown cycle");
 452             exit(1);
 453         }
 454
 455         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
 456                        "devpoll: fd:%d, ev:%04X, rev:%04X",
 457                        event_list[i].fd,
 458                        event_list[i].events, event_list[i].revents);
 459
 460         if (event_list[i].revents & (POLLERR|POLLHUP|POLLNVAL)) {
 461             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
 462                           "ioctl(DP_POLL) error fd:%d ev:%04X rev:%04X",
 463                           event_list[i].fd,
 464                           event_list[i].events, event_list[i].revents);
 465         }
 466
 467         if (event_list[i].revents & ~(POLLIN|POLLOUT|POLLERR|POLLHUP|POLLNVAL))
 468         {
 469             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
 470                           "strange ioctl(DP_POLL) events "
 471                           "fd:%d ev:%04X rev:%04X",
 472                           event_list[i].fd,
 473                           event_list[i].events, event_list[i].revents);
 474         }
 475
 476         wev = c->write;
 477
 478         if ((event_list[i].events & (POLLOUT|POLLERR|POLLHUP)) && wev->active) {
 479             wev->ready = 1;
 480
 481             if (!ngx_threaded && !ngx_accept_mutex_held) {
 482                 wev->event_handler(wev);
 483
 484             } else {
 485                 ngx_post_event(wev);
 486             }
 487         }
 488
 489         /*
 490          * POLLIN must be handled after POLLOUT because we use
 491          * the optimization to avoid the unnecessary mutex locking/unlocking
 492          * if the accept event is the last one.
 493          */
 494
 495         rev = c->read;
 496
 497         if ((event_list[i].events & (POLLIN|POLLERR|POLLHUP)) && rev->active) {
 498             rev->ready = 1;
 499
 500             if (!ngx_threaded && !ngx_accept_mutex_held) {
 501                 rev->event_handler(rev);
 502
 503             } else if (!rev->accept) {
 504                 ngx_post_event(rev);
 505
 506             } else if (ngx_accept_disabled <= 0) {
 507                 ngx_mutex_unlock(ngx_posted_events_mutex);
 508
 509                 c->read->event_handler(rev);
 510
 511                 if (ngx_accept_disabled > 0) {
 512                     ngx_accept_mutex_unlock();
 513                     accept_lock = 0;
 514                 }
 515
 516                 if (i + 1 == events) {
 517                     lock = 0;
 518                     break;
 519                 }
 520
 521                 if (ngx_mutex_lock(ngx_posted_events_mutex) == NGX_ERROR) {
 522                     if (accept_lock) {
 523                         ngx_accept_mutex_unlock();
 524                     }
 525                     return NGX_ERROR;
 526                 }
 527             }
 528         }
 529     }
 530
 531     if (accept_lock) {
 532         ngx_accept_mutex_unlock();
 533     }
 534
 535     if (lock) {
 536         ngx_mutex_unlock(ngx_posted_events_mutex);
 537     }
 538
 539     if (expire && delta) {
 540         ngx_event_expire_timers((ngx_msec_t) delta);
 541     }
 542
 543     if (!ngx_threaded) {
 544         ngx_event_process_posted(cycle);
 545     }
 546
 547     return NGX_OK;
 548 }
 549
 550
 551 static void *ngx_devpoll_create_conf(ngx_cycle_t *cycle)
 552 {
 553     ngx_devpoll_conf_t  *dpcf;
 554
 555     ngx_test_null(dpcf, ngx_palloc(cycle->pool, sizeof(ngx_devpoll_conf_t)),
 556                   NGX_CONF_ERROR);
 557
 558     dpcf->changes = NGX_CONF_UNSET;
 559     dpcf->events = NGX_CONF_UNSET;
 560
 561     return dpcf;
 562 }
 563
 564
 565 static char *ngx_devpoll_init_conf(ngx_cycle_t *cycle, void *conf)
 566 {
 567     ngx_devpoll_conf_t *dpcf = conf;
 568
 569     ngx_conf_init_unsigned_value(dpcf->changes, 512);
 570     ngx_conf_init_unsigned_value(dpcf->events, 512);
 571
 572     return NGX_CONF_OK;
 573 }