include/hyperman/backend_kqueue.c

filter: Statementstmt 100% 2 / 2 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 100% 2 / 2 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« include/hyperman/backend_iouring.c ↑ Summary include/hyperman/backend_wsapoll.c »
1 /* Hyperman::Event::Kqueue - the kqueue readiness backend (macOS / BSD).
2 * Implements the hm_backend interface from hyperman.h. Timers use the
3 * watcher pointer as the kevent ident so one backend hosts many one-shot
4 * timers; signals use EVFILT_SIGNAL (caller must SIG_IGN the default
5 * disposition). */
6  
7 #include "hyperman.h"
8  
9 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
10 #define HM_HAVE_KQUEUE 1
11 #endif
12  
13 #ifdef HM_HAVE_KQUEUE
14  
15 #include <sys/types.h>
16 #include <sys/event.h>
17 #include <sys/time.h>
18 #include <stdlib.h>
19 #include <errno.h>
20 #include <unistd.h>
21  
22 typedef struct { int kq; } hm_kq_state;
23  
24 static int kq_apply(hm_backend *be, int fd, int mask, int flags) {
25 hm_kq_state *st = (hm_kq_state *)be->state;
26 struct kevent kev[2];
27 int n = 0;
28 if (mask & HM_EV_READ) { EV_SET(&kev[n], fd, EVFILT_READ, flags, 0, 0, NULL); n++; }
29 if (mask & HM_EV_WRITE) { EV_SET(&kev[n], fd, EVFILT_WRITE, flags, 0, 0, NULL); n++; }
30 if (!n) return 0; /* # uncoverable branch true */
31 return kevent(st->kq, kev, n, NULL, 0, NULL);
32 }
33  
34 static int kq_add_io(hm_backend *be, int fd, int mask, int oneshot) {
35 return kq_apply(be, fd, mask, EV_ADD | (oneshot ? EV_ONESHOT : 0));
36 }
37  
38 /*
39 # uncoverable statement
40 # uncoverable subroutine */
41 static int kq_modify_io(hm_backend *be, int fd, int mask, int oneshot) {
42 /* kqueue ADD on an existing filter re-arms it; same call */
43 return kq_apply(be, fd, mask, EV_ADD | (oneshot ? EV_ONESHOT : 0)); /* # uncoverable statement */
44 }
45  
46 static int kq_remove_io(hm_backend *be, int fd, int mask) {
47 return kq_apply(be, fd, mask, EV_DELETE);
48 }
49  
50 static int kq_add_timer(hm_backend *be, double secs, int oneshot, void *udata) {
51 hm_kq_state *st = (hm_kq_state *)be->state;
52 struct kevent kev;
53 /* whole milliseconds, rounded UP: a timer must never come due before
54 * the deadline it was armed for */
55 long ms = (long)(secs * 1000);
56 if ((double)ms < secs * 1000) ms++;
57 if (ms < 1) ms = 1;
58 EV_SET(&kev, (uintptr_t)udata, EVFILT_TIMER,
59 EV_ADD | (oneshot ? EV_ONESHOT : 0), 0, ms, udata);
60 return kevent(st->kq, &kev, 1, NULL, 0, NULL);
61 }
62  
63 static int kq_del_timer(hm_backend *be, void *udata) {
64 hm_kq_state *st = (hm_kq_state *)be->state;
65 struct kevent kev;
66 EV_SET(&kev, (uintptr_t)udata, EVFILT_TIMER, EV_DELETE, 0, 0, NULL);
67 return kevent(st->kq, &kev, 1, NULL, 0, NULL);
68 }
69  
70 static int kq_add_signal(hm_backend *be, int signo) {
71 hm_kq_state *st = (hm_kq_state *)be->state;
72 struct kevent kev;
73 EV_SET(&kev, signo, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
74 return kevent(st->kq, &kev, 1, NULL, 0, NULL);
75 }
76  
77 static int kq_wait(hm_backend *be, hm_event *out, int max, double timeout) {
78 hm_kq_state *st = (hm_kq_state *)be->state;
79 struct kevent evs[HM_MAXEV];
80 struct timespec ts, *tsp = NULL;
81 int n, i;
82 if (max > HM_MAXEV) max = HM_MAXEV;
83 if (timeout >= 0) {
84 ts.tv_sec = (time_t)timeout;
85 ts.tv_nsec = (long)((timeout - (double)ts.tv_sec) * 1e9);
86 tsp = &ts;
87 }
88 n = kevent(st->kq, NULL, 0, evs, max, tsp);
89 if (n <= 0) return n;
90 for (i = 0; i < n; i++) {
91 switch (evs[i].filter) { /* # uncoverable branch true count:5 */
92 case EVFILT_READ:
93 out[i].kind = HM_EV_READ; out[i].fd = (int)evs[i].ident;
94 out[i].udata = NULL; break;
95 case EVFILT_WRITE:
96 out[i].kind = HM_EV_WRITE; out[i].fd = (int)evs[i].ident;
97 out[i].udata = NULL; break;
98 case EVFILT_TIMER:
99 out[i].kind = HM_EV_TIMER; out[i].fd = -1;
100 out[i].udata = evs[i].udata; break;
101 case EVFILT_SIGNAL:
102 out[i].kind = HM_EV_SIGNAL; out[i].fd = (int)evs[i].ident;
103 out[i].udata = NULL; break;
104 default:
105 out[i].kind = 0; out[i].fd = -1; out[i].udata = NULL; /* # uncoverable statement */
106 }
107 }
108 return n;
109 }
110  
111 static void kq_destroy(hm_backend *be) {
112 hm_kq_state *st = (hm_kq_state *)be->state;
113 /* be->foreign: inherited across a fork, so nothing here is ours to
114 * close. A kqueue does not survive fork at all, and the child's own
115 * kqueue() has almost certainly been handed this very number. */
116 if (st) { if (st->kq >= 0 && !be->foreign) close(st->kq); free(st); }
117 free(be);
118 }
119  
120 hm_backend *hm_backend_kqueue_new(void) {
121 hm_backend *be = (hm_backend *)hm_xcalloc(1, sizeof(hm_backend));
122 hm_kq_state *st = (hm_kq_state *)hm_xcalloc(1, sizeof(hm_kq_state));
123 if (!be || !st) { free(be); free(st); return NULL; }
124 st->kq = kqueue();
125 if (st->kq < 0) { free(be); free(st); return NULL; } /* # uncoverable branch true */
126 be->name = "kqueue";
127 be->state = st;
128 be->add_io = kq_add_io;
129 be->modify_io = kq_modify_io;
130 be->remove_io = kq_remove_io;
131 be->add_timer = kq_add_timer;
132 be->del_timer = kq_del_timer;
133 be->add_signal = kq_add_signal;
134 be->wait = kq_wait;
135 be->destroy = kq_destroy;
136 return be;
137 }
138  
139 int hm_backend_kqueue_available(void) { return 1; }
140  
141 #else /* !HM_HAVE_KQUEUE */
142  
143 151 hm_backend *hm_backend_kqueue_new(void) { return 0; }
144 5 int hm_backend_kqueue_available(void) { return 0; }
145  
146 #endif
« include/hyperman/backend_iouring.c ↑ Summary include/hyperman/backend_wsapoll.c »