Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ngx_rtsig_module.c
Go to the documentation of this file.
1 
2 /*
3  * Copyright (C) Igor Sysoev
4  * Copyright (C) Nginx, Inc.
5  */
6 
7 
8 #include <ngx_config.h>
9 #include <ngx_core.h>
10 #include <ngx_event.h>
11 
12 
13 #if (NGX_TEST_BUILD_RTSIG)
14 
15 #if (NGX_DARWIN)
16 
17 #define SIGRTMIN 33
18 #define si_fd __pad[0]
19 
20 #else
21 
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
28 
29 #endif
30 
31 #define F_SETSIG 10
32 #define KERN_RTSIGNR 30
33 #define KERN_RTSIGMAX 31
34 
35 int sigtimedwait(const sigset_t *set, siginfo_t *info,
36  const struct timespec *timeout);
37 
38 int sigtimedwait(const sigset_t *set, siginfo_t *info,
39  const struct timespec *timeout)
40 {
41  return -1;
42 }
43 
44 int ngx_linux_rtsig_max;
45 
46 #endif
47 
48 
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;
55 
56 
57 extern ngx_event_module_t ngx_poll_module_ctx;
58 
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);
68 
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);
73 
74 
75 static sigset_t set;
76 static ngx_uint_t overflow, overflow_current;
77 static struct pollfd *overflow_list;
78 
79 
80 static ngx_str_t rtsig_name = ngx_string("rtsig");
81 
82 static ngx_conf_num_bounds_t ngx_overflow_threshold_bounds = {
83  ngx_check_ngx_overflow_threshold_bounds, 2, 10
84 };
85 
86 
87 static ngx_command_t ngx_rtsig_commands[] = {
88 
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 },
95 
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 },
102 
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 },
109 
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 },
116 
117  ngx_null_command
118 };
119 
120 
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 */
125 
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  }
138 
139 };
140 
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 };
155 
156 
157 static ngx_int_t
158 ngx_rtsig_init(ngx_cycle_t *cycle, ngx_msec_t timer)
159 {
160  ngx_rtsig_conf_t *rtscf;
161 
162  rtscf = ngx_event_get_conf(cycle->conf_ctx, ngx_rtsig_module);
163 
164  sigemptyset(&set);
165  sigaddset(&set, (int) rtscf->signo);
166  sigaddset(&set, (int) rtscf->signo + 1);
167  sigaddset(&set, SIGIO);
168  sigaddset(&set, SIGALRM);
169 
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  }
175 
176  if (overflow_list) {
177  ngx_free(overflow_list);
178  }
179 
180  overflow_list = ngx_alloc(sizeof(struct pollfd) * rtscf->overflow_events,
181  cycle->log);
182  if (overflow_list == NULL) {
183  return NGX_ERROR;
184  }
185 
186  ngx_io = ngx_os_io;
187 
188  ngx_event_actions = ngx_rtsig_module_ctx.actions;
189 
190  ngx_event_flags = NGX_USE_RTSIG_EVENT
191  |NGX_USE_GREEDY_EVENT
192  |NGX_USE_FD_EVENT;
193 
194  return NGX_OK;
195 }
196 
197 
198 static void
199 ngx_rtsig_done(ngx_cycle_t *cycle)
200 {
201  ngx_free(overflow_list);
202 
203  overflow_list = NULL;
204 }
205 
206 
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;
212 
213  if (c->read->accept && c->read->disabled) {
214 
215  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
216  "rtsig enable connection: fd:%d", c->fd);
217 
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  }
223 
224  c->read->active = 1;
225  c->read->disabled = 0;
226  }
227 
228  rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
229 
230  signo = rtscf->signo + c->read->instance;
231 
232  ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
233  "rtsig add connection: fd:%d signo:%ui", c->fd, signo);
234 
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  }
240 
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  }
246 
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  }
252 
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
260 
261  c->read->active = 1;
262  c->write->active = 1;
263 
264  return NGX_OK;
265 }
266 
267 
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);
273 
274  if ((flags & NGX_DISABLE_EVENT) && c->read->accept) {
275 
276  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
277  "rtsig disable connection: fd:%d", c->fd);
278 
279  c->read->active = 0;
280  c->read->disabled = 1;
281  return NGX_OK;
282  }
283 
284  if (flags & NGX_CLOSE_EVENT) {
285  c->read->active = 0;
286  c->write->active = 0;
287  return NGX_OK;
288  }
289 
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  }
295 
296  c->read->active = 0;
297  c->write->active = 0;
298 
299  return NGX_OK;
300 }
301 
302 
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, **queue;
311  struct timespec ts, *tp;
312  struct sigaction sa;
313  ngx_connection_t *c;
314  ngx_rtsig_conf_t *rtscf;
315 
316  if (timer == NGX_TIMER_INFINITE) {
317  tp = NULL;
318 
319  } else {
320  ts.tv_sec = timer / 1000;
321  ts.tv_nsec = (timer % 1000) * 1000000;
322  tp = &ts;
323  }
324 
325  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
326  "rtsig timer: %M", timer);
327 
328  /* Linux's sigwaitinfo() is sigtimedwait() with the NULL timeout pointer */
329 
330  signo = sigtimedwait(&set, &si, tp);
331 
332  if (signo == -1) {
333  err = ngx_errno;
334 
335  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, err,
336  "rtsig signo:%d", signo);
337 
338  if (flags & NGX_UPDATE_TIME) {
339  ngx_time_update();
340  }
341 
342  if (err == NGX_EAGAIN) {
343 
344  /* timeout */
345 
346  if (timer != NGX_TIMER_INFINITE) {
347  return NGX_AGAIN;
348  }
349 
350  ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
351  "sigtimedwait() returned EAGAIN without timeout");
352  return NGX_ERROR;
353  }
354 
355  ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
356  cycle->log, err, "sigtimedwait() failed");
357  return NGX_ERROR;
358  }
359 
360  ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
361  "rtsig signo:%d fd:%d band:%04Xd",
362  signo, si.si_fd, si.si_band);
363 
364  if (flags & NGX_UPDATE_TIME) {
365  ngx_time_update();
366  }
367 
368  rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
369 
370  if (signo == (int) rtscf->signo || signo == (int) rtscf->signo + 1) {
371 
372  if (overflow && (ngx_uint_t) si.si_fd > overflow_current) {
373  return NGX_OK;
374  }
375 
376  c = ngx_cycle->files[si.si_fd];
377 
378  if (c == NULL) {
379 
380  /* the stale event */
381 
382  return NGX_OK;
383  }
384 
385  instance = signo - (int) rtscf->signo;
386 
387  rev = c->read;
388 
389  if (rev->instance != instance) {
390 
391  /*
392  * the stale event from a file descriptor
393  * that was just closed in this iteration
394  */
395 
396  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
397  "rtsig: stale event %p", c);
398 
399  return NGX_OK;
400  }
401 
402  if ((si.si_band & (POLLIN|POLLHUP|POLLERR)) && rev->active) {
403 
404  rev->ready = 1;
405 
406  if (flags & NGX_POST_EVENTS) {
407  queue = (ngx_event_t **) (rev->accept ?
408  &ngx_posted_accept_events : &ngx_posted_events);
409 
410  ngx_locked_post_event(rev, queue);
411 
412  } else {
413  rev->handler(rev);
414  }
415  }
416 
417  wev = c->write;
418 
419  if ((si.si_band & (POLLOUT|POLLHUP|POLLERR)) && wev->active) {
420 
421  wev->ready = 1;
422 
423  if (flags & NGX_POST_EVENTS) {
424  ngx_locked_post_event(wev, &ngx_posted_events);
425 
426  } else {
427  wev->handler(wev);
428  }
429  }
430 
431  return NGX_OK;
432 
433  } else if (signo == SIGALRM) {
434 
435  ngx_time_update();
436 
437  return NGX_OK;
438 
439  } else if (signo == SIGIO) {
440 
441  ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
442  "rt signal queue overflowed");
443 
444  /* flush the RT signal queue */
445 
446  ngx_memzero(&sa, sizeof(struct sigaction));
447  sa.sa_handler = SIG_DFL;
448  sigemptyset(&sa.sa_mask);
449 
450  if (sigaction(rtscf->signo, &sa, NULL) == -1) {
451  ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
452  "sigaction(%d, SIG_DFL) failed", rtscf->signo);
453  }
454 
455  if (sigaction(rtscf->signo + 1, &sa, NULL) == -1) {
456  ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
457  "sigaction(%d, SIG_DFL) failed", rtscf->signo + 1);
458  }
459 
460  overflow = 1;
461  overflow_current = 0;
462  ngx_event_actions.process_events = ngx_rtsig_process_overflow;
463 
464  return NGX_ERROR;
465 
466  }
467 
468  ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
469  "sigtimedwait() returned unexpected signal: %d", signo);
470 
471  return NGX_ERROR;
472 }
473 
474 
475 static ngx_int_t
476 ngx_rtsig_process_overflow(ngx_cycle_t *cycle, ngx_msec_t timer,
477  ngx_uint_t flags)
478 {
479  int name[2], rtsig_max, rtsig_nr, events, ready;
480  size_t len;
481  ngx_err_t err;
482  ngx_uint_t tested, n, i;
483  ngx_event_t *rev, *wev, **queue;
484  ngx_connection_t *c;
485  ngx_rtsig_conf_t *rtscf;
486 
487  ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
488  "rtsig process overflow");
489 
490  rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
491 
492  tested = 0;
493 
494  for ( ;; ) {
495 
496  n = 0;
497  while (n < rtscf->overflow_events) {
498 
499  if (overflow_current == cycle->connection_n) {
500  break;
501  }
502 
503  c = cycle->files[overflow_current++];
504 
505  if (c == NULL || c->fd == -1) {
506  continue;
507  }
508 
509  events = 0;
510 
511  if (c->read->active && c->read->handler) {
512  events |= POLLIN;
513  }
514 
515  if (c->write->active && c->write->handler) {
516  events |= POLLOUT;
517  }
518 
519  if (events == 0) {
520  continue;
521  }
522 
523  overflow_list[n].fd = c->fd;
524  overflow_list[n].events = events;
525  overflow_list[n].revents = 0;
526  n++;
527  }
528 
529  if (n == 0) {
530  break;
531  }
532 
533  for ( ;; ) {
534  ready = poll(overflow_list, n, 0);
535 
536  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
537  "rtsig overflow poll:%d", ready);
538 
539  if (ready == -1) {
540  err = ngx_errno;
541  ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
542  cycle->log, 0,
543  "poll() failed while the overflow recover");
544 
545  if (err == NGX_EINTR) {
546  continue;
547  }
548  }
549 
550  break;
551  }
552 
553  if (ready <= 0) {
554  continue;
555  }
556 
557  ngx_mutex_lock(ngx_posted_events_mutex);
558 
559  for (i = 0; i < n; i++) {
560  c = cycle->files[overflow_list[i].fd];
561 
562  if (c == NULL) {
563  continue;
564  }
565 
566  rev = c->read;
567 
568  if (rev->active
569  && !rev->closed
570  && rev->handler
571  && (overflow_list[i].revents
572  & (POLLIN|POLLERR|POLLHUP|POLLNVAL)))
573  {
574  tested++;
575 
576  if ((flags & NGX_POST_THREAD_EVENTS) && !rev->accept) {
577  rev->posted_ready = 1;
578 
579  } else {
580  rev->ready = 1;
581  }
582 
583  if (flags & NGX_POST_EVENTS) {
584  queue = (ngx_event_t **) (rev->accept ?
585  &ngx_posted_accept_events : &ngx_posted_events);
586 
587  ngx_locked_post_event(rev, queue);
588 
589  } else {
590  rev->handler(rev);
591  }
592  }
593 
594  wev = c->write;
595 
596  if (wev->active
597  && !wev->closed
598  && wev->handler
599  && (overflow_list[i].revents
600  & (POLLOUT|POLLERR|POLLHUP|POLLNVAL)))
601  {
602  tested++;
603 
604  if (flags & NGX_POST_THREAD_EVENTS) {
605  wev->posted_ready = 1;
606 
607  } else {
608  wev->ready = 1;
609  }
610 
611  if (flags & NGX_POST_EVENTS) {
612  ngx_locked_post_event(wev, &ngx_posted_events);
613 
614  } else {
615  wev->handler(wev);
616  }
617  }
618  }
619 
620  ngx_mutex_unlock(ngx_posted_events_mutex);
621 
622  if (tested >= rtscf->overflow_test) {
623 
624  if (ngx_linux_rtsig_max) {
625 
626  /*
627  * Check the current rt queue length to prevent
628  * the new overflow.
629  *
630  * learn the "/proc/sys/kernel/rtsig-max" value because
631  * it can be changed since the last checking
632  */
633 
634  name[0] = CTL_KERN;
635  name[1] = KERN_RTSIGMAX;
636  len = sizeof(rtsig_max);
637 
638  if (sysctl(name, 2, &rtsig_max, &len, NULL, 0) == -1) {
639  ngx_log_error(NGX_LOG_ALERT, cycle->log, errno,
640  "sysctl(KERN_RTSIGMAX) failed");
641  return NGX_ERROR;
642  }
643 
644  /* name[0] = CTL_KERN; */
645  name[1] = KERN_RTSIGNR;
646  len = sizeof(rtsig_nr);
647 
648  if (sysctl(name, 2, &rtsig_nr, &len, NULL, 0) == -1) {
649  ngx_log_error(NGX_LOG_ALERT, cycle->log, errno,
650  "sysctl(KERN_RTSIGNR) failed");
651  return NGX_ERROR;
652  }
653 
654  /*
655  * drain the rt signal queue if the /"proc/sys/kernel/rtsig-nr"
656  * is bigger than
657  * "/proc/sys/kernel/rtsig-max" / "rtsig_overflow_threshold"
658  */
659 
660  if (rtsig_max / (int) rtscf->overflow_threshold < rtsig_nr) {
661  ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
662  "rtsig queue state: %d/%d",
663  rtsig_nr, rtsig_max);
664  while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK)
665  {
666  /* void */
667  }
668  }
669 
670  } else {
671 
672  /*
673  * Linux has not KERN_RTSIGMAX since 2.6.6-mm2
674  * so drain the rt signal queue unconditionally
675  */
676 
677  while (ngx_rtsig_process_events(cycle, 0, flags) == NGX_OK) {
678  /* void */
679  }
680  }
681 
682  tested = 0;
683  }
684  }
685 
686  if (flags & NGX_UPDATE_TIME) {
687  ngx_time_update();
688  }
689 
690  ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
691  "rt signal queue overflow recovered");
692 
693  overflow = 0;
694  ngx_event_actions.process_events = ngx_rtsig_process_events;
695 
696  return NGX_OK;
697 }
698 
699 
700 static void *
701 ngx_rtsig_create_conf(ngx_cycle_t *cycle)
702 {
703  ngx_rtsig_conf_t *rtscf;
704 
705  rtscf = ngx_palloc(cycle->pool, sizeof(ngx_rtsig_conf_t));
706  if (rtscf == NULL) {
707  return NULL;
708  }
709 
710  rtscf->signo = NGX_CONF_UNSET;
711  rtscf->overflow_events = NGX_CONF_UNSET;
712  rtscf->overflow_test = NGX_CONF_UNSET;
713  rtscf->overflow_threshold = NGX_CONF_UNSET;
714 
715  return rtscf;
716 }
717 
718 
719 static char *
720 ngx_rtsig_init_conf(ngx_cycle_t *cycle, void *conf)
721 {
722  ngx_rtsig_conf_t *rtscf = conf;
723 
724  /* LinuxThreads use the first 3 RT signals */
725  ngx_conf_init_uint_value(rtscf->signo, SIGRTMIN + 10);
726 
727  ngx_conf_init_uint_value(rtscf->overflow_events, 16);
728  ngx_conf_init_uint_value(rtscf->overflow_test, 32);
729  ngx_conf_init_uint_value(rtscf->overflow_threshold, 10);
730 
731  return NGX_CONF_OK;
732 }
733 
734 
735 static char *
736 ngx_check_ngx_overflow_threshold_bounds(ngx_conf_t *cf, void *post, void *data)
737 {
738  if (ngx_linux_rtsig_max) {
739  return ngx_conf_check_num_bounds(cf, post, data);
740  }
741 
742  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
743  "\"rtsig_overflow_threshold\" is not supported "
744  "since Linux 2.6.6-mm2, ignored");
745 
746  return NGX_CONF_OK;
747 }
Generated on Sun Nov 10 2013 09:49:07 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2