include/fetch/backend_kqueue.c

filter: Statementstmt 50.0% 1 / 2 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 50.0% 1 / 2 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« include/fetch/backend_iouring.c ↑ Summary include/fetch/ft_future.h »
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 "ft_backend.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;
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 static int kq_modify_io(hm_backend *be, int fd, int mask, int oneshot) {
39 /* kqueue ADD on an existing filter re-arms it; same call */
40 return kq_apply(be, fd, mask, EV_ADD | (oneshot ? EV_ONESHOT : 0));
41 }
42  
43 static int kq_remove_io(hm_backend *be, int fd, int mask) {
44 return kq_apply(be, fd, mask, EV_DELETE);
45 }
46  
47 static int kq_add_timer(hm_backend *be, double secs, int oneshot, void *udata) {
48 hm_kq_state *st = (hm_kq_state *)be->state;
49 struct kevent kev;
50 /* whole milliseconds, rounded UP: a timer must never come due before
51 * the deadline it was armed for */
52 long ms = (long)(secs * 1000);
53 if ((double)ms < secs * 1000) ms++;
54 if (ms < 1) ms = 1;
55 EV_SET(&kev, (uintptr_t)udata, EVFILT_TIMER,
56 EV_ADD | (oneshot ? EV_ONESHOT : 0), 0, ms, udata);
57 return kevent(st->kq, &kev, 1, NULL, 0, NULL);
58 }
59  
60 static int kq_del_timer(hm_backend *be, void *udata) {
61 hm_kq_state *st = (hm_kq_state *)be->state;
62 struct kevent kev;
63 EV_SET(&kev, (uintptr_t)udata, EVFILT_TIMER, EV_DELETE, 0, 0, NULL);
64 return kevent(st->kq, &kev, 1, NULL, 0, NULL);
65 }
66  
67 static int kq_add_signal(hm_backend *be, int signo) {
68 hm_kq_state *st = (hm_kq_state *)be->state;
69 struct kevent kev;
70 EV_SET(&kev, signo, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
71 return kevent(st->kq, &kev, 1, NULL, 0, NULL);
72 }
73  
74 static int kq_wait(hm_backend *be, hm_event *out, int max, double timeout) {
75 hm_kq_state *st = (hm_kq_state *)be->state;
76 struct kevent evs[HM_MAXEV];
77 struct timespec ts, *tsp = NULL;
78 int n, i;
79 if (max > HM_MAXEV) max = HM_MAXEV;
80 if (timeout >= 0) {
81 ts.tv_sec = (time_t)timeout;
82 ts.tv_nsec = (long)((timeout - (double)ts.tv_sec) * 1e9);
83 tsp = &ts;
84 }
85 n = kevent(st->kq, NULL, 0, evs, max, tsp);
86 if (n <= 0) return n;
87 for (i = 0; i < n; i++) {
88 switch (evs[i].filter) {
89 case EVFILT_READ:
90 out[i].kind = HM_EV_READ; out[i].fd = (int)evs[i].ident;
91 out[i].udata = NULL; break;
92 case EVFILT_WRITE:
93 out[i].kind = HM_EV_WRITE; out[i].fd = (int)evs[i].ident;
94 out[i].udata = NULL; break;
95 case EVFILT_TIMER:
96 out[i].kind = HM_EV_TIMER; out[i].fd = -1;
97 out[i].udata = evs[i].udata; break;
98 case EVFILT_SIGNAL:
99 out[i].kind = HM_EV_SIGNAL; out[i].fd = (int)evs[i].ident;
100 out[i].udata = NULL; break;
101 default:
102 out[i].kind = 0; out[i].fd = -1; out[i].udata = NULL;
103 }
104 }
105 return n;
106 }
107  
108 static void kq_destroy(hm_backend *be) {
109 hm_kq_state *st = (hm_kq_state *)be->state;
110 /* be->foreign: inherited across a fork, so nothing here is ours to
111 * close. A kqueue does not survive fork at all, and the child's own
112 * kqueue() has almost certainly been handed this very number. */
113 if (st) { if (st->kq >= 0 && !be->foreign) close(st->kq); free(st); }
114 free(be);
115 }
116  
117 hm_backend *hm_backend_kqueue_new(void) {
118 hm_backend *be = (hm_backend *)calloc(1, sizeof(hm_backend));
119 hm_kq_state *st = (hm_kq_state *)calloc(1, sizeof(hm_kq_state));
120 if (!be || !st) { free(be); free(st); return NULL; }
121 st->kq = kqueue();
122 if (st->kq < 0) { free(be); free(st); return NULL; }
123 be->name = "kqueue";
124 be->state = st;
125 be->add_io = kq_add_io;
126 be->modify_io = kq_modify_io;
127 be->remove_io = kq_remove_io;
128 be->add_timer = kq_add_timer;
129 be->del_timer = kq_del_timer;
130 be->add_signal = kq_add_signal;
131 be->wait_ev = kq_wait;
132 be->destroy = kq_destroy;
133 return be;
134 }
135  
136 int hm_backend_kqueue_available(void) { return 1; }
137  
138 #else /* !HM_HAVE_KQUEUE */
139  
140 44 hm_backend *hm_backend_kqueue_new(void) { return 0; }
141 0 int hm_backend_kqueue_available(void) { return 0; }
142  
143 #endif
« include/fetch/backend_iouring.c ↑ Summary include/fetch/ft_future.h »