![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_kqueue_module.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / event / modules|
Return to ngx_kqueue_module.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / event / modules |
1.1 misho 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: }