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