Merge "chan_ooh323: fix h323 log file path"
[asterisk/asterisk.git] / res / res_timing_kqueue.c
index b5bc01f..f568144 100644 (file)
 
 static void *timing_funcs_handle;
 
-static int kqueue_timer_open(void);
-static void kqueue_timer_close(int handle);
-static int kqueue_timer_set_rate(int handle, unsigned int rate);
-static int kqueue_timer_ack(int handle, unsigned int quantity);
-static int kqueue_timer_enable_continuous(int handle);
-static int kqueue_timer_disable_continuous(int handle);
-static enum ast_timer_event kqueue_timer_get_event(int handle);
-static unsigned int kqueue_timer_get_max_rate(int handle);
+static void *kqueue_timer_open(void);
+static void kqueue_timer_close(void *data);
+static int kqueue_timer_set_rate(void *data, unsigned int rate);
+static int kqueue_timer_ack(void *data, unsigned int quantity);
+static int kqueue_timer_enable_continuous(void *data);
+static int kqueue_timer_disable_continuous(void *data);
+static enum ast_timer_event kqueue_timer_get_event(void *data);
+static unsigned int kqueue_timer_get_max_rate(void *data);
+static int kqueue_timer_fd(void *data);
 
 static struct ast_timing_interface kqueue_timing = {
        .name = "kqueue",
@@ -68,222 +69,333 @@ static struct ast_timing_interface kqueue_timing = {
        .timer_disable_continuous = kqueue_timer_disable_continuous,
        .timer_get_event = kqueue_timer_get_event,
        .timer_get_max_rate = kqueue_timer_get_max_rate,
+       .timer_fd = kqueue_timer_fd,
 };
 
-static struct ao2_container *kqueue_timers;
-
 struct kqueue_timer {
+       intptr_t period;
        int handle;
-       uint64_t nsecs;
-       uint64_t unacked;
+#ifndef EVFILT_USER
+       int continuous_fd;
+       unsigned int continuous_fd_valid:1;
+#endif
        unsigned int is_continuous:1;
 };
 
-static int kqueue_timer_hash(const void *obj, const int flags)
+#ifdef EVFILT_USER
+#define CONTINUOUS_EVFILT_TYPE EVFILT_USER
+static int kqueue_timer_init_continuous_event(struct kqueue_timer *timer)
+{
+       return 0;
+}
+
+static int kqueue_timer_enable_continuous_event(struct kqueue_timer *timer)
 {
-       const struct kqueue_timer *timer = obj;
+       struct kevent kev[2];
 
-       return timer->handle;
+       EV_SET(&kev[0], (uintptr_t)timer, EVFILT_USER, EV_ADD | EV_ENABLE,
+               0, 0, NULL);
+       EV_SET(&kev[1], (uintptr_t)timer, EVFILT_USER, 0, NOTE_TRIGGER,
+               0, NULL);
+       return kevent(timer->handle, kev, 2, NULL, 0, NULL);
 }
 
-static int kqueue_timer_cmp(void *obj, void *args, int flags)
+static int kqueue_timer_disable_continuous_event(struct kqueue_timer *timer)
 {
-       struct kqueue_timer *timer1 = obj, *timer2 = args;
-       return timer1->handle == timer2->handle ? CMP_MATCH | CMP_STOP : 0;
+       struct kevent kev;
+
+       EV_SET(&kev, (uintptr_t)timer, EVFILT_USER, EV_DELETE, 0, 0, NULL);
+       return kevent(timer->handle, &kev, 1, NULL, 0, NULL);
 }
 
-static void timer_destroy(void *obj)
+static void kqueue_timer_fini_continuous_event(struct kqueue_timer *timer)
 {
-       struct kqueue_timer *timer = obj;
-       close(timer->handle);
 }
 
-#define lookup_timer(a)        _lookup_timer(a, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-static struct kqueue_timer *_lookup_timer(int handle, const char *file, int line, const char *func)
+#else /* EVFILT_USER */
+
+#define CONTINUOUS_EVFILT_TYPE EVFILT_READ
+static int kqueue_timer_init_continuous_event(struct kqueue_timer *timer)
 {
-       struct kqueue_timer *our_timer, find_helper = {
-               .handle = handle,
-       };
-
-       if (!(our_timer = ao2_find(kqueue_timers, &find_helper, OBJ_POINTER))) {
-               ast_log(__LOG_ERROR, file, line, func, "Couldn't find timer with handle %d\n", handle);
-               /* API says we set errno */
-               errno = ESRCH;
-               return NULL;
+       int pipefds[2];
+       int retval;
+
+       retval = pipe(pipefds);
+       if (retval == 0) {
+               timer->continuous_fd = pipefds[0];
+               timer->continuous_fd_valid = 1;
+               close(pipefds[1]);
        }
-       return our_timer;
+       return retval;
 }
 
-static int kqueue_timer_open(void)
+static void kqueue_timer_fini_continuous_event(struct kqueue_timer *timer)
+{
+       if (timer->continuous_fd_valid) {
+               close(timer->continuous_fd);
+       }
+}
+
+static int kqueue_timer_enable_continuous_event(struct kqueue_timer *timer)
+{
+       struct kevent kev;
+
+       EV_SET(&kev, timer->continuous_fd, EVFILT_READ, EV_ADD | EV_ENABLE,
+               0, 0, NULL);
+       return kevent(timer->handle, &kev, 1, NULL, 0, NULL);
+}
+
+static int kqueue_timer_disable_continuous_event(struct kqueue_timer *timer)
+{
+       struct kevent kev;
+
+       EV_SET(&kev, timer->continuous_fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
+       return kevent(timer->handle, &kev, 1, NULL, 0, NULL);
+}
+#endif
+
+static void timer_destroy(void *obj)
+{
+       struct kqueue_timer *timer = obj;
+       ast_debug(5, "[%d]: Timer Destroy\n", timer->handle);
+       kqueue_timer_fini_continuous_event(timer);
+       if (timer->handle > -1) {
+               close(timer->handle);
+       }
+}
+
+static void *kqueue_timer_open(void)
 {
        struct kqueue_timer *timer;
-       int handle;
 
        if (!(timer = ao2_alloc(sizeof(*timer), timer_destroy))) {
-               ast_log(LOG_ERROR, "Could not allocate memory for kqueue_timer structure\n");
-               return -1;
+               ast_log(LOG_ERROR, "Alloc failed for kqueue_timer structure\n");
+               return NULL;
        }
-       if ((handle = kqueue()) < 0) {
-               ast_log(LOG_ERROR, "Failed to create kqueue timer: %s\n", strerror(errno));
+
+       if ((timer->handle = kqueue()) < 0) {
+               ast_log(LOG_ERROR, "Failed to create kqueue fd: %s\n",
+                       strerror(errno));
                ao2_ref(timer, -1);
-               return -1;
+               return NULL;
        }
 
-       timer->handle = handle;
-       ao2_link(kqueue_timers, timer);
-       /* Get rid of the reference from the allocation */
-       ao2_ref(timer, -1);
-       return handle;
+       if (kqueue_timer_init_continuous_event(timer) != 0) {
+               ast_log(LOG_ERROR, "Failed to create continuous event: %s\n",
+                       strerror(errno));
+               ao2_ref(timer, -1);
+               return NULL;
+       }
+       ast_debug(5, "[%d]: Create timer\n", timer->handle);
+       return timer;
 }
 
-static void kqueue_timer_close(int handle)
+static void kqueue_timer_close(void *data)
 {
-       struct kqueue_timer *our_timer;
-
-       if (!(our_timer = lookup_timer(handle))) {
-               return;
-       }
+       struct kqueue_timer *timer = data;
 
-       ao2_unlink(kqueue_timers, our_timer);
-       ao2_ref(our_timer, -1);
+       ast_debug(5, "[%d]: Timer Close\n", timer->handle);
+       ao2_ref(timer, -1);
 }
 
-static void kqueue_set_nsecs(struct kqueue_timer *our_timer, uint64_t nsecs)
+/*
+ * Use the highest precision available that does not overflow
+ * the datatype kevent is using for time.
+ */
+static intptr_t kqueue_scale_period(unsigned int period_ns, int *units)
 {
-       struct timespec nowait = { 0, 1 };
-#ifdef HAVE_KEVENT64
-       struct kevent64_s kev;
-
-       EV_SET64(&kev, our_timer->handle, EVFILT_TIMER, EV_ADD | EV_ENABLE, NOTE_NSECONDS,
-               nsecs, 0, 0, 0);
-       kevent64(our_timer->handle, &kev, 1, NULL, 0, 0, &nowait);
-#else
-       struct kevent kev;
-
-       EV_SET(&kev, our_timer->handle, EVFILT_TIMER, EV_ADD | EV_ENABLE,
+       uint64_t period = period_ns;
+       *units = 0;
 #ifdef NOTE_NSECONDS
-               nsecs <= 0xFFffFFff ? NOTE_NSECONDS :
-#endif
-#ifdef NOTE_USECONDS
-               NOTE_USECONDS
-#else /* Milliseconds, if no constants are defined */
-               0
-#endif
-               ,
-#ifdef NOTE_NSECONDS
-               nsecs <= 0xFFffFFff ? nsecs :
-#endif
+       if (period < INTPTR_MAX) {
+               *units = NOTE_NSECONDS;
+       } else {
 #ifdef NOTE_USECONDS
-       nsecs / 1000
-#else /* Milliseconds, if nothing else is defined */
-       nsecs / 1000000
-#endif
-       , NULL);
-       kevent(our_timer->handle, &kev, 1, NULL, 0, &nowait);
+               period /= 1000;
+               if (period < INTPTR_MAX) {
+                       *units = NOTE_USECONDS;
+               } else {
+                       period /= 1000;
+#ifdef NOTE_MSECONDS
+                       *units = NOTE_MSECONDS;
+#endif /* NOTE_MSECONDS */
+               }
+#else  /* NOTE_USECONDS */
+               period /= 1000000;
+#ifdef NOTE_MSECONDS
+               *units = NOTE_MSECONDS;
+#endif /* NOTE_MSECONDS */
+#endif /* NOTE_USECONDS */
+       }
+#else  /* NOTE_NSECONDS */
+       period /= 1000000;
 #endif
+       if (period > INTPTR_MAX) {
+               period = INTPTR_MAX;
+       }
+       return period;
 }
 
-static int kqueue_timer_set_rate(int handle, unsigned int rate)
+static int kqueue_timer_set_rate(void *data, unsigned int rate)
 {
-       struct kqueue_timer *our_timer;
-
-       if (!(our_timer = lookup_timer(handle))) {
-               return -1;
+       struct kevent kev;
+       struct kqueue_timer *timer = data;
+       uint64_t period_ns;
+       int flags;
+       int units;
+       int retval;
+
+       ao2_lock(timer);
+
+       if (rate == 0) {
+               if (timer->period == 0) {
+                       ao2_unlock(timer);
+                       return (0);
+               }
+               flags = EV_DELETE;
+               timer->period = 0;
+               units = 0;
+       } else  {
+               flags = EV_ADD | EV_ENABLE;
+               period_ns = (uint64_t)1000000000 / rate;
+               timer->period = kqueue_scale_period(period_ns, &units);
+       }
+       ast_debug(5, "[%d]: Set rate %u:%ju\n",
+               timer->handle, units, (uintmax_t)timer->period);
+       EV_SET(&kev, timer->handle, EVFILT_TIMER, flags, units,
+               timer->period, NULL);
+       retval = kevent(timer->handle, &kev, 1, NULL, 0, NULL);
+
+       if (retval == -1) {
+               ast_log(LOG_ERROR, "[%d]: Error queing timer: %s\n",
+                       timer->handle, strerror(errno));
        }
 
-       kqueue_set_nsecs(our_timer, (our_timer->nsecs = rate ? (long) (1000000000 / rate) : 0L));
-       ao2_ref(our_timer, -1);
+       ao2_unlock(timer);
 
        return 0;
 }
 
-static int kqueue_timer_ack(int handle, unsigned int quantity)
+static int kqueue_timer_ack(void *data, unsigned int quantity)
 {
-       struct kqueue_timer *our_timer;
-
-       if (!(our_timer = lookup_timer(handle))) {
+       static struct timespec ts_nowait = { 0, 0 };
+       struct kqueue_timer *timer = data;
+       struct kevent kev[2];
+       int i, retval;
+
+       ao2_lock(timer);
+
+       retval = kevent(timer->handle, NULL, 0, kev, 2, &ts_nowait);
+       if (retval == -1) {
+               ast_log(LOG_ERROR, "[%d]: Error sampling kqueue: %s\n",
+                       timer->handle, strerror(errno));
+               ao2_unlock(timer);
                return -1;
        }
 
-       if (our_timer->unacked < quantity) {
-               ast_debug(1, "Acking more events than have expired?!!\n");
-               our_timer->unacked = 0;
-               ao2_ref(our_timer, -1);
-               return -1;
-       } else {
-               our_timer->unacked -= quantity;
+       for (i = 0; i < retval; i++) {
+               switch (kev[i].filter) {
+               case EVFILT_TIMER:
+                       if (kev[i].data > quantity) {
+                               ast_log(LOG_ERROR, "[%d]: Missed %ju\n",
+                                       timer->handle,
+                                       (uintmax_t)kev[i].data - quantity);
+                       }
+                       break;
+               case CONTINUOUS_EVFILT_TYPE:
+                       if (!timer->is_continuous) {
+                               ast_log(LOG_ERROR,
+                                       "[%d]: Spurious user event\n",
+                                       timer->handle);
+                       }
+                       break;
+               default:
+                       ast_log(LOG_ERROR, "[%d]: Spurious kevent type %d.\n",
+                               timer->handle, kev[i].filter);
+               }
        }
 
-       ao2_ref(our_timer, -1);
+       ao2_unlock(timer);
+
        return 0;
 }
 
-static int kqueue_timer_enable_continuous(int handle)
+static int kqueue_timer_enable_continuous(void *data)
 {
-       struct kqueue_timer *our_timer;
-
-       if (!(our_timer = lookup_timer(handle))) {
-               return -1;
+       struct kqueue_timer *timer = data;
+       int retval;
+
+       ao2_lock(timer);
+
+       if (!timer->is_continuous) {
+               ast_debug(5, "[%d]: Enable Continuous\n", timer->handle);
+               retval = kqueue_timer_enable_continuous_event(timer);
+               if (retval == -1) {
+                       ast_log(LOG_ERROR,
+                               "[%d]: Error signaling continuous event: %s\n",
+                               timer->handle, strerror(errno));
+               }
+               timer->is_continuous = 1;
        }
 
-       kqueue_set_nsecs(our_timer, 1);
-       our_timer->is_continuous = 1;
-       our_timer->unacked = 0;
-       ao2_ref(our_timer, -1);
+       ao2_unlock(timer);
+
        return 0;
 }
 
-static int kqueue_timer_disable_continuous(int handle)
+static int kqueue_timer_disable_continuous(void *data)
 {
-       struct kqueue_timer *our_timer;
-
-       if (!(our_timer = lookup_timer(handle))) {
-               return -1;
+       struct kqueue_timer *timer = data;
+       int retval;
+
+       ao2_lock(timer);
+
+       if (timer->is_continuous) {
+               ast_debug(5, "[%d]: Disable Continuous\n", timer->handle);
+               retval = kqueue_timer_disable_continuous_event(timer);
+               if (retval == -1) {
+                       ast_log(LOG_ERROR,
+                               "[%d]: Error clearing continuous event: %s\n",
+                               timer->handle, strerror(errno));
+               }
+               timer->is_continuous = 0;
        }
 
-       kqueue_set_nsecs(our_timer, our_timer->nsecs);
-       our_timer->is_continuous = 0;
-       our_timer->unacked = 0;
-       ao2_ref(our_timer, -1);
+       ao2_unlock(timer);
+
        return 0;
 }
 
-static enum ast_timer_event kqueue_timer_get_event(int handle)
+static enum ast_timer_event kqueue_timer_get_event(void *data)
 {
-       enum ast_timer_event res = -1;
-       struct kqueue_timer *our_timer;
-       struct timespec sixty_seconds = { 60, 0 };
-       struct kevent kev;
-
-       if (!(our_timer = lookup_timer(handle))) {
-               return -1;
-       }
+       struct kqueue_timer *timer = data;
+       enum ast_timer_event res;
 
-       /* If we have non-ACKed events, just return immediately */
-       if (our_timer->unacked == 0) {
-               if (kevent(handle, NULL, 0, &kev, 1, &sixty_seconds) > 0) {
-                       our_timer->unacked += kev.data;
-               }
-       }
-
-       if (our_timer->unacked > 0) {
-               res = our_timer->is_continuous ? AST_TIMING_EVENT_CONTINUOUS : AST_TIMING_EVENT_EXPIRED;
+       if (timer->is_continuous) {
+               res = AST_TIMING_EVENT_CONTINUOUS;
+       } else {
+               res = AST_TIMING_EVENT_EXPIRED;
        }
 
-       ao2_ref(our_timer, -1);
        return res;
 }
 
-static unsigned int kqueue_timer_get_max_rate(int handle)
+static unsigned int kqueue_timer_get_max_rate(void *data)
+{
+       return INTPTR_MAX > UINT_MAX ? UINT_MAX : INTPTR_MAX;
+}
+
+static int kqueue_timer_fd(void *data)
 {
-       /* Actually, the max rate is 2^64-1 seconds, but that's not representable in a 32-bit integer. */
-       return UINT_MAX;
+       struct kqueue_timer *timer = data;
+
+       return timer->handle;
 }
 
 #ifdef TEST_FRAMEWORK
 AST_TEST_DEFINE(test_kqueue_timing)
 {
-       int res = AST_TEST_PASS, handle, i;
+       int res = AST_TEST_PASS, i;
        uint64_t diff;
        struct pollfd pfd = { 0, POLLIN, 0 };
        struct kqueue_timer *kt;
@@ -300,14 +412,14 @@ AST_TEST_DEFINE(test_kqueue_timing)
                break;
        }
 
-       if (!(handle = kqueue_timer_open())) {
+       if (!(kt = kqueue_timer_open())) {
                ast_test_status_update(test, "Cannot open timer!\n");
                return AST_TEST_FAIL;
        }
 
        do {
-               pfd.fd = handle;
-               if (kqueue_timer_set_rate(handle, 1000)) {
+               pfd.fd = kqueue_timer_fd(kt);
+               if (kqueue_timer_set_rate(kt, 1000)) {
                        ast_test_status_update(test, "Cannot set timer rate to 1000/s\n");
                        res = AST_TEST_FAIL;
                        break;
@@ -322,24 +434,18 @@ AST_TEST_DEFINE(test_kqueue_timing)
                        res = AST_TEST_FAIL;
                        break;
                }
-               if (!(kt = lookup_timer(handle))) {
-                       ast_test_status_update(test, "Could not find timer structure in container?!!\n");
-                       res = AST_TEST_FAIL;
-                       break;
-               }
-               if (kqueue_timer_get_event(handle) <= 0) {
+               if (kqueue_timer_get_event(kt) <= 0) {
                        ast_test_status_update(test, "No events generated after a poll returned successfully?!!\n");
                        res = AST_TEST_FAIL;
                        break;
                }
-#if 0
-               if (kt->unacked == 0) {
-                       ast_test_status_update(test, "Unacked events is 0, but there should be at least 1.\n");
+               if (kqueue_timer_ack(kt, 1) != 0) {
+                       ast_test_status_update(test, "Acking event failed.\n");
                        res = AST_TEST_FAIL;
                        break;
                }
-#endif
-               kqueue_timer_enable_continuous(handle);
+
+               kqueue_timer_enable_continuous(kt);
                start = ast_tvnow();
                for (i = 0; i < 100; i++) {
                        if (ast_poll(&pfd, 1, 1000) < 1) {
@@ -347,22 +453,22 @@ AST_TEST_DEFINE(test_kqueue_timing)
                                res = AST_TEST_FAIL;
                                break;
                        }
-                       if (kqueue_timer_get_event(handle) <= 0) {
+                       if (kqueue_timer_get_event(kt) <= 0) {
                                ast_test_status_update(test, "No events generated in continuous mode after 1 microsecond?!!\n");
                                res = AST_TEST_FAIL;
                                break;
                        }
+                       if (kqueue_timer_ack(kt, 1) != 0) {
+                               ast_test_status_update(test, "Acking event failed.\n");
+                               res = AST_TEST_FAIL;
+                               break;
+                       }
+
                }
                diff = ast_tvdiff_us(ast_tvnow(), start);
                ast_test_status_update(test, "diff is %llu\n", diff);
-               /*
-               if (abs(diff - kt->unacked) == 0) {
-                       ast_test_status_update(test, "Unacked events should be around 1000, not %llu\n", kt->unacked);
-                       res = AST_TEST_FAIL;
-               }
-               */
        } while (0);
-       kqueue_timer_close(handle);
+       kqueue_timer_close(kt);
        return res;
 }
 #endif
@@ -373,18 +479,13 @@ AST_TEST_DEFINE(test_kqueue_timing)
  * Module loading including tests for configuration or dependencies.
  * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
  * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
- * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the 
- * configuration file or other non-critical problem return 
+ * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
+ * configuration file or other non-critical problem return
  * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
  */
 static int load_module(void)
 {
-       if (!(kqueue_timers = ao2_container_alloc(563, kqueue_timer_hash, kqueue_timer_cmp))) {
-               return AST_MODULE_LOAD_DECLINE;
-       }
-
        if (!(timing_funcs_handle = ast_register_timing_interface(&kqueue_timing))) {
-               ao2_ref(kqueue_timers, -1);
                return AST_MODULE_LOAD_DECLINE;
        }
 
@@ -394,19 +495,14 @@ static int load_module(void)
 
 static int unload_module(void)
 {
-       int res;
-
        AST_TEST_UNREGISTER(test_kqueue_timing);
-       if (!(res = ast_unregister_timing_interface(timing_funcs_handle))) {
-               ao2_ref(kqueue_timers, -1);
-               kqueue_timers = NULL;
-       }
 
-       return res;
+       return ast_unregister_timing_interface(timing_funcs_handle);
 }
 
 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "KQueue Timing Interface",
-               .load = load_module,
-               .unload = unload_module,
-               .load_pri = AST_MODPRI_CHANNEL_DEPEND,
-               );
+       .support_level = AST_MODULE_SUPPORT_EXTENDED,
+       .load = load_module,
+       .unload = unload_module,
+       .load_pri = AST_MODPRI_CHANNEL_DEPEND,
+);