One Level Up Top Level

src/event/modules/ngx_kqueue_module.c - nginx source code

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. #ifdef EVFILT_USER
  21. static ngx_int_t ngx_kqueue_notify_init(ngx_log_t *log);
  22. #endif
  23. static void ngx_kqueue_done(ngx_cycle_t *cycle);
  24. static ngx_int_t ngx_kqueue_add_event(ngx_event_t *ev, ngx_int_t event,
  25.     ngx_uint_t flags);
  26. static ngx_int_t ngx_kqueue_del_event(ngx_event_t *ev, ngx_int_t event,
  27.     ngx_uint_t flags);
  28. static ngx_int_t ngx_kqueue_set_event(ngx_event_t *ev, ngx_int_t filter,
  29.     ngx_uint_t flags);
  30. #ifdef EVFILT_USER
  31. static ngx_int_t ngx_kqueue_notify(ngx_event_handler_pt handler);
  32. #endif
  33. static ngx_int_t ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  34.     ngx_uint_t flags);
  35. static ngx_inline void ngx_kqueue_dump_event(ngx_log_t *log,
  36.     struct kevent *kev);

  38. static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle);
  39. static char *ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf);


  42. ‌int                    ngx_kqueue = -1;

  44. ‌static struct kevent  *change_list;
  45. ‌static struct kevent  *event_list;
  46. ‌‌‌static ngx_uint_t      max_changes, nchanges, nevents;

  48. #ifdef EVFILT_USER
  49. ‌static ngx_event_t     notify_event;
  50. ‌static struct kevent   notify_kev;
  51. #endif


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

  56. ‌static ngx_command_t  ngx_kqueue_commands[] = {

  58.     { ngx_string("kqueue_changes"),
  59.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  60.       ngx_conf_set_num_slot,
  61.       0,
  62.       offsetof(ngx_kqueue_conf_t, changes),
  63.       NULL },

  65.     { ngx_string("kqueue_events"),
  66.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  67.       ngx_conf_set_num_slot,
  68.       0,
  69.       offsetof(ngx_kqueue_conf_t, events),
  70.       NULL },

  72.       ngx_null_command
  73. };


  76. ‌static ngx_event_module_t  ngx_kqueue_module_ctx = {
  77.     &kqueue_name,
  78.     ngx_kqueue_create_conf,                /* create configuration */
  79.     ngx_kqueue_init_conf,                  /* init configuration */

  81.     {
  82.         ngx_kqueue_add_event,              /* add an event */
  83.         ngx_kqueue_del_event,              /* delete an event */
  84.         ngx_kqueue_add_event,              /* enable an event */
  85.         ngx_kqueue_del_event,              /* disable an event */
  86.         NULL,                              /* add an connection */
  87.         NULL,                              /* delete an connection */
  88. #ifdef EVFILT_USER
  89.         ngx_kqueue_notify,                 /* trigger a notify */
  90. #else
  91.         NULL,                              /* trigger a notify */
  92. #endif
  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. #ifdef EVFILT_USER
  137.         if (ngx_kqueue_notify_init(cycle->log) != NGX_OK) {
  138.             return NGX_ERROR;
  139.         }
  140. #endif
  141.     }

  143.     if (max_changes < kcf->changes) {
  144.         if (nchanges) {
  145.             ts.tv_sec = 0;
  146.             ts.tv_nsec = 0;

  148.             if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
  149.                 == -1)
  150.             {
  151.                 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  152.                               "kevent() failed");
  153.                 return NGX_ERROR;
  154.             }
  155.             nchanges = 0;
  156.         }

  158.         if (change_list) {
  159.             ngx_free(change_list);
  160.         }

  162.         change_list = ngx_alloc(kcf->changes * sizeof(struct kevent),
  163.                                 cycle->log);
  164.         if (change_list == NULL) {
  165.             return NGX_ERROR;
  166.         }
  167.     }

  169.     max_changes = kcf->changes;

  171.     if (nevents < kcf->events) {
  172.         if (event_list) {
  173.             ngx_free(event_list);
  174.         }

  176.         event_list = ngx_alloc(kcf->events * sizeof(struct kevent), cycle->log);
  177.         if (event_list == NULL) {
  178.             return NGX_ERROR;
  179.         }
  180.     }

  182.     ngx_event_flags = NGX_USE_ONESHOT_EVENT
  183.                       |NGX_USE_KQUEUE_EVENT
  184.                       |NGX_USE_VNODE_EVENT;

  186. #if (NGX_HAVE_TIMER_EVENT)

  188.     if (timer) {
  189.         kev.ident = 0;
  190.         kev.filter = EVFILT_TIMER;
  191.         kev.flags = EV_ADD|EV_ENABLE;
  192.         kev.fflags = 0;
  193.         kev.data = timer;
  194.         kev.udata = 0;

  196.         ts.tv_sec = 0;
  197.         ts.tv_nsec = 0;

  199.         if (kevent(ngx_kqueue, &kev, 1, NULL, 0, &ts) == -1) {
  200.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  201.                           "kevent(EVFILT_TIMER) failed");
  202.             return NGX_ERROR;
  203.         }

  205.         ngx_event_flags |= NGX_USE_TIMER_EVENT;
  206.     }

  208. #endif

  210. #if (NGX_HAVE_CLEAR_EVENT)
  211.     ngx_event_flags |= NGX_USE_CLEAR_EVENT;
  212. #else
  213.     ngx_event_flags |= NGX_USE_LEVEL_EVENT;
  214. #endif

  216. #if (NGX_HAVE_LOWAT_EVENT)
  217.     ngx_event_flags |= NGX_USE_LOWAT_EVENT;
  218. #endif

  220.     nevents = kcf->events;

  222.     ngx_io = ngx_os_io;

  224.     ngx_event_actions = ngx_kqueue_module_ctx.actions;

  226.     return NGX_OK;
  227. }


  230. #ifdef EVFILT_USER

  232. static ngx_int_t
  233. ‌ngx_kqueue_notify_init(ngx_log_t *log)
  234. {
  235.     notify_kev.ident = 0;
  236.     notify_kev.filter = EVFILT_USER;
  237.     notify_kev.data = 0;
  238.     notify_kev.flags = EV_ADD|EV_CLEAR;
  239.     notify_kev.fflags = 0;
  240.     notify_kev.udata = 0;

  242.     if (kevent(ngx_kqueue, &notify_kev, 1, NULL, 0, NULL) == -1) {
  243.         ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
  244.                       "kevent(EVFILT_USER, EV_ADD) failed");
  245.         return NGX_ERROR;
  246.     }

  248.     notify_event.active = 1;
  249.     notify_event.log = log;

  251.     notify_kev.flags = 0;
  252.     notify_kev.fflags = NOTE_TRIGGER;
  253.     notify_kev.udata = NGX_KQUEUE_UDATA_T ((uintptr_t) &notify_event);

  255.     return NGX_OK;
  256. }

  258. #endif


  261. static void
  262. ‌ngx_kqueue_done(ngx_cycle_t *cycle)
  263. {
  264.     if (close(ngx_kqueue) == -1) {
  265.         ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  266.                       "kqueue close() failed");
  267.     }

  269.     ngx_kqueue = -1;

  271.     ngx_free(change_list);
  272.     ngx_free(event_list);

  274.     change_list = NULL;
  275.     event_list = NULL;
  276.     max_changes = 0;
  277.     nchanges = 0;
  278.     nevents = 0;
  279. }


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

  291.     ev->active = 1;
  292.     ev->disabled = 0;
  293.     ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;

  295. #if 0

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

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

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

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

  319.             return NGX_OK;
  320.         }

  322.         c = ev->data;

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

  327.         return NGX_ERROR;
  328.     }

  330. #endif

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

  334.     return rc;
  335. }


  338. static ngx_int_t
  339. ‌ngx_kqueue_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
  340. {
  341.     ngx_int_t     rc;
  342.     ngx_event_t  *e;

  344.     ev->active = 0;
  345.     ev->disabled = 0;

  347.     if (ev->index < nchanges
  348.         && ((uintptr_t) change_list[ev->index].udata & (uintptr_t) ~1)
  349.             == (uintptr_t) ev)
  350.     {
  351.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  352.                        "kevent deleted: %d: ft:%i",
  353.                        ngx_event_ident(ev->data), event);

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

  357.         nchanges--;

  359.         if (ev->index < nchanges) {
  360.             e = (ngx_event_t *)
  361.                     ((uintptr_t) change_list[nchanges].udata & (uintptr_t) ~1);
  362.             change_list[ev->index] = change_list[nchanges];
  363.             e->index = ev->index;
  364.         }

  366.         return NGX_OK;
  367.     }

  369.     /*
  370.      * when the file descriptor is closed the kqueue automatically deletes
  371.      * its filters so we do not need to delete explicitly the event
  372.      * before the closing the file descriptor.
  373.      */

  375.     if (flags & NGX_CLOSE_EVENT) {
  376.         return NGX_OK;
  377.     }

  379.     if (flags & NGX_DISABLE_EVENT) {
  380.         ev->disabled = 1;

  382.     } else {
  383.         flags |= EV_DELETE;
  384.     }

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

  388.     return rc;
  389. }


  392. static ngx_int_t
  393. ‌ngx_kqueue_set_event(ngx_event_t *ev, ngx_int_t filter, ngx_uint_t flags)
  394. {
  395.     struct kevent     *kev;
  396.     struct timespec    ts;
  397.     ngx_connection_t  *c;

  399.     c = ev->data;

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

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

  409.         ts.tv_sec = 0;
  410.         ts.tv_nsec = 0;

  412.         if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
  413.             == -1)
  414.         {
  415.             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent() failed");
  416.             return NGX_ERROR;
  417.         }

  419.         nchanges = 0;
  420.     }

  422.     kev = &change_list[nchanges];

  424.     kev->ident = c->fd;
  425.     kev->filter = (short) filter;
  426.     kev->flags = (u_short) flags;
  427.     kev->udata = NGX_KQUEUE_UDATA_T ((uintptr_t) ev | ev->instance);

  429.     if (filter == EVFILT_VNODE) {
  430.         kev->fflags = NOTE_DELETE|NOTE_WRITE|NOTE_EXTEND
  431.                                  |NOTE_ATTRIB|NOTE_RENAME
  432. #if (__FreeBSD__ == 4 && __FreeBSD_version >= 430000) \
  433.     || __FreeBSD_version >= 500018
  434.                                  |NOTE_REVOKE
  435. #endif
  436.                       ;
  437.         kev->data = 0;

  439.     } else {
  440. #if (NGX_HAVE_LOWAT_EVENT)
  441.         if (flags & NGX_LOWAT_EVENT) {
  442.             kev->fflags = NOTE_LOWAT;
  443.             kev->data = ev->available;

  445.         } else {
  446.             kev->fflags = 0;
  447.             kev->data = 0;
  448.         }
  449. #else
  450.         kev->fflags = 0;
  451.         kev->data = 0;
  452. #endif
  453.     }

  455.     ev->index = nchanges;
  456.     nchanges++;

  458.     if (flags & NGX_FLUSH_EVENT) {
  459.         ts.tv_sec = 0;
  460.         ts.tv_nsec = 0;

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

  464.         if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
  465.             == -1)
  466.         {
  467.             ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent() failed");
  468.             return NGX_ERROR;
  469.         }

  471.         nchanges = 0;
  472.     }

  474.     return NGX_OK;
  475. }


  478. #ifdef EVFILT_USER

  480. static ngx_int_t
  481. ‌ngx_kqueue_notify(ngx_event_handler_pt handler)
  482. {
  483.     notify_event.handler = handler;

  485.     if (kevent(ngx_kqueue, &notify_kev, 1, NULL, 0, NULL) == -1) {
  486.         ngx_log_error(NGX_LOG_ALERT, notify_event.log, ngx_errno,
  487.                       "kevent(EVFILT_USER, NOTE_TRIGGER) failed");
  488.         return NGX_ERROR;
  489.     }

  491.     return NGX_OK;
  492. }

  494. #endif


  497. static ngx_int_t
  498. ‌ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
  499.     ngx_uint_t flags)
  500. {
  501.     int               events, n;
  502.     ngx_int_t         i, instance;
  503.     ngx_uint_t        level;
  504.     ngx_err_t         err;
  505.     ngx_event_t      *ev;
  506.     ngx_queue_t      *queue;
  507.     struct timespec   ts, *tp;

  509.     n = (int) nchanges;
  510.     nchanges = 0;

  512.     if (timer == NGX_TIMER_INFINITE) {
  513.         tp = NULL;

  515.     } else {

  517.         ts.tv_sec = timer / 1000;
  518.         ts.tv_nsec = (timer % 1000) * 1000000;

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

  526. #if (NGX_DARWIN_KEVENT_BUG)
  527.         ts.tv_nsec <<= 32;
  528. #endif

  530.         tp = &ts;
  531.     }

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

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

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

  540.     if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
  541.         ngx_time_update();
  542.     }

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

  547.     if (err) {
  548.         if (err == NGX_EINTR) {

  550.             if (ngx_event_timer_alarm) {
  551.                 ngx_event_timer_alarm = 0;
  552.                 return NGX_OK;
  553.             }

  555.             level = NGX_LOG_INFO;

  557.         } else {
  558.             level = NGX_LOG_ALERT;
  559.         }

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

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

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

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

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

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

  587. #if (NGX_HAVE_TIMER_EVENT)

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

  594. #endif

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

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

  600.         case EVFILT_READ:
  601.         case EVFILT_WRITE:

  603.             instance = (uintptr_t) ev & 1;
  604.             ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1);

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

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

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

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

  622.             if (ev->oneshot) {
  623.                 ev->active = 0;
  624.             }

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

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

  633.             ev->ready = 1;

  635.             break;

  637.         case EVFILT_VNODE:
  638.             ev->kq_vnode = 1;

  640.             break;

  642.         case EVFILT_AIO:
  643.             ev->complete = 1;
  644.             ev->ready = 1;

  646.             break;

  648. #ifdef EVFILT_USER
  649.         case EVFILT_USER:
  650.             break;
  651. #endif

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

  660.         if (flags & NGX_POST_EVENTS) {
  661.             queue = ev->accept ? &ngx_posted_accept_events
  662.                                : &ngx_posted_events;

  664.             ngx_post_event(ev, queue);

  666.             continue;
  667.         }

  669.         ev->handler(ev);
  670.     }

  672.     return NGX_OK;
  673. }


  676. static ngx_inline void
  677. ‌ngx_kqueue_dump_event(ngx_log_t *log, struct kevent *kev)
  678. {
  679.     if (kev->ident > 0x8000000 && kev->ident != (unsigned) -1) {
  680.         ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,
  681.                        "kevent: %p: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p",
  682.                        (void *) kev->ident, kev->filter,
  683.                        kev->flags, kev->fflags,
  684.                        (int) kev->data, kev->udata);

  686.     } else {
  687.         ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,
  688.                        "kevent: %d: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p",
  689.                        (int) kev->ident, kev->filter,
  690.                        kev->flags, kev->fflags,
  691.                        (int) kev->data, kev->udata);
  692.     }
  693. }


  696. static void *
  697. ‌ngx_kqueue_create_conf(ngx_cycle_t *cycle)
  698. {
  699.     ngx_kqueue_conf_t  *kcf;

  701.     kcf = ngx_palloc(cycle->pool, sizeof(ngx_kqueue_conf_t));
  702.     if (kcf == NULL) {
  703.         return NULL;
  704.     }

  706.     kcf->changes = NGX_CONF_UNSET;
  707.     kcf->events = NGX_CONF_UNSET;

  709.     return kcf;
  710. }


  713. static char *
  714. ‌ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf)
  715. {
  716.     ngx_kqueue_conf_t *kcf = conf;

  718.     ngx_conf_init_uint_value(kcf->changes, 512);
  719.     ngx_conf_init_uint_value(kcf->events, 512);

  721.     return NGX_CONF_OK;
  722. }

One Level Up Top Level