3e686f81054a4e6f8f73180e19aabdff0998b82e
[asterisk/asterisk.git] / res / res_timing_timerfd.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2008, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@digium.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 Mark Michelson <mmichelson@digium.com>
22  *
23  * \brief timerfd timing interface
24  */
25
26 /*** MODULEINFO
27         <depend>timerfd</depend>
28  ***/
29
30 #include "asterisk.h"
31
32 #include <sys/timerfd.h>
33
34 #include "asterisk/module.h"
35 #include "asterisk/astobj2.h"
36 #include "asterisk/timing.h"
37 #include "asterisk/logger.h"
38 #include "asterisk/utils.h"
39 #include "asterisk/time.h"
40
41 static void *timing_funcs_handle;
42
43 static int timerfd_timer_open(void);
44 static void timerfd_timer_close(int handle);
45 static int timerfd_timer_set_rate(int handle, unsigned int rate);
46 static void timerfd_timer_ack(int handle, unsigned int quantity);
47 static int timerfd_timer_enable_continuous(int handle);
48 static int timerfd_timer_disable_continuous(int handle);
49 static enum ast_timer_event timerfd_timer_get_event(int handle);
50 static unsigned int timerfd_timer_get_max_rate(int handle);
51
52 static struct ast_timing_interface timerfd_timing = {
53         .name = "timerfd",
54         .priority = 200,
55         .timer_open = timerfd_timer_open,
56         .timer_close = timerfd_timer_close,
57         .timer_set_rate = timerfd_timer_set_rate,
58         .timer_ack = timerfd_timer_ack,
59         .timer_enable_continuous = timerfd_timer_enable_continuous,
60         .timer_disable_continuous = timerfd_timer_disable_continuous,
61         .timer_get_event = timerfd_timer_get_event,
62         .timer_get_max_rate = timerfd_timer_get_max_rate,
63 };
64
65 static struct ao2_container *timerfd_timers;
66
67 #define TIMERFD_TIMER_BUCKETS 563
68 #define TIMERFD_MAX_RATE 1000
69
70 struct timerfd_timer {
71         int handle;
72         struct itimerspec saved_timer;
73         unsigned int is_continuous:1;
74 };
75
76 static int timerfd_timer_hash(const void *obj, const int flags)
77 {
78         const struct timerfd_timer *timer = obj;
79
80         return timer->handle;
81 }
82
83 static int timerfd_timer_cmp(void *obj, void *args, int flags)
84 {
85         struct timerfd_timer *timer1 = obj, *timer2 = args;
86         return timer1->handle == timer2->handle ? CMP_MATCH | CMP_STOP : 0;
87 }
88
89 static void timer_destroy(void *obj)
90 {
91         struct timerfd_timer *timer = obj;
92         close(timer->handle);
93 }
94
95 static int timerfd_timer_open(void)
96 {
97         struct timerfd_timer *timer;
98         int handle;
99
100         if (!(timer = ao2_alloc(sizeof(*timer), timer_destroy))) {
101                 ast_log(LOG_ERROR, "Could not allocate memory for timerfd_timer structure\n");
102                 return -1;
103         }
104         if ((handle = timerfd_create(CLOCK_MONOTONIC, 0)) < 0) {
105                 ast_log(LOG_ERROR, "Failed to create timerfd timer: %s\n", strerror(errno));
106                 ao2_ref(timer, -1);
107                 return -1;
108         }
109
110         timer->handle = handle;
111         ao2_link(timerfd_timers, timer);
112         /* Get rid of the reference from the allocation */
113         ao2_ref(timer, -1);
114         return handle;
115 }
116
117 static void timerfd_timer_close(int handle)
118 {
119         struct timerfd_timer *our_timer, find_helper = {
120                 .handle = handle,
121         };
122
123         if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) {
124                 ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
125                 return;
126         }
127
128         ao2_unlink(timerfd_timers, our_timer);
129         ao2_ref(our_timer, -1);
130 }
131
132 static int timerfd_timer_set_rate(int handle, unsigned int rate)
133 {
134         struct timerfd_timer *our_timer, find_helper = {
135                 .handle = handle,
136         };
137         int res = 0;
138
139         if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) {
140                 ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
141                 return -1;
142         }
143         ao2_lock(our_timer);
144
145         our_timer->saved_timer.it_value.tv_sec = 0;
146         our_timer->saved_timer.it_value.tv_nsec = rate ? (long) (1000000000 / rate) : 0L;
147         our_timer->saved_timer.it_interval.tv_sec = our_timer->saved_timer.it_value.tv_sec;
148         our_timer->saved_timer.it_interval.tv_nsec = our_timer->saved_timer.it_value.tv_nsec;
149
150         if (!our_timer->is_continuous) {
151                 res = timerfd_settime(handle, 0, &our_timer->saved_timer, NULL);
152         }
153
154         ao2_unlock(our_timer);
155         ao2_ref(our_timer, -1);
156
157         return res;
158 }
159
160 static void timerfd_timer_ack(int handle, unsigned int quantity)
161 {
162         uint64_t expirations;
163         int read_result = 0;
164
165         struct timerfd_timer *our_timer, find_helper = {
166                 .handle = handle,
167         };
168
169         if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) {
170                 ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
171                 return;
172         }
173
174         if (our_timer->saved_timer.it_value.tv_nsec == 0L) {
175                 ast_log(LOG_DEBUG, "Reading attempt on idle timerfd.\n");
176                 return;
177         }
178
179         do {
180                 struct itimerspec timer_status;
181
182                 if (timerfd_gettime(handle, &timer_status)) {
183                         ast_log(LOG_ERROR, "Call to timerfd_gettime() error: %s\n", strerror(errno));
184                         expirations = 0;
185                         break;
186                 }
187
188                 if ((timer_status.it_value.tv_sec == 0) && (timer_status.it_value.tv_nsec == 0)) {
189                         ast_log(LOG_DEBUG, "Call to timerfd_timer_ack() with disarmed timer - break now.\n");
190                         expirations = 0;
191                         break;
192                 }
193
194                 read_result = read(handle, &expirations, sizeof(expirations));
195                 if (read_result == -1) {
196                         if (errno == EINTR || errno == EAGAIN) {
197                                 continue;
198                         } else {
199                                 ast_log(LOG_ERROR, "Read error: %s\n", strerror(errno));
200                                 break;
201                         }
202                 }
203         } while (read_result != sizeof(expirations));
204
205         if (expirations != quantity) {
206                 ast_debug(2, "Expected to acknowledge %u ticks but got %llu instead\n", quantity, (unsigned long long) expirations);
207         }
208 }
209
210 static int timerfd_timer_enable_continuous(int handle)
211 {
212         int res;
213         struct itimerspec continuous_timer = {
214                 .it_value.tv_nsec = 1L,
215         };
216         struct timerfd_timer *our_timer, find_helper = {
217                 .handle = handle,
218         };
219
220         if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) {
221                 ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
222                 return -1;
223         }
224         ao2_lock(our_timer);
225
226         if (our_timer->is_continuous) {
227                 /*It's already in continous mode, no need to do
228                  * anything further
229                  */
230                 ao2_unlock(our_timer);
231                 ao2_ref(our_timer, -1);
232                 return 0;
233         }
234
235         res = timerfd_settime(handle, 0, &continuous_timer, &our_timer->saved_timer);
236         our_timer->is_continuous = 1;
237         ao2_unlock(our_timer);
238         ao2_ref(our_timer, -1);
239         return res;
240 }
241
242 static int timerfd_timer_disable_continuous(int handle)
243 {
244         int res;
245         struct timerfd_timer *our_timer, find_helper = {
246                 .handle = handle,
247         };
248
249         if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) {
250                 ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
251                 return -1;
252         }
253         ao2_lock(our_timer);
254
255         if(!our_timer->is_continuous) {
256                 /* No reason to do anything if we're not
257                  * in continuous mode
258                  */
259                 ao2_unlock(our_timer);
260                 ao2_ref(our_timer, -1);
261                 return 0;
262         }
263
264         res = timerfd_settime(handle, 0, &our_timer->saved_timer, NULL);
265         our_timer->is_continuous = 0;
266         memset(&our_timer->saved_timer, 0, sizeof(our_timer->saved_timer));
267         ao2_unlock(our_timer);
268         ao2_ref(our_timer, -1);
269         return res;
270 }
271
272 static enum ast_timer_event timerfd_timer_get_event(int handle)
273 {
274         enum ast_timer_event res;
275         struct timerfd_timer *our_timer, find_helper = {
276                 .handle = handle,
277         };
278
279         if (!(our_timer = ao2_find(timerfd_timers, &find_helper, OBJ_POINTER))) {
280                 ast_log(LOG_ERROR, "Couldn't find timer with handle %d\n", handle);
281                 return -1;
282         }
283         ao2_lock(our_timer);
284
285         if (our_timer->is_continuous) {
286                 res = AST_TIMING_EVENT_CONTINUOUS;
287         } else {
288                 res = AST_TIMING_EVENT_EXPIRED;
289         }
290
291         ao2_unlock(our_timer);
292         ao2_ref(our_timer, -1);
293         return res;
294 }
295
296 static unsigned int timerfd_timer_get_max_rate(int handle)
297 {
298         return TIMERFD_MAX_RATE;
299 }
300
301 static int load_module(void)
302 {
303         int fd;
304
305         /* Make sure we support the necessary clock type */
306         if ((fd = timerfd_create(CLOCK_MONOTONIC, 0)) < 0) {
307                 ast_log(LOG_ERROR, "timerfd_create() not supported by the kernel.  Not loading.\n");
308                 return AST_MODULE_LOAD_DECLINE;
309         }
310
311         close(fd);
312
313         if (!(timerfd_timers = ao2_container_alloc(TIMERFD_TIMER_BUCKETS, timerfd_timer_hash, timerfd_timer_cmp))) {
314                 return AST_MODULE_LOAD_DECLINE;
315         }
316
317         if (!(timing_funcs_handle = ast_register_timing_interface(&timerfd_timing))) {
318                 ao2_ref(timerfd_timers, -1);
319                 return AST_MODULE_LOAD_DECLINE;
320         }
321
322         return AST_MODULE_LOAD_SUCCESS;
323 }
324
325 static int unload_module(void)
326 {
327         int res;
328
329         if (!(res = ast_unregister_timing_interface(timing_funcs_handle))) {
330                 ao2_ref(timerfd_timers, -1);
331                 timerfd_timers = NULL;
332         }
333
334         return res;
335 }
336
337 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Timerfd Timing Interface",
338                 .load = load_module,
339                 .unload = unload_module,
340                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
341                 );