One Level Up Top Level

src/event/modules/ngx_kqueue_module.c - nginx

Global variables defined

Data types defined

Functions defined

Macros 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. /* NetBSD up to 10.0 incompatibly defines kevent.udata as "intptr_t" */

  15. #if (__NetBSD__ && __NetBSD_Version__ < 1000000000)
  16. ‌#define NGX_KQUEUE_UDATA_T
  17. #else
  18. ‌#define NGX_KQUEUE_UDATA_T  (void *)
  19. #endif


  22. ‌typedef struct {
  23.     ngx_uint_t  changes;
  24.     ngx_uint_t  events;
  25. ‌} ngx_kqueue_conf_t;


  28. static ngx_int_t ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  29. #ifdef EVFILT_USER
  30. static ngx_int_t ngx_kqueue_notify_init(ngx_log_t *log);
  31. #endif
  32. static void ngx_kqueue_done(ngx_cycle_t *cycle);
  33. static ngx_int_t ngx_kqueue_add_event(ngx_event_t *ev, ngx_int_t event,
  34.     ngx_uint_t flags);
  35. static ngx_int_t ngx_kqueue_del_event(ngx_event_t *ev, ngx_int_t event,
  36.     ngx_uint_t flags);
  37. static ngx_int_t ngx_kqueue_set_event(ngx_event_t *ev, ngx_int_t filter,
  38.     ngx_uint_t flags);
  39. #ifdef EVFILT_USER
  40. static ngx_int_t ngx_kqueue_notify(ngx_event_handler_pt handler);
  41. #endif
  42. static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  43.     ngx_uint_t flags);
  44. static ngx_inline void ngx_kqueue_dump_event(ngx_log_t *log,
  45.     struct kevent *kev);

  47. static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle);
  48. static char *ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf);


  51. ‌int                    ngx_kqueue = -1;

  53. ‌static struct kevent  *change_list;
  54. ‌static struct kevent  *event_list;
  55. ‌‌‌static ngx_uint_t      max_changes, nchanges, nevents;

  57. #ifdef EVFILT_USER
  58. ‌static ngx_event_t     notify_event;
  59. ‌static struct kevent   notify_kev;
  60. #endif


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

  65. ‌static ngx_command_t  ngx_kqueue_commands[] = {

  67.     { ngx_string("kqueue_changes"),
  68.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  69.       ngx_conf_set_num_slot,
  70.       0,
  71.       offsetof(ngx_kqueue_conf_t, changes),
  72.       NULL },

  74.     { ngx_string("kqueue_events"),
  75.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  76.       ngx_conf_set_num_slot,
  77.       0,
  78.       offsetof(ngx_kqueue_conf_t, events),
  79.       NULL },

  81.       ngx_null_command
  82. };


  85. ‌static ngx_event_module_t  ngx_kqueue_module_ctx = {
  86.     &kqueue_name,
  87.     ngx_kqueue_create_conf,                /* create configuration */
  88.     ngx_kqueue_init_conf,                  /* init configuration */

  90.     {
  91.         ngx_kqueue_add_event,              /* add an event */
  92.         ngx_kqueue_del_event,              /* delete an event */
  93.         ngx_kqueue_add_event,              /* enable an event */
  94.         ngx_kqueue_del_event,              /* disable an event */
  95.         NULL,                              /* add an connection */
  96.         NULL,                              /* delete an connection */
  97. #ifdef EVFILT_USER
  98.         ngx_kqueue_notify,                 /* trigger a notify */
  99. #else
  100.         NULL,                              /* trigger a notify */
  101. #endif
  102.         ngx_kqueue_process_events,         /* process the events */
  103.         ngx_kqueue_init,                   /* init the events */
  104.         ngx_kqueue_done                    /* done the events */
  105.     }

  107. };

  109. ‌ngx_module_t  ngx_kqueue_module = {
  110.     NGX_MODULE_V1,
  111.     &ngx_kqueue_module_ctx,                /* module context */
  112.     ngx_kqueue_commands,                   /* module directives */
  113.     NGX_EVENT_MODULE,                      /* module type */
  114.     NULL,                                  /* init master */
  115.     NULL,                                  /* init module */
  116.     NULL,                                  /* init process */
  117.     NULL,                                  /* init thread */
  118.     NULL,                                  /* exit thread */
  119.     NULL,                                  /* exit process */
  120.     NULL,                                  /* exit master */
  121.     NGX_MODULE_V1_PADDING
  122. };


  125. static ngx_int_t
  126. ‌ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  127. {
  128.     ngx_kqueue_conf_t  *kcf;
  129.     struct timespec     ts;
  130. #if (NGX_HAVE_TIMER_EVENT)
  131.     struct kevent       kev;
  132. #endif

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

  136.     if (ngx_kqueue == -1) {
  137.         ngx_kqueue = kqueue();

  139.         if (ngx_kqueue == -1) {
  140.             ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  141.                           "kqueue() failed");
  142.             return NGX_ERROR;
  143.         }

  145. #ifdef EVFILT_USER
  146.         if (ngx_kqueue_notify_init(cycle->log) != NGX_OK) {
  147.             return NGX_ERROR;
  148.         }
  149. #endif
  150.     }

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

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

  167.         if (change_list) {
  168.             ngx_free(change_list);
  169.         }

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

  178.     max_changes = kcf->changes;

  180.     if (nevents < kcf->events) {
  181.         if (event_list) {
  182.             ngx_free(event_list);
  183.         }

  185.         event_list = ngx_alloc(kcf->events * sizeof(struct kevent), cycle->log);
  186.         if (event_list == NULL) {
  187.             return NGX_ERROR;
  188.         }
  189.     }

  191.     ngx_event_flags = NGX_USE_ONESHOT_EVENT
  192.                       |NGX_USE_KQUEUE_EVENT
  193.                       |NGX_USE_VNODE_EVENT;

  195. #if (NGX_HAVE_TIMER_EVENT)

  197.     if (timer) {
  198.         kev.ident = 0;
  199.         kev.filter = EVFILT_TIMER;
  200.         kev.flags = EV_ADD|EV_ENABLE;
  201.         kev.fflags = 0;
  202.         kev.data = timer;
  203.         kev.udata = NGX_KQUEUE_UDATA_T (uintptr_t) 0;

  205.         ts.tv_sec = 0;
  206.         ts.tv_nsec = 0;

  208.         if (kevent(ngx_kqueue, &kev, 1, NULL, 0, &ts) == -1) {
  209.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  210.                           "kevent(EVFILT_TIMER) failed");
  211.             return NGX_ERROR;
  212.         }

  214.         ngx_event_flags |= NGX_USE_TIMER_EVENT;
  215.     }

  217. #endif

  219. #if (NGX_HAVE_CLEAR_EVENT)
  220.     ngx_event_flags |= NGX_USE_CLEAR_EVENT;
  221. #else
  222.     ngx_event_flags |= NGX_USE_LEVEL_EVENT;
  223. #endif

  225. #if (NGX_HAVE_LOWAT_EVENT)
  226.     ngx_event_flags |= NGX_USE_LOWAT_EVENT;
  227. #endif

  229.     nevents = kcf->events;

  231.     ngx_io = ngx_os_io;

  233.     ngx_event_actions = ngx_kqueue_module_ctx.actions;

  235.     return NGX_OK;
  236. }


  239. #ifdef EVFILT_USER

  241. static ngx_int_t
  242. ‌ngx_kqueue_notify_init(ngx_log_t *log)
  243. {
  244.     notify_kev.ident = 0;
  245.     notify_kev.filter = EVFILT_USER;
  246.     notify_kev.data = 0;
  247.     notify_kev.flags = EV_ADD|EV_CLEAR;
  248.     notify_kev.fflags = 0;
  249.     notify_kev.udata = NGX_KQUEUE_UDATA_T (uintptr_t) 0;

  251.     if (kevent(ngx_kqueue, &notify_kev, 1, NULL, 0, NULL) == -1) {
  252.         ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
  253.                       "kevent(EVFILT_USER, EV_ADD) failed");
  254.         return NGX_ERROR;
  255.     }

  257.     notify_event.active = 1;
  258.     notify_event.log = log;

  260.     notify_kev.flags = 0;
  261.     notify_kev.fflags = NOTE_TRIGGER;
  262.     notify_kev.udata = NGX_KQUEUE_UDATA_T ((uintptr_t) &notify_event);

  264.     return NGX_OK;
  265. }

  267. #endif


  270. static void
  271. ‌ngx_kqueue_done(ngx_cycle_t *cycle)
  272. {
  273.     if (close(ngx_kqueue) == -1) {
  274.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  275.                       "kqueue close() failed");
  276.     }

  278.     ngx_kqueue = -1;

  280.     ngx_free(change_list);
  281.     ngx_free(event_list);

  283.     change_list = NULL;
  284.     event_list = NULL;
  285.     max_changes = 0;
  286.     nchanges = 0;
  287.     nevents = 0;
  288. }


  291. static ngx_int_t
  292. ‌ngx_kqueue_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  293. {
  294.     ngx_int_t          rc;
  295. #if 0
  296.     ngx_event_t       *e;
  297.     ngx_connection_t  *c;
  298. #endif

  300.     ev->active = 1;
  301.     ev->disabled = 0;
  302.     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;

  304. #if 0

  306.     if (ev->index < nchanges
  307.         && ((uintptr_t) change_list[ev->index].udata & (uintptr_t) ~1)
  308.             == (uintptr_t) ev)
  309.     {
  310.         if (change_list[ev->index].flags == EV_DISABLE) {

  312.             /*
  313.              * if the EV_DISABLE is still not passed to a kernel
  314.              * we will not pass it
  315.              */

  317.             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  318.                            "kevent activated: %d: ft:%i",
  319.                            ngx_event_ident(ev->data), event);

  321.             if (ev->index < --nchanges) {
  322.                 e = (ngx_event_t *)
  323.                     ((uintptr_t) change_list[nchanges].udata & (uintptr_t) ~1);
  324.                 change_list[ev->index] = change_list[nchanges];
  325.                 e->index = ev->index;
  326.             }

  328.             return NGX_OK;
  329.         }

  331.         c = ev->data;

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

  336.         return NGX_ERROR;
  337.     }

  339. #endif

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

  343.     return rc;
  344. }


  347. static ngx_int_t
  348. ‌ngx_kqueue_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  349. {
  350.     ngx_int_t     rc;
  351.     ngx_event_t  *e;

  353.     ev->active = 0;
  354.     ev->disabled = 0;

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

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

  366.         nchanges--;

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

  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.         return NGX_OK;
  386.     }

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

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

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

  397.     return rc;
  398. }


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

  408.     c = ev->data;

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

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

  418.         ts.tv_sec = 0;
  419.         ts.tv_nsec = 0;

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

  428.         nchanges = 0;
  429.     }

  431.     kev = &change_list[nchanges];

  433.     kev->ident = c->fd;
  434.     kev->filter = (short) filter;
  435.     kev->flags = (u_short) flags;
  436.     kev->udata = NGX_KQUEUE_UDATA_T ((uintptr_t) ev | ev->instance);

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

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

  454.         } else {
  455.             kev->fflags = 0;
  456.             kev->data = 0;
  457.         }
  458. #else
  459.         kev->fflags = 0;
  460.         kev->data = 0;
  461. #endif
  462.     }

  464.     ev->index = nchanges;
  465.     nchanges++;

  467.     if (flags & NGX_FLUSH_EVENT) {
  468.         ts.tv_sec = 0;
  469.         ts.tv_nsec = 0;

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

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

  480.         nchanges = 0;
  481.     }

  483.     return NGX_OK;
  484. }


  487. #ifdef EVFILT_USER

  489. static ngx_int_t
  490. ‌ngx_kqueue_notify(ngx_event_handler_pt handler)
  491. {
  492.     notify_event.handler = handler;

  494.     if (kevent(ngx_kqueue, &notify_kev, 1, NULL, 0, NULL) == -1) {
  495.         ngx_log_error(NGX_LOG_ALERT, notify_event.log, ngx_errno,
  496.                       "kevent(EVFILT_USER, NOTE_TRIGGER) failed");
  497.         return NGX_ERROR;
  498.     }

  500.     return NGX_OK;
  501. }

  503. #endif


  506. static ngx_int_t
  507. ‌ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  508.     ngx_uint_t flags)
  509. {
  510.     int               events, n;
  511.     ngx_int_t         i, instance;
  512.     ngx_uint_t        level;
  513.     ngx_err_t         err;
  514.     ngx_event_t      *ev;
  515.     ngx_queue_t      *queue;
  516.     struct timespec   ts, *tp;

  518.     n = (int) nchanges;
  519.     nchanges = 0;

  521.     if (timer == NGX_TIMER_INFINITE) {
  522.         tp = NULL;

  524.     } else {

  526.         ts.tv_sec = timer / 1000;
  527.         ts.tv_nsec = (timer % 1000) * 1000000;

  529.         /*
  530.          * 64-bit Darwin kernel has the bug: kernel level ts.tv_nsec is
  531.          * the int32_t while user level ts.tv_nsec is the long (64-bit),
  532.          * so on the big endian PowerPC all nanoseconds are lost.
  533.          */

  535. #if (NGX_DARWIN_KEVENT_BUG)
  536.         ts.tv_nsec <<= 32;
  537. #endif

  539.         tp = &ts;
  540.     }

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

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

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

  549.     if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
  550.         ngx_time_update();
  551.     }

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

  556.     if (err) {
  557.         if (err == NGX_EINTR) {

  559.             if (ngx_event_timer_alarm) {
  560.                 ngx_event_timer_alarm = 0;
  561.                 return NGX_OK;
  562.             }

  564.             level = NGX_LOG_INFO;

  566.         } else {
  567.             level = NGX_LOG_ALERT;
  568.         }

  570.         ngx_log_error(level, cycle->log, err, "kevent() failed");
  571.         return NGX_ERROR;
  572.     }

  574.     if (events == 0) {
  575.         if (timer != NGX_TIMER_INFINITE) {
  576.             return NGX_OK;
  577.         }

  579.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  580.                       "kevent() returned no events without timeout");
  581.         return NGX_ERROR;
  582.     }

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

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

  588.         if (event_list[i].flags & EV_ERROR) {
  589.             ngx_log_error(NGX_LOG_ALERT, cycle->log, event_list[i].data,
  590.                           "kevent() error on %d filter:%d flags:%04Xd",
  591.                           (int) event_list[i].ident, event_list[i].filter,
  592.                           event_list[i].flags);
  593.             continue;
  594.         }

  596. #if (NGX_HAVE_TIMER_EVENT)

  598.         if (event_list[i].filter == EVFILT_TIMER) {
  599.             ngx_time_update();
  600.             continue;
  601.         }

  603. #endif

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

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

  609.         case EVFILT_READ:
  610.         case EVFILT_WRITE:

  612.             instance = (uintptr_t) ev & 1;
  613.             ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1);

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

  617.                 /*
  618.                  * the stale event from a file descriptor
  619.                  * that was just closed in this iteration
  620.                  */

  622.                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  623.                                "kevent: stale event %p", ev);
  624.                 continue;
  625.             }

  627.             if (ev->log && (ev->log->log_level & NGX_LOG_DEBUG_CONNECTION)) {
  628.                 ngx_kqueue_dump_event(ev->log, &event_list[i]);
  629.             }

  631.             if (ev->oneshot) {
  632.                 ev->active = 0;
  633.             }

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

  637.             if (event_list[i].flags & EV_EOF) {
  638.                 ev->pending_eof = 1;
  639.                 ev->kq_errno = event_list[i].fflags;
  640.             }

  642.             ev->ready = 1;

  644.             break;

  646.         case EVFILT_VNODE:
  647.             ev->kq_vnode = 1;

  649.             break;

  651.         case EVFILT_AIO:
  652.             ev->complete = 1;
  653.             ev->ready = 1;

  655.             break;

  657. #ifdef EVFILT_USER
  658.         case EVFILT_USER:
  659.             break;
  660. #endif

  662.         default:
  663.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  664.                           "unexpected kevent() filter %d",
  665.                           event_list[i].filter);
  666.             continue;
  667.         }

  669.         if (flags & NGX_POST_EVENTS) {
  670.             queue = ev->accept ? &ngx_posted_accept_events
  671.                                : &ngx_posted_events;

  673.             ngx_post_event(ev, queue);

  675.             continue;
  676.         }

  678.         ev->handler(ev);
  679.     }

  681.     return NGX_OK;
  682. }


  685. static ngx_inline void
  686. ‌ngx_kqueue_dump_event(ngx_log_t *log, struct kevent *kev)
  687. {
  688.     if (kev->ident > 0x8000000 && kev->ident != (unsigned) -1) {
  689.         ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,
  690.                        "kevent: %p: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p",
  691.                        (void *) kev->ident, kev->filter,
  692.                        kev->flags, kev->fflags,
  693.                        (int) kev->data, kev->udata);

  695.     } else {
  696.         ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,
  697.                        "kevent: %d: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p",
  698.                        (int) kev->ident, kev->filter,
  699.                        kev->flags, kev->fflags,
  700.                        (int) kev->data, kev->udata);
  701.     }
  702. }


  705. static void *
  706. ‌ngx_kqueue_create_conf(ngx_cycle_t *cycle)
  707. {
  708.     ngx_kqueue_conf_t  *kcf;

  710.     kcf = ngx_palloc(cycle->pool, sizeof(ngx_kqueue_conf_t));
  711.     if (kcf == NULL) {
  712.         return NULL;
  713.     }

  715.     kcf->changes = NGX_CONF_UNSET;
  716.     kcf->events = NGX_CONF_UNSET;

  718.     return kcf;
  719. }


  722. static char *
  723. ‌ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf)
  724. {
  725.     ngx_kqueue_conf_t *kcf = conf;

  727.     ngx_conf_init_uint_value(kcf->changes, 512);
  728.     ngx_conf_init_uint_value(kcf->events, 512);

  730.     return NGX_CONF_OK;
  731. }

One Level Up Top Level