Doxygen Updates Janitor Work
[asterisk/asterisk.git] / res / res_timing_kqueue.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2010, Digium, Inc.
5  *
6  * Tilghman Lesher <tlesher AT digium DOT com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \author Tilghman Lesher \verbatim <tlesher AT digium DOT com> \endverbatim
22  *
23  * \brief kqueue timing interface
24  */
25
26 /*** MODULEINFO
27         <depend>kqueue</depend>
28         <conflict>launchd</conflict>
29         <support_level>extended</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 #include <sys/types.h>
35 #include <sys/event.h>
36 #include <sys/time.h>
37
38 #include "asterisk/module.h"
39 #include "asterisk/astobj2.h"
40 #include "asterisk/timing.h"
41 #include "asterisk/logger.h"
42 #include "asterisk/utils.h"
43 #include "asterisk/time.h"
44 #include "asterisk/test.h"
45 #include "asterisk/poll-compat.h"       /* for ast_poll() */
46
47 static void *timing_funcs_handle;
48
49 static int kqueue_timer_open(void);
50 static void kqueue_timer_close(int handle);
51 static int kqueue_timer_set_rate(int handle, unsigned int rate);
52 static void kqueue_timer_ack(int handle, unsigned int quantity);
53 static int kqueue_timer_enable_continuous(int handle);
54 static int kqueue_timer_disable_continuous(int handle);
55 static enum ast_timer_event kqueue_timer_get_event(int handle);
56 static unsigned int kqueue_timer_get_max_rate(int handle);
57
58 static struct ast_timing_interface kqueue_timing = {
59         .name = "kqueue",
60         .priority = 150,
61         .timer_open = kqueue_timer_open,
62         .timer_close = kqueue_timer_close,
63         .timer_set_rate = kqueue_timer_set_rate,
64         .timer_ack = kqueue_timer_ack,
65         .timer_enable_continuous = kqueue_timer_enable_continuous,
66         .timer_disable_continuous = kqueue_timer_disable_continuous,
67         .timer_get_event = kqueue_timer_get_event,
68         .timer_get_max_rate = kqueue_timer_get_max_rate,
69 };
70
71 static struct ao2_container *kqueue_timers;
72
73 struct kqueue_timer {
74         int handle;
75         uint64_t nsecs;
76         uint64_t unacked;
77         unsigned int is_continuous:1;
78 };
79
80 static int kqueue_timer_hash(const void *obj, const int flags)
81 {
82         const struct kqueue_timer *timer = obj;
83
84         return timer->handle;
85 }
86
87 static int kqueue_timer_cmp(void *obj, void *args, int flags)
88 {
89         struct kqueue_timer *timer1 = obj, *timer2 = args;
90         return timer1->handle == timer2->handle ? CMP_MATCH | CMP_STOP : 0;
91 }
92
93 static void timer_destroy(void *obj)
94 {
95         struct kqueue_timer *timer = obj;
96         close(timer->handle);
97 }
98
99 #define lookup_timer(a) _lookup_timer(a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
100 static struct kqueue_timer *_lookup_timer(int handle, const char *file, int line, const char *func)
101 {
102         struct kqueue_timer *our_timer, find_helper = {
103                 .handle = handle,
104         };
105
106         if (!(our_timer = ao2_find(kqueue_timers, &find_helper, OBJ_POINTER))) {
107                 ast_log(__LOG_ERROR, file, line, func, "Couldn't find timer with handle %d\n", handle);
108                 /* API says we set errno */
109                 errno = ESRCH;
110                 return NULL;
111         }
112         return our_timer;
113 }
114
115 static int kqueue_timer_open(void)
116 {
117         struct kqueue_timer *timer;
118         int handle;
119
120         if (!(timer = ao2_alloc(sizeof(*timer), timer_destroy))) {
121                 ast_log(LOG_ERROR, "Could not allocate memory for kqueue_timer structure\n");
122                 return -1;
123         }
124         if ((handle = kqueue()) < 0) {
125                 ast_log(LOG_ERROR, "Failed to create kqueue timer: %s\n", strerror(errno));
126                 ao2_ref(timer, -1);
127                 return -1;
128         }
129
130         timer->handle = handle;
131         ao2_link(kqueue_timers, timer);
132         /* Get rid of the reference from the allocation */
133         ao2_ref(timer, -1);
134         return handle;
135 }
136
137 static void kqueue_timer_close(int handle)
138 {
139         struct kqueue_timer *our_timer;
140
141         if (!(our_timer = lookup_timer(handle))) {
142                 return;
143         }
144
145         ao2_unlink(kqueue_timers, our_timer);
146         ao2_ref(our_timer, -1);
147 }
148
149 static void kqueue_set_nsecs(struct kqueue_timer *our_timer, uint64_t nsecs)
150 {
151         struct timespec nowait = { 0, 1 };
152 #ifdef HAVE_KEVENT64
153         struct kevent64_s kev;
154
155         EV_SET64(&kev, our_timer->handle, EVFILT_TIMER, EV_ADD | EV_ENABLE, NOTE_NSECONDS,
156                 nsecs, 0, 0, 0);
157         kevent64(our_timer->handle, &kev, 1, NULL, 0, 0, &nowait);
158 #else
159         struct kevent kev;
160
161         EV_SET(&kev, our_timer->handle, EVFILT_TIMER, EV_ADD | EV_ENABLE,
162 #ifdef NOTE_NSECONDS
163                 nsecs <= 0xFFffFFff ? NOTE_NSECONDS :
164 #endif
165 #ifdef NOTE_USECONDS
166                 NOTE_USECONDS
167 #else /* Milliseconds, if no constants are defined */
168                 0
169 #endif
170                 ,
171 #ifdef NOTE_NSECONDS
172                 nsecs <= 0xFFffFFff ? nsecs :
173 #endif
174 #ifdef NOTE_USECONDS
175         nsecs / 1000
176 #else /* Milliseconds, if nothing else is defined */
177         nsecs / 1000000
178 #endif
179         , NULL);
180         kevent(our_timer->handle, &kev, 1, NULL, 0, &nowait);
181 #endif
182 }
183
184 static int kqueue_timer_set_rate(int handle, unsigned int rate)
185 {
186         struct kqueue_timer *our_timer;
187
188         if (!(our_timer = lookup_timer(handle))) {
189                 return -1;
190         }
191
192         kqueue_set_nsecs(our_timer, (our_timer->nsecs = rate ? (long) (1000000000 / rate) : 0L));
193         ao2_ref(our_timer, -1);
194
195         return 0;
196 }
197
198 static void kqueue_timer_ack(int handle, unsigned int quantity)
199 {
200         struct kqueue_timer *our_timer;
201
202         if (!(our_timer = lookup_timer(handle))) {
203                 return;
204         }
205
206         if (our_timer->unacked < quantity) {
207                 ast_debug(1, "Acking more events than have expired?!!\n");
208                 our_timer->unacked = 0;
209         } else {
210                 our_timer->unacked -= quantity;
211         }
212 }
213
214 static int kqueue_timer_enable_continuous(int handle)
215 {
216         struct kqueue_timer *our_timer;
217
218         if (!(our_timer = lookup_timer(handle))) {
219                 return -1;
220         }
221
222         kqueue_set_nsecs(our_timer, 1);
223         our_timer->is_continuous = 1;
224         our_timer->unacked = 0;
225         ao2_ref(our_timer, -1);
226         return 0;
227 }
228
229 static int kqueue_timer_disable_continuous(int handle)
230 {
231         struct kqueue_timer *our_timer;
232
233         if (!(our_timer = lookup_timer(handle))) {
234                 return -1;
235         }
236
237         kqueue_set_nsecs(our_timer, our_timer->nsecs);
238         our_timer->is_continuous = 0;
239         our_timer->unacked = 0;
240         ao2_ref(our_timer, -1);
241         return 0;
242 }
243
244 static enum ast_timer_event kqueue_timer_get_event(int handle)
245 {
246         enum ast_timer_event res = -1;
247         struct kqueue_timer *our_timer;
248         struct timespec sixty_seconds = { 60, 0 };
249         struct kevent kev;
250
251         if (!(our_timer = lookup_timer(handle))) {
252                 return -1;
253         }
254
255         /* If we have non-ACKed events, just return immediately */
256         if (our_timer->unacked == 0) {
257                 if (kevent(handle, NULL, 0, &kev, 1, &sixty_seconds) > 0) {
258                         our_timer->unacked += kev.data;
259                 }
260         }
261
262         if (our_timer->unacked > 0) {
263                 res = our_timer->is_continuous ? AST_TIMING_EVENT_CONTINUOUS : AST_TIMING_EVENT_EXPIRED;
264         }
265
266         ao2_ref(our_timer, -1);
267         return res;
268 }
269
270 static unsigned int kqueue_timer_get_max_rate(int handle)
271 {
272         /* Actually, the max rate is 2^64-1 seconds, but that's not representable in a 32-bit integer. */
273         return UINT_MAX;
274 }
275
276 #ifdef TEST_FRAMEWORK
277 AST_TEST_DEFINE(test_kqueue_timing)
278 {
279         int res = AST_TEST_PASS, handle, i;
280         uint64_t diff;
281         struct pollfd pfd = { 0, POLLIN, 0 };
282         struct kqueue_timer *kt;
283         struct timeval start;
284
285         switch (cmd) {
286         case TEST_INIT:
287                 info->name = "test_kqueue_timing";
288                 info->category = "/res/res_timing_kqueue/";
289                 info->summary = "Test KQueue timing interface";
290                 info->description = "Verify that the KQueue timing interface correctly generates timing events";
291                 return AST_TEST_NOT_RUN;
292         case TEST_EXECUTE:
293                 break;
294         }
295
296         if (!(handle = kqueue_timer_open())) {
297                 ast_test_status_update(test, "Cannot open timer!\n");
298                 return AST_TEST_FAIL;
299         }
300
301         do {
302                 pfd.fd = handle;
303                 if (kqueue_timer_set_rate(handle, 1000)) {
304                         ast_test_status_update(test, "Cannot set timer rate to 1000/s\n");
305                         res = AST_TEST_FAIL;
306                         break;
307                 }
308                 if (ast_poll(&pfd, 1, 1000) < 1) {
309                         ast_test_status_update(test, "Polling on a kqueue doesn't work\n");
310                         res = AST_TEST_FAIL;
311                         break;
312                 }
313                 if (pfd.revents != POLLIN) {
314                         ast_test_status_update(test, "poll() should have returned POLLIN, but instead returned %hd\n", pfd.revents);
315                         res = AST_TEST_FAIL;
316                         break;
317                 }
318                 if (!(kt = lookup_timer(handle))) {
319                         ast_test_status_update(test, "Could not find timer structure in container?!!\n");
320                         res = AST_TEST_FAIL;
321                         break;
322                 }
323                 if (kqueue_timer_get_event(handle) <= 0) {
324                         ast_test_status_update(test, "No events generated after a poll returned successfully?!!\n");
325                         res = AST_TEST_FAIL;
326                         break;
327                 }
328 #if 0
329                 if (kt->unacked == 0) {
330                         ast_test_status_update(test, "Unacked events is 0, but there should be at least 1.\n");
331                         res = AST_TEST_FAIL;
332                         break;
333                 }
334 #endif
335                 kqueue_timer_enable_continuous(handle);
336                 start = ast_tvnow();
337                 for (i = 0; i < 100; i++) {
338                         if (ast_poll(&pfd, 1, 1000) < 1) {
339                                 ast_test_status_update(test, "Polling on a kqueue doesn't work\n");
340                                 res = AST_TEST_FAIL;
341                                 break;
342                         }
343                         if (kqueue_timer_get_event(handle) <= 0) {
344                                 ast_test_status_update(test, "No events generated in continuous mode after 1 microsecond?!!\n");
345                                 res = AST_TEST_FAIL;
346                                 break;
347                         }
348                 }
349                 diff = ast_tvdiff_us(ast_tvnow(), start);
350                 ast_test_status_update(test, "diff is %llu\n", diff);
351                 /*
352                 if (abs(diff - kt->unacked) == 0) {
353                         ast_test_status_update(test, "Unacked events should be around 1000, not %llu\n", kt->unacked);
354                         res = AST_TEST_FAIL;
355                 }
356                 */
357         } while (0);
358         kqueue_timer_close(handle);
359         return res;
360 }
361 #endif
362
363 static int load_module(void)
364 {
365         if (!(kqueue_timers = ao2_container_alloc(563, kqueue_timer_hash, kqueue_timer_cmp))) {
366                 return AST_MODULE_LOAD_DECLINE;
367         }
368
369         if (!(timing_funcs_handle = ast_register_timing_interface(&kqueue_timing))) {
370                 ao2_ref(kqueue_timers, -1);
371                 return AST_MODULE_LOAD_DECLINE;
372         }
373
374         AST_TEST_REGISTER(test_kqueue_timing);
375         return AST_MODULE_LOAD_SUCCESS;
376 }
377
378 static int unload_module(void)
379 {
380         int res;
381
382         AST_TEST_UNREGISTER(test_kqueue_timing);
383         if (!(res = ast_unregister_timing_interface(timing_funcs_handle))) {
384                 ao2_ref(kqueue_timers, -1);
385                 kqueue_timers = NULL;
386         }
387
388         return res;
389 }
390
391 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "KQueue Timing Interface",
392                 .load = load_module,
393                 .unload = unload_module,
394                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
395                 );