One Level Up Top Level

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

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. #if (NGX_TEST_BUILD_RTSIG)

  15. #if (NGX_DARWIN)

  17. ‌#define SIGRTMIN       33
  18. ‌#define si_fd          __pad[0]

  20. #else

  22. #ifdef  SIGRTMIN
  23. ‌#define si_fd          _reason.__spare__.__spare2__[0]
  24. #else
  25. ‌#define SIGRTMIN       33
  26. ‌#define si_fd          __spare__[0]
  27. #endif

  29. #endif

  31. ‌#define F_SETSIG       10
  32. ‌#define KERN_RTSIGNR   30
  33. ‌#define KERN_RTSIGMAX  31

  35. int sigtimedwait(const sigset_t *set, siginfo_t *info,
  36.                  const struct timespec *timeout);

  38. ‌int sigtimedwait(const sigset_t *set, siginfo_t *info,
  39.                  const struct timespec *timeout)
  40. {
  41.     return -1;
  42. }

  44. ‌int ngx_linux_rtsig_max;

  46. #endif


  49. typedef struct {
  50.     ngx_uint_t  signo;
  51.     ngx_uint_t  overflow_events;
  52.     ngx_uint_t  overflow_test;
  53.     ngx_uint_t  overflow_threshold;
  54. ‌} ngx_rtsig_conf_t;


  57. extern ngx_event_module_t  ngx_poll_module_ctx;

  59. static ngx_int_t ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer);
  60. static void ngx_rtsig_done(ngx_cycle_t *cycle);
  61. static ngx_int_t ngx_rtsig_add_connection(ngx_connection_t *c);
  62. static ngx_int_t ngx_rtsig_del_connection(ngx_connection_t *c,
  63.     ngx_uint_t flags);
  64. static ngx_int_t ngx_rtsig_process_events(ngx_cycle_t *cycle,
  65.     ngx_msec_t timer, ngx_uint_t flags);
  66. static ngx_int_t ngx_rtsig_process_overflow(ngx_cycle_t *cycle,
  67.     ngx_msec_t timer, ngx_uint_t flags);

  69. static void *ngx_rtsig_create_conf(ngx_cycle_t *cycle);
  70. static char *ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf);
  71. static char *ngx_check_ngx_overflow_threshold_bounds(ngx_conf_t *cf,
  72.     void *post, void *data);


  75. ‌static sigset_t        set;
  76. ‌‌static ngx_uint_t      overflow, overflow_current;
  77. ‌static struct pollfd  *overflow_list;


  80. ‌static ngx_str_t      rtsig_name = ngx_string("rtsig");

  82. ‌static ngx_conf_num_bounds_t  ngx_overflow_threshold_bounds = {
  83.     ngx_check_ngx_overflow_threshold_bounds, 2, 10
  84. };


  87. ‌static ngx_command_t  ngx_rtsig_commands[] = {

  89.     { ngx_string("rtsig_signo"),
  90.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  91.       ngx_conf_set_num_slot,
  92.       0,
  93.       offsetof(ngx_rtsig_conf_t, signo),
  94.       NULL },

  96.     { ngx_string("rtsig_overflow_events"),
  97.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  98.       ngx_conf_set_num_slot,
  99.       0,
  100.       offsetof(ngx_rtsig_conf_t, overflow_events),
  101.       NULL },

  103.     { ngx_string("rtsig_overflow_test"),
  104.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  105.       ngx_conf_set_num_slot,
  106.       0,
  107.       offsetof(ngx_rtsig_conf_t, overflow_test),
  108.       NULL },

  110.     { ngx_string("rtsig_overflow_threshold"),
  111.       NGX_EVENT_CONF|NGX_CONF_TAKE1,
  112.       ngx_conf_set_num_slot,
  113.       0,
  114.       offsetof(ngx_rtsig_conf_t, overflow_threshold),
  115.       &ngx_overflow_threshold_bounds },

  117.       ngx_null_command
  118. };


  121. ‌ngx_event_module_t  ngx_rtsig_module_ctx = {
  122.     &rtsig_name,
  123.     ngx_rtsig_create_conf,               /* create configuration */
  124.     ngx_rtsig_init_conf,                 /* init configuration */

  126.     {
  127.         NULL,                            /* add an event */
  128.         NULL,                            /* delete an event */
  129.         NULL,                            /* enable an event */
  130.         NULL,                            /* disable an event */
  131.         ngx_rtsig_add_connection,        /* add an connection */
  132.         ngx_rtsig_del_connection,        /* delete an connection */
  133.         NULL,                            /* process the changes */
  134.         ngx_rtsig_process_events,        /* process the events */
  135.         ngx_rtsig_init,                  /* init the events */
  136.         ngx_rtsig_done,                  /* done the events */
  137.     }

  139. };

  141. ‌ngx_module_t  ngx_rtsig_module = {
  142.     NGX_MODULE_V1,
  143.     &ngx_rtsig_module_ctx,               /* module context */
  144.     ngx_rtsig_commands,                  /* module directives */
  145.     NGX_EVENT_MODULE,                    /* module type */
  146.     NULL,                                /* init master */
  147.     NULL,                                /* init module */
  148.     NULL,                                /* init process */
  149.     NULL,                                /* init thread */
  150.     NULL,                                /* exit thread */
  151.     NULL,                                /* exit process */
  152.     NULL,                                /* exit master */
  153.     NGX_MODULE_V1_PADDING
  154. };


  157. static ngx_int_t
  158. ‌ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer)
  159. {
  160.     ngx_rtsig_conf_t  *rtscf;

  162.     rtscf = ngx_event_get_conf(cycle->conf_ctx, ngx_rtsig_module);

  164.     sigemptyset(&set);
  165.     sigaddset(&set, (int) rtscf->signo);
  166.     sigaddset(&set, (int) rtscf->signo + 1);
  167.     sigaddset(&set, SIGIO);
  168.     sigaddset(&set, SIGALRM);

  170.     if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
  171.         ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
  172.                       "sigprocmask() failed");
  173.         return NGX_ERROR;
  174.     }

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

  180.     overflow_list = ngx_alloc(sizeof(struct pollfd) * rtscf->overflow_events,
  181.                               cycle->log);
  182.     if (overflow_list == NULL) {
  183.         return NGX_ERROR;
  184.     }

  186.     ngx_io = ngx_os_io;

  188.     ngx_event_actions = ngx_rtsig_module_ctx.actions;

  190.     ngx_event_flags = NGX_USE_RTSIG_EVENT
  191.                       |NGX_USE_GREEDY_EVENT
  192.                       |NGX_USE_FD_EVENT;

  194.     return NGX_OK;
  195. }


  198. static void
  199. ‌ngx_rtsig_done(ngx_cycle_t *cycle)
  200. {
  201.     ngx_free(overflow_list);

  203.     overflow_list = NULL;
  204. }


  207. static ngx_int_t
  208. ‌ngx_rtsig_add_connection(ngx_connection_t *c)
  209. {
  210.     ngx_uint_t         signo;
  211.     ngx_rtsig_conf_t  *rtscf;

  213.     if (c->read->accept && c->read->disabled) {

  215.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  216.                        "rtsig enable connection: fd:%d", c->fd);

  218.         if (fcntl(c->fd, F_SETOWN, ngx_pid) == -1) {
  219.             ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
  220.                           "fcntl(F_SETOWN) failed");
  221.             return NGX_ERROR;
  222.         }

  224.         c->read->active = 1;
  225.         c->read->disabled = 0;
  226.     }

  228.     rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);

  230.     signo = rtscf->signo + c->read->instance;

  232.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  233.                    "rtsig add connection: fd:%d signo:%ui", c->fd, signo);

  235.     if (fcntl(c->fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC) == -1) {
  236.         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
  237.                       "fcntl(O_RDWR|O_NONBLOCK|O_ASYNC) failed");
  238.         return NGX_ERROR;
  239.     }

  241.     if (fcntl(c->fd, F_SETSIG, (int) signo) == -1) {
  242.         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
  243.                       "fcntl(F_SETSIG) failed");
  244.         return NGX_ERROR;
  245.     }

  247.     if (fcntl(c->fd, F_SETOWN, ngx_pid) == -1) {
  248.         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
  249.                       "fcntl(F_SETOWN) failed");
  250.         return NGX_ERROR;
  251.     }

  253. #if (NGX_HAVE_ONESIGFD)
  254.     if (fcntl(c->fd, F_SETAUXFL, O_ONESIGFD) == -1) {
  255.         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
  256.                       "fcntl(F_SETAUXFL) failed");
  257.         return NGX_ERROR;
  258.     }
  259. #endif

  261.     c->read->active = 1;
  262.     c->write->active = 1;

  264.     return NGX_OK;
  265. }


  268. static ngx_int_t
  269. ‌ngx_rtsig_del_connection(ngx_connection_t *c, ngx_uint_t flags)
  270. {
  271.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  272.                    "rtsig del connection: fd:%d", c->fd);

  274.     if ((flags & NGX_DISABLE_EVENT) && c->read->accept) {

  276.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  277.                        "rtsig disable connection: fd:%d", c->fd);

  279.         c->read->active = 0;
  280.         c->read->disabled = 1;
  281.         return NGX_OK;
  282.     }

  284.     if (flags & NGX_CLOSE_EVENT) {
  285.         c->read->active = 0;
  286.         c->write->active = 0;
  287.         return NGX_OK;
  288.     }

  290.     if (fcntl(c->fd, F_SETFL, O_RDWR|O_NONBLOCK) == -1) {
  291.         ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
  292.                       "fcntl(O_RDWR|O_NONBLOCK) failed");
  293.         return NGX_ERROR;
  294.     }

  296.     c->read->active = 0;
  297.     c->write->active = 0;

  299.     return NGX_OK;
  300. }


  303. static ngx_int_t
  304. ‌ngx_rtsig_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
  305. {
  306.     int                 signo;
  307.     ngx_int_t           instance;
  308.     ngx_err_t           err;
  309.     siginfo_t           si;
  310.     ngx_event_t        *rev, *wev;
  311.     ngx_queue_t        *queue;
  312.     struct timespec     ts, *tp;
  313.     struct sigaction    sa;
  314.     ngx_connection_t   *c;
  315.     ngx_rtsig_conf_t   *rtscf;

  317.     if (timer == NGX_TIMER_INFINITE) {
  318.         tp = NULL;

  320.     } else {
  321.         ts.tv_sec = timer / 1000;
  322.         ts.tv_nsec = (timer % 1000) * 1000000;
  323.         tp = &ts;
  324.     }

  326.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  327.                    "rtsig timer: %M", timer);

  329.     /* Linux's sigwaitinfo() is sigtimedwait() with the NULL timeout pointer */

  331.     signo = sigtimedwait(&set, &si, tp);

  333.     if (signo == -1) {
  334.         err = ngx_errno;

  336.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, err,
  337.                        "rtsig signo:%d", signo);

  339.         if (flags & NGX_UPDATE_TIME) {
  340.             ngx_time_update();
  341.         }

  343.         if (err == NGX_EAGAIN) {

  345.             /* timeout */

  347.             if (timer != NGX_TIMER_INFINITE) {
  348.                 return NGX_AGAIN;
  349.             }

  351.             ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
  352.                           "sigtimedwait() returned EAGAIN without timeout");
  353.             return NGX_ERROR;
  354.         }

  356.         ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
  357.                       cycle->log, err, "sigtimedwait() failed");
  358.         return NGX_ERROR;
  359.     }

  361.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  362.                    "rtsig signo:%d fd:%d band:%04Xd",
  363.                    signo, si.si_fd, si.si_band);

  365.     if (flags & NGX_UPDATE_TIME) {
  366.         ngx_time_update();
  367.     }

  369.     rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);

  371.     if (signo == (int) rtscf->signo || signo == (int) rtscf->signo + 1) {

  373.         if (overflow && (ngx_uint_t) si.si_fd > overflow_current) {
  374.             return NGX_OK;
  375.         }

  377.         c = ngx_cycle->files[si.si_fd];

  379.         if (c == NULL) {

  381.             /* the stale event */

  383.             return NGX_OK;
  384.         }

  386.         instance = signo - (int) rtscf->signo;

  388.         rev = c->read;

  390.         if (rev->instance != instance) {

  392.             /*
  393.              * the stale event from a file descriptor
  394.              * that was just closed in this iteration
  395.              */

  397.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  398.                            "rtsig: stale event %p", c);

  400.             return NGX_OK;
  401.         }

  403.         if ((si.si_band & (POLLIN|POLLHUP|POLLERR)) && rev->active) {

  405.             rev->ready = 1;

  407.             if (flags & NGX_POST_EVENTS) {
  408.                 queue = rev->accept ? &ngx_posted_accept_events
  409.                                     : &ngx_posted_events;

  411.                 ngx_post_event(rev, queue);

  413.             } else {
  414.                 rev->handler(rev);
  415.             }
  416.         }

  418.         wev = c->write;

  420.         if ((si.si_band & (POLLOUT|POLLHUP|POLLERR)) && wev->active) {

  422.             wev->ready = 1;

  424.             if (flags & NGX_POST_EVENTS) {
  425.                 ngx_post_event(wev, &ngx_posted_events);

  427.             } else {
  428.                 wev->handler(wev);
  429.             }
  430.         }

  432.         return NGX_OK;

  434.     } else if (signo == SIGALRM) {

  436.         ngx_time_update();

  438.         return NGX_OK;

  440.     } else if (signo == SIGIO) {

  442.         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  443.                       "rt signal queue overflowed");

  445.         /* flush the RT signal queue */

  447.         ngx_memzero(&sa, sizeof(struct sigaction));
  448.         sa.sa_handler = SIG_DFL;
  449.         sigemptyset(&sa.sa_mask);

  451.         if (sigaction(rtscf->signo, &sa, NULL) == -1) {
  452.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  453.                           "sigaction(%d, SIG_DFL) failed", rtscf->signo);
  454.         }

  456.         if (sigaction(rtscf->signo + 1, &sa, NULL) == -1) {
  457.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
  458.                           "sigaction(%d, SIG_DFL) failed", rtscf->signo + 1);
  459.         }

  461.         overflow = 1;
  462.         overflow_current = 0;
  463.         ngx_event_actions.process_events = ngx_rtsig_process_overflow;

  465.         return NGX_ERROR;

  467.     }

  469.     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  470.                   "sigtimedwait() returned unexpected signal: %d", signo);

  472.     return NGX_ERROR;
  473. }


  476. static ngx_int_t
  477. ‌ngx_rtsig_process_overflow(ngx_cycle_t *cycle, ngx_msec_t timer,
  478.     ngx_uint_t flags)
  479. {
  480.     int                name[2], rtsig_max, rtsig_nr, events, ready;
  481.     size_t             len;
  482.     ngx_err_t          err;
  483.     ngx_uint_t         tested, n, i;
  484.     ngx_event_t       *rev, *wev;
  485.     ngx_queue_t       *queue;
  486.     ngx_connection_t  *c;
  487.     ngx_rtsig_conf_t  *rtscf;

  489.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  490.                    "rtsig process overflow");

  492.     rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);

  494.     tested = 0;

  496.     for ( ;; ) {

  498.         n = 0;
  499.         while (n < rtscf->overflow_events) {

  501.             if (overflow_current == cycle->connection_n) {
  502.                 break;
  503.             }

  505.             c = cycle->files[overflow_current++];

  507.             if (c == NULL || c->fd == -1) {
  508.                 continue;
  509.             }

  511.             events = 0;

  513.             if (c->read->active && c->read->handler) {
  514.                 events |= POLLIN;
  515.             }

  517.             if (c->write->active && c->write->handler) {
  518.                 events |= POLLOUT;
  519.             }

  521.             if (events == 0) {
  522.                 continue;
  523.             }

  525.             overflow_list[n].fd = c->fd;
  526.             overflow_list[n].events = events;
  527.             overflow_list[n].revents = 0;
  528.             n++;
  529.         }

  531.         if (n == 0) {
  532.             break;
  533.         }

  535.         for ( ;; ) {
  536.             ready = poll(overflow_list, n, 0);

  538.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  539.                            "rtsig overflow poll:%d", ready);

  541.             if (ready == -1) {
  542.                 err = ngx_errno;
  543.                 ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
  544.                               cycle->log, 0,
  545.                               "poll() failed while the overflow recover");

  547.                 if (err == NGX_EINTR) {
  548.                     continue;
  549.                 }
  550.             }

  552.             break;
  553.         }

  555.         if (ready <= 0) {
  556.             continue;
  557.         }

  559.         for (i = 0; i < n; i++) {
  560.             c = cycle->files[overflow_list[i].fd];

  562.             if (c == NULL) {
  563.                 continue;
  564.             }

  566.             rev = c->read;

  568.             if (rev->active
  569.                 && !rev->closed
  570.                 && rev->handler
  571.                 && (overflow_list[i].revents
  572.                                           & (POLLIN|POLLERR|POLLHUP|POLLNVAL)))
  573.             {
  574.                 tested++;

  576.                 rev->ready = 1;

  578.                 if (flags & NGX_POST_EVENTS) {
  579.                     queue = rev->accept ? &ngx_posted_accept_events
  580.                                         : &ngx_posted_events;

  582.                     ngx_post_event(rev, queue);

  584.                 } else {
  585.                     rev->handler(rev);
  586.                 }
  587.             }

  589.             wev = c->write;

  591.             if (wev->active
  592.                 && !wev->closed
  593.                 && wev->handler
  594.                 && (overflow_list[i].revents
  595.                                          & (POLLOUT|POLLERR|POLLHUP|POLLNVAL)))
  596.             {
  597.                 tested++;

  599.                 wev->ready = 1;

  601.                 if (flags & NGX_POST_EVENTS) {
  602.                     ngx_post_event(wev, &ngx_posted_events);

  604.                 } else {
  605.                     wev->handler(wev);
  606.                 }
  607.             }
  608.         }

  610.         if (tested >= rtscf->overflow_test) {

  612.             if (ngx_linux_rtsig_max) {

  614.                 /*
  615.                  * Check the current rt queue length to prevent
  616.                  * the new overflow.
  617.                  *
  618.                  * learn the "/proc/sys/kernel/rtsig-max" value because
  619.                  * it can be changed since the last checking
  620.                  */

  622.                 name[0] = CTL_KERN;
  623.                 name[1] = KERN_RTSIGMAX;
  624.                 len = sizeof(rtsig_max);

  626.                 if (sysctl(name, 2, &rtsig_max, &len, NULL, 0) == -1) {
  627.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, errno,
  628.                                   "sysctl(KERN_RTSIGMAX) failed");
  629.                     return NGX_ERROR;
  630.                 }

  632.                 /* name[0] = CTL_KERN; */
  633.                 name[1] = KERN_RTSIGNR;
  634.                 len = sizeof(rtsig_nr);

  636.                 if (sysctl(name, 2, &rtsig_nr, &len, NULL, 0) == -1) {
  637.                     ngx_log_error(NGX_LOG_ALERT, cycle->log, errno,
  638.                                   "sysctl(KERN_RTSIGNR) failed");
  639.                     return NGX_ERROR;
  640.                 }

  642.                 /*
  643.                  * drain the rt signal queue if the /"proc/sys/kernel/rtsig-nr"
  644.                  * is bigger than
  645.                  *    "/proc/sys/kernel/rtsig-max" / "rtsig_overflow_threshold"
  646.                  */

  648.                 if (rtsig_max / (int) rtscf->overflow_threshold < rtsig_nr) {
  649.                     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
  650.                                    "rtsig queue state: %d/%d",
  651.                                    rtsig_nr, rtsig_max);
  652.                     while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK)
  653.                     {
  654.                         /* void */
  655.                     }
  656.                 }

  658.             } else {

  660.                 /*
  661.                  * Linux has not KERN_RTSIGMAX since 2.6.6-mm2
  662.                  * so drain the rt signal queue unconditionally
  663.                  */

  665.                 while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK) {
  666.                     /* void */
  667.                 }
  668.             }

  670.             tested = 0;
  671.         }
  672.     }

  674.     if (flags & NGX_UPDATE_TIME) {
  675.         ngx_time_update();
  676.     }

  678.     ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  679.                   "rt signal queue overflow recovered");

  681.     overflow = 0;
  682.     ngx_event_actions.process_events = ngx_rtsig_process_events;

  684.     return NGX_OK;
  685. }


  688. static void *
  689. ‌ngx_rtsig_create_conf(ngx_cycle_t *cycle)
  690. {
  691.     ngx_rtsig_conf_t  *rtscf;

  693.     rtscf = ngx_palloc(cycle->pool, sizeof(ngx_rtsig_conf_t));
  694.     if (rtscf == NULL) {
  695.         return NULL;
  696.     }

  698.     rtscf->signo = NGX_CONF_UNSET;
  699.     rtscf->overflow_events = NGX_CONF_UNSET;
  700.     rtscf->overflow_test = NGX_CONF_UNSET;
  701.     rtscf->overflow_threshold = NGX_CONF_UNSET;

  703.     return rtscf;
  704. }


  707. static char *
  708. ‌ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf)
  709. {
  710.     ngx_rtsig_conf_t  *rtscf = conf;

  712.     /* LinuxThreads use the first 3 RT signals */
  713.     ngx_conf_init_uint_value(rtscf->signo, SIGRTMIN + 10);

  715.     ngx_conf_init_uint_value(rtscf->overflow_events, 16);
  716.     ngx_conf_init_uint_value(rtscf->overflow_test, 32);
  717.     ngx_conf_init_uint_value(rtscf->overflow_threshold, 10);

  719.     return NGX_CONF_OK;
  720. }


  723. static char *
  724. ‌ngx_check_ngx_overflow_threshold_bounds(ngx_conf_t *cf, void *post, void *data)
  725. {
  726.     if (ngx_linux_rtsig_max) {
  727.         return ngx_conf_check_num_bounds(cf, post, data);
  728.     }

  730.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  731.                        "\"rtsig_overflow_threshold\" is not supported "
  732.                        "since Linux 2.6.6-mm2, ignored");

  734.     return NGX_CONF_OK;
  735. }

One Level Up Top Level