Clean up main loop child and timer code, and deprecate their public API

daemons/attrd/attrd_attributes.c

@@ -30,6 +30,8 @@ attrd_create_attribute(xmlNode *xml)
     const char *dampen_s = pcmk__xe_get(xml, PCMK__XA_ATTR_DAMPENING);
     attribute_t *a = NULL;
 
+    pcmk__assert(name != NULL);
+
     if (set_type == NULL) {
         set_type = PCMK_XE_INSTANCE_ATTRIBUTES;
     }
@@ -97,7 +99,7 @@ attrd_update_dampening(attribute_t *a, xmlNode *xml, const char *attr)
     }
 
     if (a->timeout_ms != dampen) {
-        mainloop_timer_del(a->timer);
+        pcmk__main_loop_timer_free(a->timer);
         a->timeout_ms = (int) QB_MIN(dampen, INT_MAX);
         if (dampen > 0) {
             a->timer = attrd_add_timer(attr, a->timeout_ms, a);

daemons/attrd/attrd_cib.c

@@ -240,7 +240,7 @@ attribute_timer_cb(void *data)
     attribute_t *a = data;
     pcmk__trace("Dampen interval expired for %s", a->id);
     attrd_write_or_elect_attribute(a);
-    return FALSE;
+    return G_SOURCE_REMOVE;
 }
 
 static void
@@ -270,7 +270,7 @@ attrd_cib_callback(xmlNode *msg, int call_id, int rc, xmlNode *output, void *use
             last_cib_op_done = call_id;
             if (a->timer && !a->timeout_ms) {
                 // Remove temporary dampening for failed writes
-                g_clear_pointer(&a->timer, mainloop_timer_del);
+                g_clear_pointer(&a->timer, pcmk__main_loop_timer_free);
             }
             break;
 
@@ -319,18 +319,18 @@ attrd_cib_callback(xmlNode *msg, int call_id, int rc, xmlNode *output, void *use
          */
         } else if (a->timer) {
             // Attribute has a dampening value, so use that as delay
-            if (!mainloop_timer_running(a->timer)) {
+            if (!pcmk__main_loop_timer_running(a->timer)) {
                 pcmk__trace("Delayed re-attempted write for %s by %s",
                             name, pcmk__readable_interval(a->timeout_ms));
-                mainloop_timer_start(a->timer);
+                pcmk__main_loop_timer_start(a->timer);
             }
         } else {
             /* Set a temporary dampening of 2 seconds (timer will continue
              * to exist until the attribute's dampening gets set or the
              * write succeeds).
              */
             a->timer = attrd_add_timer(a->id, 2000, a);
-            mainloop_timer_start(a->timer);
+            pcmk__main_loop_timer_start(a->timer);
         }
     }
 }
@@ -489,10 +489,10 @@ set_alert_attribute_value(GHashTable *t, attribute_value_t *v)
     g_hash_table_replace(t, a_v->nodename, a_v);
 }
 
-mainloop_timer_t *
+pcmk__main_loop_timer_t *
 attrd_add_timer(const char *id, int timeout_ms, attribute_t *attr)
 {
-   return mainloop_timer_add(id, timeout_ms, FALSE, attribute_timer_cb, attr);
+   return pcmk__main_loop_timer_new(id, timeout_ms, attribute_timer_cb, attr);
 }
 
 /*!
@@ -536,9 +536,9 @@ write_attribute(attribute_t *a, bool ignore_delay)
                        a->id, a->update);
             goto done;
 
-        } else if (mainloop_timer_running(a->timer)) {
+        } else if (pcmk__main_loop_timer_running(a->timer)) {
             if (ignore_delay) {
-                mainloop_timer_stop(a->timer);
+                pcmk__main_loop_timer_stop(a->timer);
                 pcmk__debug("Overriding '%s' write delay", a->id);
             } else {
                 pcmk__info("Delaying write of '%s'", a->id);

daemons/attrd/attrd_corosync.c

@@ -361,7 +361,7 @@ update_attr_on_host(attribute_t *a, const pcmk__node_status_t *peer,
         if (a->timeout_ms && a->timer) {
             pcmk__trace("Delaying write of %s %s for dampening", attr,
                         pcmk__readable_interval(a->timeout_ms));
-            mainloop_timer_start(a->timer);
+            pcmk__main_loop_timer_start(a->timer);
         } else {
             attrd_write_or_elect_attribute(a);
         }

daemons/attrd/attrd_sync.c

@@ -66,7 +66,7 @@ struct confirmation_action {
      * \brief A timer that will be used to remove the client should it time out
      *        before receiving all confirmations
      */
-    mainloop_timer_t *timer;
+    pcmk__main_loop_timer_t *timer;
 
     /*!
      * \brief A function to run when all confirmations have been received
@@ -341,7 +341,7 @@ free_action(void *data)
 {
     struct confirmation_action *action = (struct confirmation_action *) data;
     g_list_free_full(action->respondents, free);
-    mainloop_timer_del(action->timer);
+    pcmk__main_loop_timer_free(action->timer);
     pcmk__xml_free(action->xml);
     free(action->client_id);
     free(action);
@@ -513,8 +513,9 @@ attrd_expect_confirmations(pcmk__request_t *request, attrd_confirmation_action_f
     action->ipc_id = request->ipc_id;
     action->flags = request->flags;
 
-    action->timer = mainloop_timer_add(NULL, 15000, FALSE, confirmation_timeout_cb, action);
-    mainloop_timer_start(action->timer);
+    action->timer = pcmk__main_loop_timer_new("attrd_confirmation", 15000,
+                                              confirmation_timeout_cb, action);
+    pcmk__main_loop_timer_start(action->timer);
 
     pcmk__intkey_table_insert(expected_confirmations, callid, action);
     pcmk__trace("Callid %d now waiting on %u confirmations", callid,

daemons/attrd/attrd_utils.c

@@ -213,7 +213,7 @@ attrd_free_attribute(void *data)
         free(a->set_type);
         free(a->user);
 
-        mainloop_timer_del(a->timer);
+        pcmk__main_loop_timer_free(a->timer);
         g_hash_table_destroy(a->values);
 
         free(a);

daemons/attrd/pacemaker-attrd.h

@@ -141,7 +141,7 @@ typedef struct {
     int timeout_ms; // How long to wait for more changes before writing
     uint32_t flags; // Group of enum attrd_attr_flags
     GHashTable *values;         // Key: node name, value: attribute_value_t
-    mainloop_timer_t *timer;    // Timer to use for timeout_ms
+    pcmk__main_loop_timer_t *timer; // Timer to use for timeout_ms
 } attribute_t;
 
 #define attrd_set_attr_flags(attr, flags_to_set) do {               \
@@ -236,7 +236,8 @@ extern int minimum_protocol_version;
 void attrd_remove_peer_protocol_ver(const char *host);
 void attrd_update_minimum_protocol_ver(const char *host, const char *value);
 
-mainloop_timer_t *attrd_add_timer(const char *id, int timeout_ms, attribute_t *attr);
+pcmk__main_loop_timer_t *attrd_add_timer(const char *id, int timeout_ms,
+                                         attribute_t *attr);
 
 void attrd_unregister_handlers(void);
 void attrd_handle_request(pcmk__request_t *request);

daemons/based/based_callbacks.c

@@ -34,7 +34,7 @@
 
 #include "pacemaker-based.h"
 
-static mainloop_timer_t *digest_timer = NULL;
+static pcmk__main_loop_timer_t *digest_timer = NULL;
 static long long ping_seq = 0;
 static char *ping_digest = NULL;
 static bool ping_modified_since = false;
@@ -102,8 +102,8 @@ void
 based_callbacks_init(void)
 {
     if (digest_timer == NULL) {
-        digest_timer = mainloop_timer_add("based_digest_timer", 5000, false,
-                                          digest_timer_cb, NULL);
+        digest_timer = pcmk__main_loop_timer_new("based_digest_timer", 5000,
+                                                 digest_timer_cb, NULL);
     }
 }
 
@@ -114,7 +114,7 @@ based_callbacks_init(void)
 void
 based_callbacks_cleanup(void)
 {
-    g_clear_pointer(&digest_timer, mainloop_timer_del);
+    g_clear_pointer(&digest_timer, pcmk__main_loop_timer_free);
     g_clear_pointer(&ping_digest, free);
 }
 
@@ -566,7 +566,7 @@ based_perform_op_rw(xmlNode *request, const cib__operation_t *operation,
         ping_modified_since = true;
     }
 
-    mainloop_timer_start(digest_timer);
+    pcmk__main_loop_timer_start(digest_timer);
 
 done:
     if (!pcmk__any_flags_set(call_options,

daemons/based/based_io.c

@@ -45,13 +45,13 @@ static crm_trigger_t *write_trigger = NULL;
  * \internal
  * \brief Process the exit status of a child forked from \c write_cib_async()
  *
- * \param[in] child      Mainloop child data
+ * \param[in] child      Main loop child
  * \param[in] core       If set to 1, the child process dumped core
  * \param[in] signo      Signal that the child process exited with
  * \param[in] exit_code  Child process's exit code
  */
 static void
-write_cib_cb(mainloop_child_t *child, int core, int signo, int exit_code)
+write_cib_cb(pcmk__main_loop_child_t *child, int core, int signo, int exit_code)
 {
     const char *error = "Could not write CIB to disk";
 
@@ -113,7 +113,8 @@ write_cib_async(void *user_data)
 
     if (pid > 0) {
         // Parent
-        mainloop_child_add(pid, 0, "disk-writer", NULL, write_cib_cb);
+        pcmk__main_loop_child_create(pid, "disk-writer", 0, NULL, true,
+                                     write_cib_cb);
 
         if (blackbox_state == QB_LOG_STATE_ENABLED) {
             qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_ENABLED, QB_TRUE);

daemons/controld/controld_control.c

@@ -295,9 +295,7 @@ do_startup(long long action, enum crmd_fsa_cause cause,
     controld_execd_state_table_init();
     controld_remote_proxy_table_init();
 
-    if (!controld_init_fsa_timers()) {
-        register_fsa_error(I_ERROR, msg_data);
-    }
+    controld_init_fsa_timers();
 }
 
 // \return libqb error code (0 on success, -errno on error)

daemons/controld/controld_election.c

@@ -45,7 +45,7 @@ controld_configure_election(GHashTable *options)
     unsigned int interval_ms = 0;
 
     pcmk_parse_interval_spec(value, &interval_ms);
-    election_timeout_set_period(controld_globals.cluster, interval_ms);
+    election_timeout_set_interval(controld_globals.cluster, interval_ms);
 }
 
 void

daemons/controld/controld_fencing.c

@@ -386,7 +386,7 @@ controld_execute_fencing_cleanup(void)
  */
 
 static stonith_t *fencer_api = NULL;
-static mainloop_timer_t *controld_fencer_connect_timer = NULL;
+static pcmk__main_loop_timer_t *controld_fencer_connect_timer = NULL;
 static char *te_client_id = NULL;
 
 static bool
@@ -443,8 +443,8 @@ destroy_fencer_connection(stonith_t *st, stonith_event_t *e)
 
     if (pcmk__is_set(controld_globals.fsa_input_register, R_ST_REQUIRED)) {
         pcmk__err("Lost fencer connection (will attempt to reconnect)");
-        if (!mainloop_timer_running(controld_fencer_connect_timer)) {
-            mainloop_timer_start(controld_fencer_connect_timer);
+        if (!pcmk__main_loop_timer_running(controld_fencer_connect_timer)) {
+            pcmk__main_loop_timer_start(controld_fencer_connect_timer);
         }
     } else {
         pcmk__info("Disconnected from fencer");
@@ -674,9 +674,9 @@ controld_timer_fencer_connect(void *user_data)
 
         if (controld_fencer_connect_timer == NULL) {
             controld_fencer_connect_timer =
-                mainloop_timer_add("controld_fencer_connect", 1000,
-                                   TRUE, controld_timer_fencer_connect,
-                                   GINT_TO_POINTER(TRUE));
+                pcmk__main_loop_timer_new("controld_fencer_connect", 1000,
+                                          controld_timer_fencer_connect,
+                                          GINT_TO_POINTER(TRUE));
         }
 
         if (rc != pcmk_ok) {
@@ -686,8 +686,8 @@ controld_timer_fencer_connect(void *user_data)
                              QB_XS " rc=%d",
                              pcmk_strerror(rc), rc);
 
-                if (!mainloop_timer_running(controld_fencer_connect_timer)) {
-                    mainloop_timer_start(controld_fencer_connect_timer);
+                if (!pcmk__main_loop_timer_running(controld_fencer_connect_timer)) {
+                    pcmk__main_loop_timer_start(controld_fencer_connect_timer);
                 }
 
                 return G_SOURCE_CONTINUE;
@@ -735,7 +735,8 @@ controld_disconnect_fencer(bool destroy)
             g_clear_pointer(&fencer_api, fencer_api->cmds->free);
         }
 
-        g_clear_pointer(&controld_fencer_connect_timer, mainloop_timer_del);
+        g_clear_pointer(&controld_fencer_connect_timer,
+			pcmk__main_loop_timer_free);
         g_clear_pointer(&te_client_id, free);
     }
 }
@@ -1011,19 +1012,21 @@ controld_validate_fencing_watchdog_timeout(const char *value)
  */
 
 static crm_trigger_t *fencing_history_sync_trigger = NULL;
-static mainloop_timer_t *fencing_history_sync_timer_short = NULL;
-static mainloop_timer_t *fencing_history_sync_timer_long = NULL;
+static pcmk__main_loop_timer_t *fencing_history_sync_timer_short = NULL;
+static pcmk__main_loop_timer_t *fencing_history_sync_timer_long = NULL;
 
 void
 controld_cleanup_fencing_history_sync(stonith_t *st, bool free_timers)
 {
     if (free_timers) {
-        g_clear_pointer(&fencing_history_sync_timer_short, mainloop_timer_del);
-        g_clear_pointer(&fencing_history_sync_timer_long, mainloop_timer_del);
+        g_clear_pointer(&fencing_history_sync_timer_short,
+			pcmk__main_loop_timer_free);
+        g_clear_pointer(&fencing_history_sync_timer_long,
+			pcmk__main_loop_timer_free);
 
     } else {
-        mainloop_timer_stop(fencing_history_sync_timer_short);
-        mainloop_timer_stop(fencing_history_sync_timer_long);
+        pcmk__main_loop_timer_stop(fencing_history_sync_timer_short);
+        pcmk__main_loop_timer_stop(fencing_history_sync_timer_long);
     }
 
     if (st) {
@@ -1042,7 +1045,7 @@ static gboolean
 fencing_history_sync_set_trigger(void *user_data)
 {
     mainloop_set_trigger(fencing_history_sync_trigger);
-    return FALSE;
+    return G_SOURCE_REMOVE;
 }
 
 void
@@ -1074,24 +1077,24 @@ controld_trigger_fencing_history_sync(bool long_timeout)
     if (long_timeout) {
         if (fencing_history_sync_timer_long == NULL) {
             fencing_history_sync_timer_long =
-                mainloop_timer_add("history_sync_long", 30000,
-                                   FALSE, fencing_history_sync_set_trigger,
-                                   NULL);
+                pcmk__main_loop_timer_new("history_sync_long", 30000,
+                                          fencing_history_sync_set_trigger,
+                                          NULL);
         }
         pcmk__info("Fence history will be synchronized cluster-wide within 30 "
                    "seconds");
-        mainloop_timer_start(fencing_history_sync_timer_long);
+        pcmk__main_loop_timer_start(fencing_history_sync_timer_long);
 
     } else {
         if (fencing_history_sync_timer_short == NULL) {
             fencing_history_sync_timer_short =
-                mainloop_timer_add("history_sync_short", 5000,
-                                   FALSE, fencing_history_sync_set_trigger,
-                                   NULL);
+                pcmk__main_loop_timer_new("history_sync_short", 5000,
+                                          fencing_history_sync_set_trigger,
+                                          NULL);
         }
         pcmk__info("Fence history will be synchronized cluster-wide within 5 "
                    "seconds");
-        mainloop_timer_start(fencing_history_sync_timer_short);
+        pcmk__main_loop_timer_start(fencing_history_sync_timer_short);
     }
 
 }