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 #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);
37
38 static void *ngx_kqueue_create_conf(ngx_cycle_t *cycle);
39 static char *ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf);
40
41
42 int ngx_kqueue = -1;
43
44 static struct kevent *change_list;
45 static struct kevent *event_list;
46 static ngx_uint_t max_changes, nchanges, nevents;
47
48 #ifdef EVFILT_USER
49 static ngx_event_t notify_event;
50 static struct kevent notify_kev;
51 #endif
52
53 #if (NGX_HAVE_FSTACK)
54 extern int kqueue(void);
55 extern int kevent(int kq, const struct kevent *changelist, int nchanges,
56 struct kevent *eventlist, int nevents, const struct timespec *timeout);
57 #endif
58
59 static ngx_str_t kqueue_name = ngx_string("kqueue");
60
61 static ngx_command_t ngx_kqueue_commands[] = {
62
63 { ngx_string("kqueue_changes"),
64 NGX_EVENT_CONF|NGX_CONF_TAKE1,
65 ngx_conf_set_num_slot,
66 0,
67 offsetof(ngx_kqueue_conf_t, changes),
68 NULL },
69
70 { ngx_string("kqueue_events"),
71 NGX_EVENT_CONF|NGX_CONF_TAKE1,
72 ngx_conf_set_num_slot,
73 0,
74 offsetof(ngx_kqueue_conf_t, events),
75 NULL },
76
77 ngx_null_command
78 };
79
80
81 static ngx_event_module_t ngx_kqueue_module_ctx = {
82 &kqueue_name,
83 ngx_kqueue_create_conf, /* create configuration */
84 ngx_kqueue_init_conf, /* init configuration */
85
86 {
87 ngx_kqueue_add_event, /* add an event */
88 ngx_kqueue_del_event, /* delete an event */
89 ngx_kqueue_add_event, /* enable an event */
90 ngx_kqueue_del_event, /* disable an event */
91 NULL, /* add an connection */
92 NULL, /* delete an connection */
93 #ifdef EVFILT_USER
94 ngx_kqueue_notify, /* trigger a notify */
95 #else
96 NULL, /* trigger a notify */
97 #endif
98 ngx_kqueue_process_events, /* process the events */
99 ngx_kqueue_init, /* init the events */
100 ngx_kqueue_done /* done the events */
101 }
102
103 };
104
105 ngx_module_t ngx_kqueue_module = {
106 NGX_MODULE_V1,
107 &ngx_kqueue_module_ctx, /* module context */
108 ngx_kqueue_commands, /* module directives */
109 NGX_EVENT_MODULE, /* module type */
110 NULL, /* init master */
111 NULL, /* init module */
112 NULL, /* init process */
113 NULL, /* init thread */
114 NULL, /* exit thread */
115 NULL, /* exit process */
116 NULL, /* exit master */
117 NGX_MODULE_V1_PADDING
118 };
119
120
121 static ngx_int_t
ngx_kqueue_init(ngx_cycle_t * cycle,ngx_msec_t timer)122 ngx_kqueue_init(ngx_cycle_t *cycle, ngx_msec_t timer)
123 {
124 ngx_kqueue_conf_t *kcf;
125 struct timespec ts;
126 #if (NGX_HAVE_TIMER_EVENT)
127 struct kevent kev;
128 #endif
129
130 #if (NGX_HAVE_FSTACK)
131 if(ngx_ff_process == NGX_FF_PROCESS_NONE) {
132 return NGX_OK;
133 }
134 #endif
135
136 kcf = ngx_event_get_conf(cycle->conf_ctx, ngx_kqueue_module);
137
138 if (ngx_kqueue == -1) {
139 ngx_kqueue = kqueue();
140
141 if (ngx_kqueue == -1) {
142 ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
143 "kqueue() failed");
144 return NGX_ERROR;
145 }
146
147 #ifdef EVFILT_USER
148 if (ngx_kqueue_notify_init(cycle->log) != NGX_OK) {
149 return NGX_ERROR;
150 }
151 #endif
152 }
153
154 if (max_changes < kcf->changes) {
155 if (nchanges) {
156 ts.tv_sec = 0;
157 ts.tv_nsec = 0;
158
159 if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
160 == -1)
161 {
162 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
163 "kevent() failed");
164 return NGX_ERROR;
165 }
166 nchanges = 0;
167 }
168
169 if (change_list) {
170 ngx_free(change_list);
171 }
172
173 change_list = ngx_alloc(kcf->changes * sizeof(struct kevent),
174 cycle->log);
175 if (change_list == NULL) {
176 return NGX_ERROR;
177 }
178 }
179
180 max_changes = kcf->changes;
181
182 if (nevents < kcf->events) {
183 if (event_list) {
184 ngx_free(event_list);
185 }
186
187 event_list = ngx_alloc(kcf->events * sizeof(struct kevent), cycle->log);
188 if (event_list == NULL) {
189 return NGX_ERROR;
190 }
191 }
192
193 ngx_event_flags = NGX_USE_ONESHOT_EVENT
194 |NGX_USE_KQUEUE_EVENT
195 |NGX_USE_VNODE_EVENT;
196
197 #if (NGX_HAVE_TIMER_EVENT)
198
199 if (timer) {
200 kev.ident = 0;
201 kev.filter = EVFILT_TIMER;
202 kev.flags = EV_ADD|EV_ENABLE;
203 kev.fflags = 0;
204 kev.data = timer;
205 kev.udata = 0;
206
207 ts.tv_sec = 0;
208 ts.tv_nsec = 0;
209
210 if (kevent(ngx_kqueue, &kev, 1, NULL, 0, &ts) == -1) {
211 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
212 "kevent(EVFILT_TIMER) failed");
213 return NGX_ERROR;
214 }
215
216 ngx_event_flags |= NGX_USE_TIMER_EVENT;
217 }
218
219 #endif
220
221 #if (NGX_HAVE_CLEAR_EVENT)
222 ngx_event_flags |= NGX_USE_CLEAR_EVENT;
223 #else
224 ngx_event_flags |= NGX_USE_LEVEL_EVENT;
225 #endif
226
227 #if (NGX_HAVE_LOWAT_EVENT)
228 ngx_event_flags |= NGX_USE_LOWAT_EVENT;
229 #endif
230
231 nevents = kcf->events;
232
233 ngx_io = ngx_os_io;
234
235 ngx_event_actions = ngx_kqueue_module_ctx.actions;
236
237 return NGX_OK;
238 }
239
240
241 #ifdef EVFILT_USER
242
243 static ngx_int_t
ngx_kqueue_notify_init(ngx_log_t * log)244 ngx_kqueue_notify_init(ngx_log_t *log)
245 {
246 notify_kev.ident = 0;
247 notify_kev.filter = EVFILT_USER;
248 notify_kev.data = 0;
249 notify_kev.flags = EV_ADD|EV_CLEAR;
250 notify_kev.fflags = 0;
251 notify_kev.udata = 0;
252
253 if (kevent(ngx_kqueue, ¬ify_kev, 1, NULL, 0, NULL) == -1) {
254 ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
255 "kevent(EVFILT_USER, EV_ADD) failed");
256 return NGX_ERROR;
257 }
258
259 notify_event.active = 1;
260 notify_event.log = log;
261
262 notify_kev.flags = 0;
263 notify_kev.fflags = NOTE_TRIGGER;
264 notify_kev.udata = NGX_KQUEUE_UDATA_T ((uintptr_t) ¬ify_event);
265
266 return NGX_OK;
267 }
268
269 #endif
270
271
272 static void
ngx_kqueue_done(ngx_cycle_t * cycle)273 ngx_kqueue_done(ngx_cycle_t *cycle)
274 {
275 if (close(ngx_kqueue) == -1) {
276 ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
277 "kqueue close() failed");
278 }
279
280 ngx_kqueue = -1;
281
282 ngx_free(change_list);
283 ngx_free(event_list);
284
285 change_list = NULL;
286 event_list = NULL;
287 max_changes = 0;
288 nchanges = 0;
289 nevents = 0;
290 }
291
292
293 static ngx_int_t
ngx_kqueue_add_event(ngx_event_t * ev,ngx_int_t event,ngx_uint_t flags)294 ngx_kqueue_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
295 {
296 ngx_int_t rc;
297 #if 0
298 ngx_event_t *e;
299 ngx_connection_t *c;
300 #endif
301
302 ev->active = 1;
303 ev->disabled = 0;
304 ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;
305
306 #if 0
307
308 if (ev->index < nchanges
309 && ((uintptr_t) change_list[ev->index].udata & (uintptr_t) ~1)
310 == (uintptr_t) ev)
311 {
312 if (change_list[ev->index].flags == EV_DISABLE) {
313
314 /*
315 * if the EV_DISABLE is still not passed to a kernel
316 * we will not pass it
317 */
318
319 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
320 "kevent activated: %d: ft:%i",
321 ngx_event_ident(ev->data), event);
322
323 if (ev->index < --nchanges) {
324 e = (ngx_event_t *)
325 ((uintptr_t) change_list[nchanges].udata & (uintptr_t) ~1);
326 change_list[ev->index] = change_list[nchanges];
327 e->index = ev->index;
328 }
329
330 return NGX_OK;
331 }
332
333 c = ev->data;
334
335 ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
336 "previous event on #%d were not passed in kernel", c->fd);
337
338 return NGX_ERROR;
339 }
340
341 #endif
342
343 rc = ngx_kqueue_set_event(ev, event, EV_ADD|EV_ENABLE|flags);
344
345 return rc;
346 }
347
348
349 static ngx_int_t
ngx_kqueue_del_event(ngx_event_t * ev,ngx_int_t event,ngx_uint_t flags)350 ngx_kqueue_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
351 {
352 ngx_int_t rc;
353 ngx_event_t *e;
354
355 ev->active = 0;
356 ev->disabled = 0;
357
358 if (ev->index < nchanges
359 && ((uintptr_t) change_list[ev->index].udata & (uintptr_t) ~1)
360 == (uintptr_t) ev)
361 {
362 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
363 "kevent deleted: %d: ft:%i",
364 ngx_event_ident(ev->data), event);
365
366 /* if the event is still not passed to a kernel we will not pass it */
367
368 nchanges--;
369
370 if (ev->index < nchanges) {
371 e = (ngx_event_t *)
372 ((uintptr_t) change_list[nchanges].udata & (uintptr_t) ~1);
373 change_list[ev->index] = change_list[nchanges];
374 e->index = ev->index;
375 }
376
377 return NGX_OK;
378 }
379
380 /*
381 * when the file descriptor is closed the kqueue automatically deletes
382 * its filters so we do not need to delete explicitly the event
383 * before the closing the file descriptor.
384 */
385
386 if (flags & NGX_CLOSE_EVENT) {
387 return NGX_OK;
388 }
389
390 if (flags & NGX_DISABLE_EVENT) {
391 ev->disabled = 1;
392
393 } else {
394 flags |= EV_DELETE;
395 }
396
397 rc = ngx_kqueue_set_event(ev, event, flags);
398
399 return rc;
400 }
401
402
403 static ngx_int_t
ngx_kqueue_set_event(ngx_event_t * ev,ngx_int_t filter,ngx_uint_t flags)404 ngx_kqueue_set_event(ngx_event_t *ev, ngx_int_t filter, ngx_uint_t flags)
405 {
406 struct kevent *kev;
407 struct timespec ts;
408 ngx_connection_t *c;
409
410 c = ev->data;
411
412 ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
413 "kevent set event: %d: ft:%i fl:%04Xi",
414 c->fd, filter, flags);
415
416 if (nchanges >= max_changes) {
417 ngx_log_error(NGX_LOG_WARN, ev->log, 0,
418 "kqueue change list is filled up");
419
420 ts.tv_sec = 0;
421 ts.tv_nsec = 0;
422
423 if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
424 == -1)
425 {
426 ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent() failed");
427 return NGX_ERROR;
428 }
429
430 nchanges = 0;
431 }
432
433 kev = &change_list[nchanges];
434
435 kev->ident = c->fd;
436 kev->filter = (short) filter;
437 kev->flags = (u_short) flags;
438 kev->udata = NGX_KQUEUE_UDATA_T ((uintptr_t) ev | ev->instance);
439
440 if (filter == EVFILT_VNODE) {
441 kev->fflags = NOTE_DELETE|NOTE_WRITE|NOTE_EXTEND
442 |NOTE_ATTRIB|NOTE_RENAME
443 #if (__FreeBSD__ == 4 && __FreeBSD_version >= 430000) \
444 || __FreeBSD_version >= 500018
445 |NOTE_REVOKE
446 #endif
447 ;
448 kev->data = 0;
449
450 } else {
451 #if (NGX_HAVE_LOWAT_EVENT)
452 if (flags & NGX_LOWAT_EVENT) {
453 kev->fflags = NOTE_LOWAT;
454 kev->data = ev->available;
455
456 } else {
457 kev->fflags = 0;
458 kev->data = 0;
459 }
460 #else
461 kev->fflags = 0;
462 kev->data = 0;
463 #endif
464 }
465
466 ev->index = nchanges;
467 nchanges++;
468
469 if (flags & NGX_FLUSH_EVENT) {
470 ts.tv_sec = 0;
471 ts.tv_nsec = 0;
472
473 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "kevent flush");
474
475 if (kevent(ngx_kqueue, change_list, (int) nchanges, NULL, 0, &ts)
476 == -1)
477 {
478 ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "kevent() failed");
479 return NGX_ERROR;
480 }
481
482 nchanges = 0;
483 }
484
485 return NGX_OK;
486 }
487
488
489 #ifdef EVFILT_USER
490
491 static ngx_int_t
ngx_kqueue_notify(ngx_event_handler_pt handler)492 ngx_kqueue_notify(ngx_event_handler_pt handler)
493 {
494 notify_event.handler = handler;
495
496 if (kevent(ngx_kqueue, ¬ify_kev, 1, NULL, 0, NULL) == -1) {
497 ngx_log_error(NGX_LOG_ALERT, notify_event.log, ngx_errno,
498 "kevent(EVFILT_USER, NOTE_TRIGGER) failed");
499 return NGX_ERROR;
500 }
501
502 return NGX_OK;
503 }
504
505 #endif
506
507
508 static ngx_int_t
ngx_kqueue_process_events(ngx_cycle_t * cycle,ngx_msec_t timer,ngx_uint_t flags)509 ngx_kqueue_process_events(ngx_cycle_t *cycle, ngx_msec_t timer,
510 ngx_uint_t flags)
511 {
512 int events, n;
513 ngx_int_t i, instance;
514 ngx_uint_t level;
515 ngx_err_t err;
516 ngx_event_t *ev;
517 ngx_queue_t *queue;
518 struct timespec ts, *tp;
519
520 n = (int) nchanges;
521 nchanges = 0;
522
523 if (timer == NGX_TIMER_INFINITE) {
524 tp = NULL;
525
526 } else {
527
528 ts.tv_sec = timer / 1000;
529 ts.tv_nsec = (timer % 1000) * 1000000;
530
531 /*
532 * 64-bit Darwin kernel has the bug: kernel level ts.tv_nsec is
533 * the int32_t while user level ts.tv_nsec is the long (64-bit),
534 * so on the big endian PowerPC all nanoseconds are lost.
535 */
536
537 #if (NGX_DARWIN_KEVENT_BUG)
538 ts.tv_nsec <<= 32;
539 #endif
540
541 tp = &ts;
542 }
543
544 #if (NGX_HAVE_FSTACK)
545 if (n > 0) {
546 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
547 "kevent timer: %M, changes: %d", timer, n);
548 }
549 #else
550 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
551 "kevent timer: %M, changes: %d", timer, n);
552 #endif
553
554 events = kevent(ngx_kqueue, change_list, n, event_list, (int) nevents, tp);
555
556 err = (events == -1) ? ngx_errno : 0;
557
558 if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
559 ngx_time_update();
560 }
561
562 #if !(NGX_HAVE_FSTACK)
563 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
564 "kevent events: %d", events);
565 #endif
566
567 if (err) {
568 if (err == NGX_EINTR) {
569
570 if (ngx_event_timer_alarm) {
571 ngx_event_timer_alarm = 0;
572 return NGX_OK;
573 }
574
575 level = NGX_LOG_INFO;
576
577 } else {
578 level = NGX_LOG_ALERT;
579 }
580
581 ngx_log_error(level, cycle->log, err, "kevent() failed");
582 return NGX_ERROR;
583 }
584
585 if (events == 0) {
586 #if (NGX_HAVE_FSTACK)
587 return NGX_OK;
588 #else
589 if (timer != NGX_TIMER_INFINITE) {
590 return NGX_OK;
591 }
592
593 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
594 "kevent() returned no events without timeout");
595 return NGX_ERROR;
596 #endif
597 }
598
599 for (i = 0; i < events; i++) {
600
601 ngx_kqueue_dump_event(cycle->log, &event_list[i]);
602
603 if (event_list[i].flags & EV_ERROR) {
604 ngx_log_error(NGX_LOG_ALERT, cycle->log, event_list[i].data,
605 "kevent() error on %d filter:%d flags:%04Xd",
606 (int) event_list[i].ident, event_list[i].filter,
607 event_list[i].flags);
608 continue;
609 }
610
611 #if (NGX_HAVE_TIMER_EVENT)
612
613 if (event_list[i].filter == EVFILT_TIMER) {
614 ngx_time_update();
615 continue;
616 }
617
618 #endif
619
620 ev = (ngx_event_t *) event_list[i].udata;
621
622 switch (event_list[i].filter) {
623
624 case EVFILT_READ:
625 case EVFILT_WRITE:
626
627 instance = (uintptr_t) ev & 1;
628 ev = (ngx_event_t *) ((uintptr_t) ev & (uintptr_t) ~1);
629
630 if (ev->closed || ev->instance != instance) {
631
632 /*
633 * the stale event from a file descriptor
634 * that was just closed in this iteration
635 */
636
637 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
638 "kevent: stale event %p", ev);
639 continue;
640 }
641
642 if (ev->log && (ev->log->log_level & NGX_LOG_DEBUG_CONNECTION)) {
643 ngx_kqueue_dump_event(ev->log, &event_list[i]);
644 }
645
646 if (ev->oneshot) {
647 ev->active = 0;
648 }
649
650 ev->available = event_list[i].data;
651
652 if (event_list[i].flags & EV_EOF) {
653 ev->pending_eof = 1;
654 ev->kq_errno = event_list[i].fflags;
655 }
656
657 ev->ready = 1;
658
659 break;
660
661 case EVFILT_VNODE:
662 ev->kq_vnode = 1;
663
664 break;
665
666 case EVFILT_AIO:
667 ev->complete = 1;
668 ev->ready = 1;
669
670 break;
671
672 #ifdef EVFILT_USER
673 case EVFILT_USER:
674 break;
675 #endif
676
677 default:
678 ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
679 "unexpected kevent() filter %d",
680 event_list[i].filter);
681 continue;
682 }
683
684 if (flags & NGX_POST_EVENTS) {
685 queue = ev->accept ? &ngx_posted_accept_events
686 : &ngx_posted_events;
687
688 ngx_post_event(ev, queue);
689
690 continue;
691 }
692
693 ev->handler(ev);
694 }
695
696 return NGX_OK;
697 }
698
699
700 static ngx_inline void
ngx_kqueue_dump_event(ngx_log_t * log,struct kevent * kev)701 ngx_kqueue_dump_event(ngx_log_t *log, struct kevent *kev)
702 {
703 if (kev->ident > 0x8000000 && kev->ident != (unsigned) -1) {
704 ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,
705 "kevent: %p: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p",
706 (void *) kev->ident, kev->filter,
707 kev->flags, kev->fflags,
708 (int) kev->data, kev->udata);
709
710 } else {
711 ngx_log_debug6(NGX_LOG_DEBUG_EVENT, log, 0,
712 "kevent: %d: ft:%d fl:%04Xd ff:%08Xd d:%d ud:%p",
713 (int) kev->ident, kev->filter,
714 kev->flags, kev->fflags,
715 (int) kev->data, kev->udata);
716 }
717 }
718
719
720 static void *
ngx_kqueue_create_conf(ngx_cycle_t * cycle)721 ngx_kqueue_create_conf(ngx_cycle_t *cycle)
722 {
723 ngx_kqueue_conf_t *kcf;
724
725 kcf = ngx_palloc(cycle->pool, sizeof(ngx_kqueue_conf_t));
726 if (kcf == NULL) {
727 return NULL;
728 }
729
730 kcf->changes = NGX_CONF_UNSET;
731 kcf->events = NGX_CONF_UNSET;
732
733 return kcf;
734 }
735
736
737 static char *
ngx_kqueue_init_conf(ngx_cycle_t * cycle,void * conf)738 ngx_kqueue_init_conf(ngx_cycle_t *cycle, void *conf)
739 {
740 ngx_kqueue_conf_t *kcf = conf;
741
742 ngx_conf_init_uint_value(kcf->changes, 512);
743 ngx_conf_init_uint_value(kcf->events, 512);
744
745 return NGX_CONF_OK;
746 }
747