sd-event: rename PASSIVE/PREPARED to INITIAL/ARMED

[elogind.git] / src / libsystemd / sd-event / sd-event.c

diff --git a/src/libsystemd/sd-event/sd-event.c b/src/libsystemd/sd-event/sd-event.c
index f0356a48e647f90711699daf7062852c00b5a595..2529a86233c247fcb271eedd97b0c4ffa518bac0 100644 (file)
--- a/src/libsystemd/sd-event/sd-event.c
+++ b/src/libsystemd/sd-event/sd-event.c
@@ -22,7 +22,6 @@
 #include <sys/epoll.h>
 #include <sys/timerfd.h>
 #include <sys/wait.h>
-#include <pthread.h>
 
 #include "sd-id128.h"
 #include "sd-daemon.h"
@@ -37,7 +36,6 @@
 
 #include "sd-event.h"
 
-#define EPOLL_QUEUE_MAX 512U
 #define DEFAULT_ACCURACY_USEC (250 * USEC_PER_MSEC)
 
 typedef enum EventSourceType {
@@ -463,7 +461,7 @@ _public_ sd_event* sd_event_unref(sd_event *e) {
 static bool event_pid_changed(sd_event *e) {
         assert(e);
 
-        /* We don't support people creating am event loop and keeping
+        /* We don't support people creating an event loop and keeping
          * it around over a fork(). Let's complain. */
 
         return e->original_pid != getpid();
@@ -891,6 +889,12 @@ static int event_setup_timer_fd(
         return 0;
 }
 
+static int time_exit_callback(sd_event_source *s, uint64_t usec, void *userdata) {
+        assert(s);
+
+        return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
+}
+
 _public_ int sd_event_add_time(
                 sd_event *e,
                 sd_event_source **ret,
@@ -908,12 +912,14 @@ _public_ int sd_event_add_time(
         assert_return(e, -EINVAL);
         assert_return(usec != (uint64_t) -1, -EINVAL);
         assert_return(accuracy != (uint64_t) -1, -EINVAL);
-        assert_return(callback, -EINVAL);
         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
         assert_return(!event_pid_changed(e), -ECHILD);
 
+        if (!callback)
+                callback = time_exit_callback;
+
         type = clock_to_event_source_type(clock);
-        assert_return(type >= 0, -ENOTSUP);
+        assert_return(type >= 0, -EOPNOTSUPP);
 
         d = event_get_clock_data(e, type);
         assert(d);
@@ -1031,6 +1037,9 @@ _public_ int sd_event_add_signal(
                 }
         }
 
+        /* Use the signal name as description for the event source by default */
+        (void) sd_event_source_set_description(s, signal_to_string(sig));
+
         if (ret)
                 *ret = s;
 
@@ -1255,6 +1264,7 @@ _public_ sd_event_source* sd_event_source_unref(sd_event_source *s) {
 
 _public_ int sd_event_source_set_description(sd_event_source *s, const char *description) {
         assert_return(s, -EINVAL);
+        assert_return(!event_pid_changed(s->event), -ECHILD);
 
         return free_and_strdup(&s->description, description);
 }
@@ -1262,6 +1272,8 @@ _public_ int sd_event_source_set_description(sd_event_source *s, const char *des
 _public_ int sd_event_source_get_description(sd_event_source *s, const char **description) {
         assert_return(s, -EINVAL);
         assert_return(description, -EINVAL);
+        assert_return(s->description, -ENXIO);
+        assert_return(!event_pid_changed(s->event), -ECHILD);
 
         *description = s->description;
         return 0;
@@ -2152,9 +2164,9 @@ static int source_dispatch(sd_event_source *s) {
 
         if (r < 0) {
                 if (s->description)
-                        log_debug("Event source '%s' returned error, disabling: %s", s->description, strerror(-r));
+                        log_debug_errno(r, "Event source '%s' returned error, disabling: %m", s->description);
                 else
-                        log_debug("Event source %p returned error, disabling: %s", s, strerror(-r));
+                        log_debug_errno(r, "Event source %p returned error, disabling: %m", s);
         }
 
         if (s->n_ref == 0)
@@ -2190,9 +2202,9 @@ static int event_prepare(sd_event *e) {
 
                 if (r < 0) {
                         if (s->description)
-                                log_debug("Prepare callback of event source '%s' returned error, disabling: %s", s->description, strerror(-r));
+                                log_debug_errno(r, "Prepare callback of event source '%s' returned error, disabling: %m", s->description);
                         else
-                                log_debug("Prepare callback of event source %p returned error, disabling: %s", s, strerror(-r));
+                                log_debug_errno(r, "Prepare callback of event source %p returned error, disabling: %m", s);
                 }
 
                 if (s->n_ref == 0)
@@ -2222,7 +2234,7 @@ static int dispatch_exit(sd_event *e) {
 
         r = source_dispatch(p);
 
-        e->state = SD_EVENT_PASSIVE;
+        e->state = SD_EVENT_INITIAL;
         sd_event_unref(e);
 
         return r;
@@ -2291,7 +2303,7 @@ _public_ int sd_event_prepare(sd_event *e) {
         assert_return(e, -EINVAL);
         assert_return(!event_pid_changed(e), -ECHILD);
         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
-        assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
+        assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
 
         if (e->exit_requested)
                 goto pending;
@@ -2325,15 +2337,15 @@ _public_ int sd_event_prepare(sd_event *e) {
         if (event_next_pending(e) || e->need_process_child)
                 goto pending;
 
-        e->state = SD_EVENT_PREPARED;
+        e->state = SD_EVENT_ARMED;
 
         return 0;
 
 pending:
-        e->state = SD_EVENT_PREPARED;
+        e->state = SD_EVENT_ARMED;
         r = sd_event_wait(e, 0);
         if (r == 0)
-                e->state = SD_EVENT_PREPARED;
+                e->state = SD_EVENT_ARMED;
 
         return r;
 }
@@ -2346,14 +2358,14 @@ _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
         assert_return(e, -EINVAL);
         assert_return(!event_pid_changed(e), -ECHILD);
         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
-        assert_return(e->state == SD_EVENT_PREPARED, -EBUSY);
+        assert_return(e->state == SD_EVENT_ARMED, -EBUSY);
 
         if (e->exit_requested) {
                 e->state = SD_EVENT_PENDING;
                 return 1;
         }
 
-        ev_queue_max = CLAMP(e->n_sources, 1U, EPOLL_QUEUE_MAX);
+        ev_queue_max = MAX(e->n_sources, 1u);
         ev_queue = newa(struct epoll_event, ev_queue_max);
 
         m = epoll_wait(e->epoll_fd, ev_queue, ev_queue_max,
@@ -2434,7 +2446,7 @@ _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
         r = 0;
 
 finish:
-        e->state = SD_EVENT_PASSIVE;
+        e->state = SD_EVENT_INITIAL;
 
         return r;
 }
@@ -2457,14 +2469,14 @@ _public_ int sd_event_dispatch(sd_event *e) {
 
                 e->state = SD_EVENT_RUNNING;
                 r = source_dispatch(p);
-                e->state = SD_EVENT_PASSIVE;
+                e->state = SD_EVENT_INITIAL;
 
                 sd_event_unref(e);
 
                 return r;
         }
 
-        e->state = SD_EVENT_PASSIVE;
+        e->state = SD_EVENT_INITIAL;
 
         return 1;
 }
@@ -2475,7 +2487,7 @@ _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
         assert_return(e, -EINVAL);
         assert_return(!event_pid_changed(e), -ECHILD);
         assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
-        assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
+        assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
 
         r = sd_event_prepare(e);
         if (r > 0)
@@ -2495,7 +2507,7 @@ _public_ int sd_event_loop(sd_event *e) {
 
         assert_return(e, -EINVAL);
         assert_return(!event_pid_changed(e), -ECHILD);
-        assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
+        assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
 
         sd_event_ref(e);