Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ngx_kqueue_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 typedef struct {
14  ngx_uint_t changes;
15  ngx_uint_t events;
16 } ngx_kqueue_conf_t;
17 
18 
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);
32 
33 static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle);
34 static char *ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf);
35 
36 
37 int ngx_kqueue = -1;
38 
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  */
46 
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;
50 
51 #if (NGX_THREADS)
52 static ngx_mutex_t *list_mutex;
53 static ngx_mutex_t *kevent_mutex;
54 #endif
55 
56 
57 
58 static ngx_str_t kqueue_name = ngx_string("kqueue");
59 
60 static ngx_command_t ngx_kqueue_commands[] = {
61 
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 },
68 
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 },
75 
76  ngx_null_command
77 };
78 
79 
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 */
84 
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  }
97 
98 };
99 
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 };
114 
115 
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
124 
125  kcf = ngx_event_get_conf(cycle->conf_ctx, ngx_kqueue_module);
126 
127  if (ngx_kqueue == -1) {
128  ngx_kqueue = kqueue();
129 
130  if (ngx_kqueue == -1) {
131  ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
132  "kqueue() failed");
133  return NGX_ERROR;
134  }
135 
136 #if (NGX_THREADS)
137 
138  list_mutex = ngx_mutex_init(cycle->log, 0);
139  if (list_mutex == NULL) {
140  return NGX_ERROR;
141  }
142 
143  kevent_mutex = ngx_mutex_init(cycle->log, 0);
144  if (kevent_mutex == NULL) {
145  return NGX_ERROR;
146  }
147 
148 #endif
149  }
150 
151  if (max_changes < kcf->changes) {
152  if (nchanges) {
153  ts.tv_sec = 0;
154  ts.tv_nsec = 0;
155 
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  }
165 
166  if (change_list0) {
167  ngx_free(change_list0);
168  }
169 
170  change_list0 = ngx_alloc(kcf->changes * sizeof(struct kevent),
171  cycle->log);
172  if (change_list0 == NULL) {
173  return NGX_ERROR;
174  }
175 
176  if (change_list1) {
177  ngx_free(change_list1);
178  }
179 
180  change_list1 = ngx_alloc(kcf->changes * sizeof(struct kevent),
181  cycle->log);
182  if (change_list1 == NULL) {
183  return NGX_ERROR;
184  }
185 
186  change_list = change_list0;
187  }
188 
189  max_changes = kcf->changes;
190 
191  if (nevents < kcf->events) {
192  if (event_list) {
193  ngx_free(event_list);
194  }
195 
196  event_list = ngx_alloc(kcf->events * sizeof(struct kevent), cycle->log);
197  if (event_list == NULL) {
198  return NGX_ERROR;
199  }
200  }
201 
202  ngx_event_flags = NGX_USE_ONESHOT_EVENT
203  |NGX_USE_KQUEUE_EVENT
204  |NGX_USE_VNODE_EVENT;
205 
206 #if (NGX_HAVE_TIMER_EVENT)
207 
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;
215 
216  ts.tv_sec = 0;
217  ts.tv_nsec = 0;
218 
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  }
224 
225  ngx_event_flags |= NGX_USE_TIMER_EVENT;
226  }
227 
228 #endif
229 
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
235 
236 #if (NGX_HAVE_LOWAT_EVENT)
237  ngx_event_flags |= NGX_USE_LOWAT_EVENT;
238 #endif
239 
240  nevents = kcf->events;
241 
242  ngx_io = ngx_os_io;
243 
244  ngx_event_actions = ngx_kqueue_module_ctx.actions;
245 
246  return NGX_OK;
247 }
248 
249 
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  }
257 
258  ngx_kqueue = -1;
259 
260 #if (NGX_THREADS)
261  ngx_mutex_destroy(kevent_mutex);
262  ngx_mutex_destroy(list_mutex);
263 #endif
264 
265  ngx_free(change_list1);
266  ngx_free(change_list0);
267  ngx_free(event_list);
268 
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 }
277 
278 
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
287 
288  ev->active = 1;
289  ev->disabled = 0;
290  ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;
291 
292  ngx_mutex_lock(list_mutex);
293 
294 #if 0
295 
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) {
301 
302  /*
303  * if the EV_DISABLE is still not passed to a kernel
304  * we will not pass it
305  */
306 
307  ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
308  "kevent activated: %d: ft:%i",
309  ngx_event_ident(ev->data), event);
310 
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  }
317 
318  ngx_mutex_unlock(list_mutex);
319 
320  return NGX_OK;
321  }
322 
323  c = ev->data;
324 
325  ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
326  "previous event on #%d were not passed in kernel", c->fd);
327 
328  ngx_mutex_unlock(list_mutex);
329 
330  return NGX_ERROR;
331  }
332 
333 #endif
334 
335  rc = ngx_kqueue_set_event(ev, event, EV_ADD|EV_ENABLE|flags);
336 
337  ngx_mutex_unlock(list_mutex);
338 
339  return rc;
340 }
341 
342 
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;
348 
349  ev->active = 0;
350  ev->disabled = 0;
351 
352  ngx_mutex_lock(list_mutex);
353 
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);
361 
362  /* if the event is still not passed to a kernel we will not pass it */
363 
364  nchanges--;
365 
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  }
372 
373  ngx_mutex_unlock(list_mutex);
374 
375  return NGX_OK;
376  }
377 
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  */
383 
384  if (flags & NGX_CLOSE_EVENT) {
385  ngx_mutex_unlock(list_mutex);
386  return NGX_OK;
387  }
388 
389  if (flags & NGX_DISABLE_EVENT) {
390  ev->disabled = 1;
391 
392  } else {
393  flags |= EV_DELETE;
394  }
395 
396  rc = ngx_kqueue_set_event(ev, event, flags);
397 
398  ngx_mutex_unlock(list_mutex);
399 
400  return rc;
401 }
402 
403 
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;
410 
411  c = ev->data;
412 
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);
416 
417  if (nchanges >= max_changes) {
418  ngx_log_error(NGX_LOG_WARN, ev->log, 0,
419  "kqueue change list is filled up");
420 
421  ts.tv_sec = 0;
422  ts.tv_nsec = 0;
423 
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  }
430 
431  nchanges = 0;
432  }
433 
434  kev = &change_list[nchanges];
435 
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);
440 
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;
450 
451  } else {
452 #if (NGX_HAVE_LOWAT_EVENT)
453  if (flags & NGX_LOWAT_EVENT) {
454  kev->fflags = NOTE_LOWAT;
455  kev->data = ev->available;
456 
457  } else {
458  kev->fflags = 0;
459  kev->data = 0;
460  }
461 #else
462  kev->fflags = 0;
463  kev->data = 0;
464 #endif
465  }
466 
467  ev->index = nchanges;
468  nchanges++;
469 
470  if (flags & NGX_FLUSH_EVENT) {
471  ts.tv_sec = 0;
472  ts.tv_nsec = 0;
473 
474  ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "kevent flush");
475 
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  }
482 
483  nchanges = 0;
484  }
485 
486  return NGX_OK;
487 }
488 
489 
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, **queue;
499  struct timespec ts, *tp;
500 
501  if (ngx_threaded) {
502  if (ngx_kqueue_process_changes(cycle, 0) == NGX_ERROR) {
503  return NGX_ERROR;
504  }
505 
506  n = 0;
507 
508  } else {
509  n = (int) nchanges;
510  nchanges = 0;
511  }
512 
513  if (timer == NGX_TIMER_INFINITE) {
514  tp = NULL;
515 
516  } else {
517 
518  ts.tv_sec = timer / 1000;
519  ts.tv_nsec = (timer % 1000) * 1000000;
520 
521  /*
522  * 64-bit Darwin kernel has the bug: kernel level ts.tv_nsec is
523  * the int32_t while user level ts.tv_nsec is the long (64-bit),
524  * so on the big endian PowerPC all nanoseconds are lost.
525  */
526 
527 #if (NGX_DARWIN_KEVENT_BUG)
528  ts.tv_nsec <<= 32;
529 #endif
530 
531  tp = &ts;
532  }
533 
534  ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
535  "kevent timer: %M, changes: %d", timer, n);
536 
537  events = kevent(ngx_kqueue, change_list, n, event_list, (int) nevents, tp);
538 
539  err = (events == -1) ? ngx_errno : 0;
540 
541  if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
542  ngx_time_update();
543  }
544 
545  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
546  "kevent events: %d", events);
547 
548  if (err) {
549  if (err == NGX_EINTR) {
550 
551  if (ngx_event_timer_alarm) {
552  ngx_event_timer_alarm = 0;
553  return NGX_OK;
554  }
555 
556  level = NGX_LOG_INFO;
557 
558  } else {
559  level = NGX_LOG_ALERT;
560  }
561 
562  ngx_log_error(level, cycle->log, err, "kevent() failed");
563  return NGX_ERROR;
564  }
565 
566  if (events == 0) {
567  if (timer != NGX_TIMER_INFINITE) {
568  return NGX_OK;
569  }
570 
571  ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
572  "kevent() returned no events without timeout");
573  return NGX_ERROR;
574  }
575 
576  ngx_mutex_lock(ngx_posted_events_mutex);
577 
578  for (i = 0; i < events; i++) {
579 
580  ngx_kqueue_dump_event(cycle->log, &event_list[i]);
581 
582  if (event_list[i].flags & EV_ERROR) {
583  ngx_log_error(NGX_LOG_ALERT, cycle->log, event_list[i].data,
584  "kevent() error on %d filter:%d flags:%04Xd",
585  event_list[i].ident, event_list[i].filter,
586  event_list[i].flags);
587  continue;
588  }
589 
590 #if (NGX_HAVE_TIMER_EVENT)
591 
592  if (event_list[i].filter == EVFILT_TIMER) {
593  ngx_time_update();
594  continue;
595  }
596 
597 #endif
598 
599  ev = (ngx_event_t *) event_list[i].udata;
600 
601  switch (event_list[i].filter) {
602 
603  case EVFILT_READ:
604  case EVFILT_WRITE:
605 
606  instance = (uintptr_t) ev & 1;
607  ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1);
608 
609  if (ev->closed || ev->instance != instance) {
610 
611  /*
612  * the stale event from a file descriptor
613  * that was just closed in this iteration
614  */
615 
616  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
617  "kevent: stale event %p", ev);
618  continue;
619  }
620 
621  if (ev->log && (ev->log->log_level & NGX_LOG_DEBUG_CONNECTION)) {
622  ngx_kqueue_dump_event(ev->log, &event_list[i]);
623  }
624 
625  if (ev->oneshot) {
626  ev->active = 0;
627  }
628 
629 #if (NGX_THREADS)
630 
631  if ((flags & NGX_POST_THREAD_EVENTS) && !ev->accept) {
632  ev->posted_ready = 1;
633  ev->posted_available = event_list[i].data;
634 
635  if (event_list[i].flags & EV_EOF) {
636  ev->posted_eof = 1;
637  ev->posted_errno = event_list[i].fflags;
638  }
639 
640  ngx_locked_post_event(ev, &ngx_posted_events);
641 
642  continue;
643  }
644 
645 #endif
646 
647  ev->available = event_list[i].data;
648 
649  if (event_list[i].flags & EV_EOF) {
650  ev->pending_eof = 1;
651  ev->kq_errno = event_list[i].fflags;
652  }
653 
654  ev->ready = 1;
655 
656  break;
657 
658  case EVFILT_VNODE:
659  ev->kq_vnode = 1;
660 
661  break;
662 
663  case EVFILT_AIO:
664  ev->complete = 1;
665  ev->ready = 1;
666 
667  break;
668 
669  default:
670  ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
671  "unexpected kevent() filter %d",
672  event_list[i].filter);
673  continue;
674  }
675 
676  if (flags & NGX_POST_EVENTS) {
677  queue = (ngx_event_t **) (ev->accept ? &ngx_posted_accept_events:
678  &ngx_posted_events);
679  ngx_locked_post_event(ev, queue);
680 
681  continue;
682  }
683 
684  ev->handler(ev);
685  }
686 
687  ngx_mutex_unlock(ngx_posted_events_mutex);
688 
689  return NGX_OK;
690 }
691 
692 
693 static ngx_int_t
694 ngx_kqueue_process_changes(ngx_cycle_t *cycle, ngx_uint_t try)
695 {
696  int n;
697  ngx_int_t rc;
698  ngx_err_t err;
699  struct timespec ts;
700  struct kevent *changes;
701 
702  ngx_mutex_lock(kevent_mutex);
703 
704  ngx_mutex_lock(list_mutex);
705 
706  if (nchanges == 0) {
707  ngx_mutex_unlock(list_mutex);
708  ngx_mutex_unlock(kevent_mutex);
709  return NGX_OK;
710  }
711 
712  changes = change_list;
713  if (change_list == change_list0) {
714  change_list = change_list1;
715  } else {
716  change_list = change_list0;
717  }
718 
719  n = (int) nchanges;
720  nchanges = 0;
721 
722  ngx_mutex_unlock(list_mutex);
723 
724  ts.tv_sec = 0;
725  ts.tv_nsec = 0;
726 
727  ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
728  "kevent changes: %d", n);
729 
730  if (kevent(ngx_kqueue, changes, n, NULL, 0, &ts) == -1) {
731  err = ngx_errno;
732  ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
733  cycle->log, err, "kevent() failed");
734  rc = NGX_ERROR;
735 
736  } else {
737  rc = NGX_OK;
738  }
739 
740  ngx_mutex_unlock(kevent_mutex);
741 
742  return rc;
743 }
744 
745 
746 static ngx_inline void
747 ngx_kqueue_dump_event(ngx_log_t *log, struct kevent *kev)
748 {
749  ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,
750  (kev->ident > 0x8000000 && kev->ident != (unsigned) -1) ?
751  "kevent: %p: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p":
752  "kevent: %d: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p",
753  kev->ident, kev->filter,
754  kev->flags, kev->fflags,
755  kev->data, kev->udata);
756 }
757 
758 
759 static void *
760 ngx_kqueue_create_conf(ngx_cycle_t *cycle)
761 {
762  ngx_kqueue_conf_t *kcf;
763 
764  kcf = ngx_palloc(cycle->pool, sizeof(ngx_kqueue_conf_t));
765  if (kcf == NULL) {
766  return NULL;
767  }
768 
769  kcf->changes = NGX_CONF_UNSET;
770  kcf->events = NGX_CONF_UNSET;
771 
772  return kcf;
773 }
774 
775 
776 static char *
777 ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf)
778 {
779  ngx_kqueue_conf_t *kcf = conf;
780 
781  ngx_conf_init_uint_value(kcf->changes, 512);
782  ngx_conf_init_uint_value(kcf->events, 512);
783 
784  return NGX_CONF_OK;
785 }
Generated on Sun Nov 10 2013 09:49:07 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2