One Level Up Top Level

src/event/modules/ngx_kqueue_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>


  13. typedef struct {
  14.     ngx_uint_t  changes;
  15.     ngx_uint_t  events;
  16. ‌} ngx_kqueue_conf_t;


  19. static ngx_int_t ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  20. static void ngx_kqueue_done(ngx_cycle_t *cycle);
  21. static ngx_int_t ngx_kqueue_add_event(ngx_event_t *ev, ngx_int_t event,
  22.     ngx_uint_t flags);
  23. static ngx_int_t ngx_kqueue_del_event(ngx_event_t *ev, ngx_int_t event,
  24.     ngx_uint_t flags);
  25. static ngx_int_t ngx_kqueue_set_event(ngx_event_t *ev, ngx_int_t filter,
  26.     ngx_uint_t flags);
  27. static ngx_int_t ngx_kqueue_process_changes(ngx_cycle_t *cycle, ngx_uint_t try);
  28. static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  29.     ngx_uint_t flags);
  30. static ngx_inline void ngx_kqueue_dump_event(ngx_log_t *log,
  31.     struct kevent *kev);

  33. static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle);
  34. static char *ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf);


  37. ‌int                    ngx_kqueue = -1;

  39. /*
  40. * The "change_list" should be declared as ngx_thread_volatile.
  41. * However, the use of the change_list is localized in kqueue functions and
  42. * is protected by the mutex so even the "icc -ipo" should not build the code
  43. * with the race condition.  Thus we avoid the declaration to make a more
  44. * readable code.
  45. */

  47. ‌‌‌static struct kevent  *change_list, *change_list0, *change_list1;
  48. ‌static struct kevent  *event_list;
  49. ‌‌‌static ngx_uint_t      max_changes, nchanges, nevents;

  51. #if (NGX_THREADS)
  52. ‌static ngx_mutex_t    *list_mutex;
  53. ‌static ngx_mutex_t    *kevent_mutex;
  54. #endif



  58. ‌static ngx_str_t      kqueue_name = ngx_string("kqueue");

  60. ‌static ngx_command_t  ngx_kqueue_commands[] = {

  62.     { ngx_string("kqueue_changes"),
  63.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  64.       ngx_conf_set_num_slot,
  65.       0,
  66.       offsetof(ngx_kqueue_conf_t, changes),
  67.       NULL },

  69.     { ngx_string("kqueue_events"),
  70.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  71.       ngx_conf_set_num_slot,
  72.       0,
  73.       offsetof(ngx_kqueue_conf_t, events),
  74.       NULL },

  76.       ngx_null_command
  77. };


  80. ‌ngx_event_module_t  ngx_kqueue_module_ctx = {
  81.     &kqueue_name,
  82.     ngx_kqueue_create_conf,                /* create configuration */
  83.     ngx_kqueue_init_conf,                  /* init configuration */

  85.     {
  86.         ngx_kqueue_add_event,              /* add an event */
  87.         ngx_kqueue_del_event,              /* delete an event */
  88.         ngx_kqueue_add_event,              /* enable an event */
  89.         ngx_kqueue_del_event,              /* disable an event */
  90.         NULL,                              /* add an connection */
  91.         NULL,                              /* delete an connection */
  92.         ngx_kqueue_process_changes,        /* process the changes */
  93.         ngx_kqueue_process_events,         /* process the events */
  94.         ngx_kqueue_init,                   /* init the events */
  95.         ngx_kqueue_done                    /* done the events */
  96.     }

  98. };

  100. ‌ngx_module_t  ngx_kqueue_module = {
  101.     NGX_MODULE_V1,
  102.     &ngx_kqueue_module_ctx,                /* module context */
  103.     ngx_kqueue_commands,                   /* module directives */
  104.     NGX_EVENT_MODULE,                      /* module type */
  105.     NULL,                                  /* init master */
  106.     NULL,                                  /* init module */
  107.     NULL,                                  /* init process */
  108.     NULL,                                  /* init thread */
  109.     NULL,                                  /* exit thread */
  110.     NULL,                                  /* exit process */
  111.     NULL,                                  /* exit master */
  112.     NGX_MODULE_V1_PADDING
  113. };


  116. static ngx_int_t
  117. ‌ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  118. {
  119.     ngx_kqueue_conf_t  *kcf;
  120.     struct timespec     ts;
  121. #if (NGX_HAVE_TIMER_EVENT)
  122.     struct kevent       kev;
  123. #endif

  125.     kcf = ngx_event_get_conf(cycle->conf_ctx, ngx_kqueue_module);

  127.     if (ngx_kqueue == -1) {
  128.         ngx_kqueue = kqueue();

  130.         if (ngx_kqueue == -1) {
  131.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  132.                           "kqueue() failed");
  133.             return NGX_ERROR;
  134.         }

  136. #if (NGX_THREADS)

  138.         list_mutex = ngx_mutex_init(cycle->log, 0);
  139.         if (list_mutex == NULL) {
  140.             return NGX_ERROR;
  141.         }

  143.         kevent_mutex = ngx_mutex_init(cycle->log, 0);
  144.         if (kevent_mutex == NULL) {
  145.             return NGX_ERROR;
  146.         }

  148. #endif
  149.     }

  151.     if (max_changes < kcf->changes) {
  152.         if (nchanges) {
  153.             ts.tv_sec = 0;
  154.             ts.tv_nsec = 0;

  156.             if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
  157.                 == -1)
  158.             {
  159.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  160.                               "kevent() failed");
  161.                 return NGX_ERROR;
  162.             }
  163.             nchanges = 0;
  164.         }

  166.         if (change_list0) {
  167.             ngx_free(change_list0);
  168.         }

  170.         change_list0 = ngx_alloc(kcf->changes * sizeof(struct kevent),
  171.                                  cycle->log);
  172.         if (change_list0 == NULL) {
  173.             return NGX_ERROR;
  174.         }

  176.         if (change_list1) {
  177.             ngx_free(change_list1);
  178.         }

  180.         change_list1 = ngx_alloc(kcf->changes * sizeof(struct kevent),
  181.                                  cycle->log);
  182.         if (change_list1 == NULL) {
  183.             return NGX_ERROR;
  184.         }

  186.         change_list = change_list0;
  187.     }

  189.     max_changes = kcf->changes;

  191.     if (nevents < kcf->events) {
  192.         if (event_list) {
  193.             ngx_free(event_list);
  194.         }

  196.         event_list = ngx_alloc(kcf->events * sizeof(struct kevent), cycle->log);
  197.         if (event_list == NULL) {
  198.             return NGX_ERROR;
  199.         }
  200.     }

  202.     ngx_event_flags = NGX_USE_ONESHOT_EVENT
  203.                       |NGX_USE_KQUEUE_EVENT
  204.                       |NGX_USE_VNODE_EVENT;

  206. #if (NGX_HAVE_TIMER_EVENT)

  208.     if (timer) {
  209.         kev.ident = 0;
  210.         kev.filter = EVFILT_TIMER;
  211.         kev.flags = EV_ADD|EV_ENABLE;
  212.         kev.fflags = 0;
  213.         kev.data = timer;
  214.         kev.udata = 0;

  216.         ts.tv_sec = 0;
  217.         ts.tv_nsec = 0;

  219.         if (kevent(ngx_kqueue, &kev, 1, NULL, 0, &ts) == -1) {
  220.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  221.                           "kevent(EVFILT_TIMER) failed");
  222.             return NGX_ERROR;
  223.         }

  225.         ngx_event_flags |= NGX_USE_TIMER_EVENT;
  226.     }

  228. #endif

  230. #if (NGX_HAVE_CLEAR_EVENT)
  231.     ngx_event_flags |= NGX_USE_CLEAR_EVENT;
  232. #else
  233.     ngx_event_flags |= NGX_USE_LEVEL_EVENT;
  234. #endif

  236. #if (NGX_HAVE_LOWAT_EVENT)
  237.     ngx_event_flags |= NGX_USE_LOWAT_EVENT;
  238. #endif

  240.     nevents = kcf->events;

  242.     ngx_io = ngx_os_io;

  244.     ngx_event_actions = ngx_kqueue_module_ctx.actions;

  246.     return NGX_OK;
  247. }


  250. static void
  251. ‌ngx_kqueue_done(ngx_cycle_t *cycle)
  252. {
  253.     if (close(ngx_kqueue) == -1) {
  254.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  255.                       "kqueue close() failed");
  256.     }

  258.     ngx_kqueue = -1;

  260. #if (NGX_THREADS)
  261.     ngx_mutex_destroy(kevent_mutex);
  262.     ngx_mutex_destroy(list_mutex);
  263. #endif

  265.     ngx_free(change_list1);
  266.     ngx_free(change_list0);
  267.     ngx_free(event_list);

  269.     change_list1 = NULL;
  270.     change_list0 = NULL;
  271.     change_list = NULL;
  272.     event_list = NULL;
  273.     max_changes = 0;
  274.     nchanges = 0;
  275.     nevents = 0;
  276. }


  279. static ngx_int_t
  280. ‌ngx_kqueue_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  281. {
  282.     ngx_int_t          rc;
  283. #if 0
  284.     ngx_event_t       *e;
  285.     ngx_connection_t  *c;
  286. #endif

  288.     ev->active = 1;
  289.     ev->disabled = 0;
  290.     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;

  292.     ngx_mutex_lock(list_mutex);

  294. #if 0

  296.     if (ev->index < nchanges
  297.         && ((uintptr_t) change_list[ev->index].udata & (uintptr_t) ~1)
  298.             == (uintptr_t) ev)
  299.     {
  300.         if (change_list[ev->index].flags == EV_DISABLE) {

  302.             /*
  303.              * if the EV_DISABLE is still not passed to a kernel
  304.              * we will not pass it
  305.              */

  307.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  308.                            "kevent activated: %d: ft:%i",
  309.                            ngx_event_ident(ev->data), event);

  311.             if (ev->index < --nchanges) {
  312.                 e = (ngx_event_t *)
  313.                     ((uintptr_t) change_list[nchanges].udata & (uintptr_t) ~1);
  314.                 change_list[ev->index] = change_list[nchanges];
  315.                 e->index = ev->index;
  316.             }

  318.             ngx_mutex_unlock(list_mutex);

  320.             return NGX_OK;
  321.         }

  323.         c = ev->data;

  325.         ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
  326.                       "previous event on #%d were not passed in kernel", c->fd);

  328.         ngx_mutex_unlock(list_mutex);

  330.         return NGX_ERROR;
  331.     }

  333. #endif

  335.     rc = ngx_kqueue_set_event(ev, event, EV_ADD|EV_ENABLE|flags);

  337.     ngx_mutex_unlock(list_mutex);

  339.     return rc;
  340. }


  343. static ngx_int_t
  344. ‌ngx_kqueue_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  345. {
  346.     ngx_int_t     rc;
  347.     ngx_event_t  *e;

  349.     ev->active = 0;
  350.     ev->disabled = 0;

  352.     ngx_mutex_lock(list_mutex);

  354.     if (ev->index < nchanges
  355.         && ((uintptr_t) change_list[ev->index].udata & (uintptr_t) ~1)
  356.             == (uintptr_t) ev)
  357.     {
  358.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  359.                        "kevent deleted: %d: ft:%i",
  360.                        ngx_event_ident(ev->data), event);

  362.         /* if the event is still not passed to a kernel we will not pass it */

  364.         nchanges--;

  366.         if (ev->index < nchanges) {
  367.             e = (ngx_event_t *)
  368.                     ((uintptr_t) change_list[nchanges].udata & (uintptr_t) ~1);
  369.             change_list[ev->index] = change_list[nchanges];
  370.             e->index = ev->index;
  371.         }

  373.         ngx_mutex_unlock(list_mutex);

  375.         return NGX_OK;
  376.     }

  378.     /*
  379.      * when the file descriptor is closed the kqueue automatically deletes
  380.      * its filters so we do not need to delete explicitly the event
  381.      * before the closing the file descriptor.
  382.      */

  384.     if (flags & NGX_CLOSE_EVENT) {
  385.         ngx_mutex_unlock(list_mutex);
  386.         return NGX_OK;
  387.     }

  389.     if (flags & NGX_DISABLE_EVENT) {
  390.         ev->disabled = 1;

  392.     } else {
  393.         flags |= EV_DELETE;
  394.     }

  396.     rc = ngx_kqueue_set_event(ev, event, flags);

  398.     ngx_mutex_unlock(list_mutex);

  400.     return rc;
  401. }


  404. static ngx_int_t
  405. ‌ngx_kqueue_set_event(ngx_event_t *ev, ngx_int_t filter, ngx_uint_t flags)
  406. {
  407.     struct kevent     *kev;
  408.     struct timespec    ts;
  409.     ngx_connection_t  *c;

  411.     c = ev->data;

  413.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  414.                    "kevent set event: %d: ft:%i fl:%04Xi",
  415.                    c->fd, filter, flags);

  417.     if (nchanges >= max_changes) {
  418.         ngx_log_error(NGX_LOG_WARN, ev->log, 0,
  419.                       "kqueue change list is filled up");

  421.         ts.tv_sec = 0;
  422.         ts.tv_nsec = 0;

  424.         if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
  425.             == -1)
  426.         {
  427.             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent() failed");
  428.             return NGX_ERROR;
  429.         }

  431.         nchanges = 0;
  432.     }

  434.     kev = &change_list[nchanges];

  436.     kev->ident = c->fd;
  437.     kev->filter = (short) filter;
  438.     kev->flags = (u_short) flags;
  439.     kev->udata = NGX_KQUEUE_UDATA_T ((uintptr_t) ev | ev->instance);

  441.     if (filter == EVFILT_VNODE) {
  442.         kev->fflags = NOTE_DELETE|NOTE_WRITE|NOTE_EXTEND
  443.                                  |NOTE_ATTRIB|NOTE_RENAME
  444. #if (__FreeBSD__ == 4 && __FreeBSD_version >= 430000) \
  445.     || __FreeBSD_version >= 500018
  446.                                  |NOTE_REVOKE
  447. #endif
  448.                       ;
  449.         kev->data = 0;

  451.     } else {
  452. #if (NGX_HAVE_LOWAT_EVENT)
  453.         if (flags & NGX_LOWAT_EVENT) {
  454.             kev->fflags = NOTE_LOWAT;
  455.             kev->data = ev->available;

  457.         } else {
  458.             kev->fflags = 0;
  459.             kev->data = 0;
  460.         }
  461. #else
  462.         kev->fflags = 0;
  463.         kev->data = 0;
  464. #endif
  465.     }

  467.     ev->index = nchanges;
  468.     nchanges++;

  470.     if (flags & NGX_FLUSH_EVENT) {
  471.         ts.tv_sec = 0;
  472.         ts.tv_nsec = 0;

  474.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "kevent flush");

  476.         if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
  477.             == -1)
  478.         {
  479.             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent() failed");
  480.             return NGX_ERROR;
  481.         }

  483.         nchanges = 0;
  484.     }

  486.     return NGX_OK;
  487. }


  490. static ngx_int_t
  491. ‌ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  492.     ngx_uint_t flags)
  493. {
  494.     int               events, n;
  495.     ngx_int_t         i, instance;
  496.     ngx_uint_t        level;
  497.     ngx_err_t         err;
  498.     ngx_event_t      *ev;
  499.     ngx_queue_t      *queue;
  500.     struct timespec   ts, *tp;

  502.     if (ngx_threaded) {
  503.         if (ngx_kqueue_process_changes(cycle, 0) == NGX_ERROR) {
  504.             return NGX_ERROR;
  505.         }

  507.         n = 0;

  509.     } else {
  510.         n = (int) nchanges;
  511.         nchanges = 0;
  512.     }

  514.     if (timer == NGX_TIMER_INFINITE) {
  515.         tp = NULL;

  517.     } else {

  519.         ts.tv_sec = timer / 1000;
  520.         ts.tv_nsec = (timer % 1000) * 1000000;

  522.         /*
  523.          * 64-bit Darwin kernel has the bug: kernel level ts.tv_nsec is
  524.          * the int32_t while user level ts.tv_nsec is the long (64-bit),
  525.          * so on the big endian PowerPC all nanoseconds are lost.
  526.          */

  528. #if (NGX_DARWIN_KEVENT_BUG)
  529.         ts.tv_nsec <<= 32;
  530. #endif

  532.         tp = &ts;
  533.     }

  535.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  536.                    "kevent timer: %M, changes: %d", timer, n);

  538.     events = kevent(ngx_kqueue, change_list, n, event_list, (int) nevents, tp);

  540.     err = (events == -1) ? ngx_errno : 0;

  542.     if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
  543.         ngx_time_update();
  544.     }

  546.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  547.                    "kevent events: %d", events);

  549.     if (err) {
  550.         if (err == NGX_EINTR) {

  552.             if (ngx_event_timer_alarm) {
  553.                 ngx_event_timer_alarm = 0;
  554.                 return NGX_OK;
  555.             }

  557.             level = NGX_LOG_INFO;

  559.         } else {
  560.             level = NGX_LOG_ALERT;
  561.         }

  563.         ngx_log_error(level, cycle->log, err, "kevent() failed");
  564.         return NGX_ERROR;
  565.     }

  567.     if (events == 0) {
  568.         if (timer != NGX_TIMER_INFINITE) {
  569.             return NGX_OK;
  570.         }

  572.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  573.                       "kevent() returned no events without timeout");
  574.         return NGX_ERROR;
  575.     }

  577.     for (i = 0; i < events; i++) {

  579.         ngx_kqueue_dump_event(cycle->log, &event_list[i]);

  581.         if (event_list[i].flags & EV_ERROR) {
  582.             ngx_log_error(NGX_LOG_ALERT, cycle->log, event_list[i].data,
  583.                           "kevent() error on %d filter:%d flags:%04Xd",
  584.                           event_list[i].ident, event_list[i].filter,
  585.                           event_list[i].flags);
  586.             continue;
  587.         }

  589. #if (NGX_HAVE_TIMER_EVENT)

  591.         if (event_list[i].filter == EVFILT_TIMER) {
  592.             ngx_time_update();
  593.             continue;
  594.         }

  596. #endif

  598.         ev = (ngx_event_t *) event_list[i].udata;

  600.         switch (event_list[i].filter) {

  602.         case EVFILT_READ:
  603.         case EVFILT_WRITE:

  605.             instance = (uintptr_t) ev & 1;
  606.             ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1);

  608.             if (ev->closed || ev->instance != instance) {

  610.                 /*
  611.                  * the stale event from a file descriptor
  612.                  * that was just closed in this iteration
  613.                  */

  615.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  616.                                "kevent: stale event %p", ev);
  617.                 continue;
  618.             }

  620.             if (ev->log && (ev->log->log_level & NGX_LOG_DEBUG_CONNECTION)) {
  621.                 ngx_kqueue_dump_event(ev->log, &event_list[i]);
  622.             }

  624.             if (ev->oneshot) {
  625.                 ev->active = 0;
  626.             }

  628.             ev->available = event_list[i].data;

  630.             if (event_list[i].flags & EV_EOF) {
  631.                 ev->pending_eof = 1;
  632.                 ev->kq_errno = event_list[i].fflags;
  633.             }

  635.             ev->ready = 1;

  637.             break;

  639.         case EVFILT_VNODE:
  640.             ev->kq_vnode = 1;

  642.             break;

  644.         case EVFILT_AIO:
  645.             ev->complete = 1;
  646.             ev->ready = 1;

  648.             break;

  650.         default:
  651.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  652.                           "unexpected kevent() filter %d",
  653.                           event_list[i].filter);
  654.             continue;
  655.         }

  657.         if (flags & NGX_POST_EVENTS) {
  658.             queue = ev->accept ? &ngx_posted_accept_events
  659.                                : &ngx_posted_events;

  661.             ngx_post_event(ev, queue);

  663.             continue;
  664.         }

  666.         ev->handler(ev);
  667.     }

  669.     return NGX_OK;
  670. }


  673. static ngx_int_t
  674. ‌ngx_kqueue_process_changes(ngx_cycle_t *cycle, ngx_uint_t try)
  675. {
  676.     int               n;
  677.     ngx_int_t         rc;
  678.     ngx_err_t         err;
  679.     struct timespec   ts;
  680.     struct kevent    *changes;

  682.     ngx_mutex_lock(kevent_mutex);

  684.     ngx_mutex_lock(list_mutex);

  686.     if (nchanges == 0) {
  687.         ngx_mutex_unlock(list_mutex);
  688.         ngx_mutex_unlock(kevent_mutex);
  689.         return NGX_OK;
  690.     }

  692.     changes = change_list;
  693.     if (change_list == change_list0) {
  694.         change_list = change_list1;
  695.     } else {
  696.         change_list = change_list0;
  697.     }

  699.     n = (int) nchanges;
  700.     nchanges = 0;

  702.     ngx_mutex_unlock(list_mutex);

  704.     ts.tv_sec = 0;
  705.     ts.tv_nsec = 0;

  707.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  708.                    "kevent changes: %d", n);

  710.     if (kevent(ngx_kqueue, changes, n, NULL, 0, &ts) == -1) {
  711.         err = ngx_errno;
  712.         ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
  713.                       cycle->log, err, "kevent() failed");
  714.         rc = NGX_ERROR;

  716.     } else {
  717.         rc = NGX_OK;
  718.     }

  720.     ngx_mutex_unlock(kevent_mutex);

  722.     return rc;
  723. }


  726. static ngx_inline void
  727. ‌ngx_kqueue_dump_event(ngx_log_t *log, struct kevent *kev)
  728. {
  729.     ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,
  730.                    (kev->ident > 0x8000000 && kev->ident != (unsigned) -1) ?
  731.                     "kevent: %p: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p":
  732.                     "kevent: %d: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p",
  733.                     kev->ident, kev->filter,
  734.                     kev->flags, kev->fflags,
  735.                     kev->data, kev->udata);
  736. }


  739. static void *
  740. ‌ngx_kqueue_create_conf(ngx_cycle_t *cycle)
  741. {
  742.     ngx_kqueue_conf_t  *kcf;

  744.     kcf = ngx_palloc(cycle->pool, sizeof(ngx_kqueue_conf_t));
  745.     if (kcf == NULL) {
  746.         return NULL;
  747.     }

  749.     kcf->changes = NGX_CONF_UNSET;
  750.     kcf->events = NGX_CONF_UNSET;

  752.     return kcf;
  753. }


  756. static char *
  757. ‌ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf)
  758. {
  759.     ngx_kqueue_conf_t *kcf = conf;

  761.     ngx_conf_init_uint_value(kcf->changes, 512);
  762.     ngx_conf_init_uint_value(kcf->events, 512);

  764.     return NGX_CONF_OK;
  765. }

One Level Up Top Level