ClusterLabs · nrwahl2 · Jul 23, 2026 · Jul 23, 2026 · Jul 23, 2026 · Jan 11, 2026
diff --git a/daemons/attrd/attrd_alerts.c b/daemons/attrd/attrd_alerts.c
@@ -8,12 +8,12 @@
  */
 
 #include <crm_internal.h>
+
 #include <crm/crm.h>
 #include <crm/cib/internal.h>
-#include <crm/cluster/internal.h>
-#include <crm/cluster/election_internal.h>
 #include <crm/common/xml.h>
 #include <crm/lrmd_internal.h>
+
 #include "pacemaker-attrd.h"
 
 static GList *attrd_alert_list = NULL;

diff --git a/daemons/attrd/attrd_cib.c b/daemons/attrd/attrd_cib.c
@@ -18,7 +18,6 @@
 #include <crm/common/logging.h>
 #include <crm/common/results.h>
 #include <crm/common/xml.h>
-#include <crm/cluster/internal.h>   // pcmk__get_node()
 
 #include "pacemaker-attrd.h"
 

diff --git a/daemons/attrd/attrd_corosync.c b/daemons/attrd/attrd_corosync.c
@@ -15,7 +15,6 @@
 #include <stdlib.h>
 
 #include <crm/cluster.h>
-#include <crm/cluster/internal.h>
 #include <crm/common/logging.h>
 #include <crm/common/results.h>
 #include <crm/common/xml.h>

diff --git a/daemons/attrd/attrd_elections.c b/daemons/attrd/attrd_elections.c
@@ -12,7 +12,6 @@
 #include <stdbool.h>
 
 #include <crm/cluster.h>
-#include <crm/cluster/election_internal.h>
 #include <crm/common/xml.h>
 
 #include "pacemaker-attrd.h"

diff --git a/daemons/attrd/attrd_ipc.c b/daemons/attrd/attrd_ipc.c
@@ -17,7 +17,6 @@
 #include <sys/types.h>
 
 #include <crm/cluster.h>
-#include <crm/cluster/internal.h>
 #include <crm/common/logging.h>
 #include <crm/common/results.h>
 #include <crm/common/util.h>

diff --git a/daemons/attrd/attrd_messages.c b/daemons/attrd/attrd_messages.c
@@ -14,7 +14,6 @@
 
 #include <glib.h>
 
-#include <crm/cluster/internal.h>   // pcmk__get_node()
 #include <crm/common/xml.h>
 
 #include "pacemaker-attrd.h"

diff --git a/daemons/attrd/attrd_utils.c b/daemons/attrd/attrd_utils.c
@@ -57,28 +57,16 @@ attrd_shutdown(int nsig)
     // Tell various functions not to do anthing
     shutting_down = true;
 
-    // Don't respond to signals while shutting down
-    mainloop_destroy_signal(SIGTERM);
-    mainloop_destroy_signal(SIGCHLD);
-    mainloop_destroy_signal(SIGPIPE);
-    mainloop_destroy_signal(SIGUSR1);
-    mainloop_destroy_signal(SIGUSR2);
-    mainloop_destroy_signal(SIGTRAP);
-
     attrd_free_waitlist();
     attrd_free_confirmations();
 
     g_clear_pointer(&peer_protocol_vers, g_hash_table_destroy);
 
-    if ((mloop == NULL) || !g_main_loop_is_running(mloop)) {
-        /* If there's no main loop active, just exit. This should be possible
-         * only if we get SIGTERM in brief windows at start-up and shutdown.
-         */
-        crm_exit(CRM_EX_OK);
-    } else {
-        g_main_loop_quit(mloop);
-        g_main_loop_unref(mloop);
-    }
+    // There should be no way to get here without the main loop running
+    CRM_CHECK((mloop != NULL) && g_main_loop_is_running(mloop),
+              crm_exit(CRM_EX_OK));
+
+    g_main_loop_quit(mloop);
 }
 
 /*!
@@ -99,6 +87,7 @@ void
 attrd_run_mainloop(void)
 {
     g_main_loop_run(mloop);
+    g_clear_pointer(&mloop, g_main_loop_unref);
 }
 
 /* strlen("value") */

diff --git a/daemons/attrd/pacemaker-attrd.c b/daemons/attrd/pacemaker-attrd.c
@@ -24,7 +24,6 @@
 #include <crm/common/iso8601.h>
 #include <crm/common/ipc.h>
 #include <crm/common/xml.h>
-#include <crm/cluster/internal.h>
 
 #include "pacemaker-attrd.h"
 

diff --git a/daemons/attrd/pacemaker-attrd.h b/daemons/attrd/pacemaker-attrd.h
@@ -18,7 +18,7 @@
 
 #include <crm/crm.h>
 #include <crm/cluster.h>
-#include <crm/cluster/election_internal.h>
+#include <crm/cluster/internal.h>
 #include <crm/common/internal.h>
 #include <crm/cib/cib_types.h>
 

diff --git a/daemons/based/based_callbacks.c b/daemons/based/based_callbacks.c
@@ -23,8 +23,6 @@
 
 #include <crm/cib.h>                // cib_call_options values
 #include <crm/cib/internal.h>       // cib__*
-#include <crm/cluster/internal.h>   // pcmk__cluster_send_message
-#include <crm/common/internal.h>    // pcmk__s, pcmk__str_eq
 #include <crm/common/ipc.h>         // crm_ipc_*, pcmk_ipc_*
 #include <crm/common/logging.h>     // CRM_LOG_ASSERT, CRM_CHECK
 #include <crm/common/mainloop.h>    // mainloop_*
@@ -69,6 +67,10 @@ digest_timer_cb(void *data)
 {
     xmlNode *ping = NULL;
 
+    if (based_shutting_down()) {
+        return G_SOURCE_REMOVE;
+    }
+
     if (!based_get_local_node_dc()) {
         // Only the DC sends a ping
         return G_SOURCE_REMOVE;
@@ -615,14 +617,9 @@ log_op_result(const xmlNode *request, const cib__operation_t *operation, int rc,
     originator = pcmk__s(originator, "local");
     client_name = pcmk__s(client_name, "client");
 
-    /* @FIXME based_cib should always be non-NULL, but that's currently not the
-     * case during shutdown
-     */
-    if (based_cib != NULL) {
-        pcmk__xe_get_int(based_cib, PCMK_XA_ADMIN_EPOCH, &admin_epoch);
-        pcmk__xe_get_int(based_cib, PCMK_XA_EPOCH, &epoch);
-        pcmk__xe_get_int(based_cib, PCMK_XA_NUM_UPDATES, &num_updates);
-    }
+    pcmk__xe_get_int(based_cib, PCMK_XA_ADMIN_EPOCH, &admin_epoch);
+    pcmk__xe_get_int(based_cib, PCMK_XA_EPOCH, &epoch);
+    pcmk__xe_get_int(based_cib, PCMK_XA_NUM_UPDATES, &num_updates);
 
     do_crm_log(level,
                "Completed %s operation for section %s: %s (rc=%d, "
@@ -659,17 +656,14 @@ send_peer_reply(xmlNode *msg, const char *originator)
  * \internal
  * \brief Handle an IPC or CPG message containing a request
  *
- * \param[in,out] request     Request XML
- * \param[in]     privileged  If \c true, operations with
- *                            \c cib__op_attr_privileged can be run
- * \param[in]     client      IPC client that sent request (\c NULL if request
- *                            came from CPG)
+ * \param[in,out] request  Request XML
+ * \param[in]     client   IPC client that sent request (\c NULL if request came
+ *                         from CPG)
  *
  * \return Standard Pacemaker return code
  */
 int
-based_process_request(xmlNode *request, bool privileged,
-                      const pcmk__client_t *client)
+based_process_request(xmlNode *request, const pcmk__client_t *client)
 {
     // @TODO: Break into multiple smaller functions
     uint32_t call_options = cib_none;
@@ -696,6 +690,11 @@ based_process_request(xmlNode *request, bool privileged,
     xmlNode *output = NULL;
     time_t start_time = 0;
 
+    if (based_shutting_down()) {
+        pcmk__info("Ignoring pending CIB request during shutdown");
+        return ENOTCONN;
+    }
+
     rc = pcmk__xe_get_flags(request, PCMK__XA_CIB_CALLOPT, &call_options,
                             cib_none);
     if (rc != pcmk_rc_ok) {
@@ -793,12 +792,7 @@ based_process_request(xmlNode *request, bool privileged,
 
     start_time = time(NULL);
 
-    if (!privileged
-        && pcmk__is_set(operation->flags, cib__op_attr_privileged)) {
-
-        rc = EACCES;
-
-    } else if (!pcmk__is_set(operation->flags, cib__op_attr_modifies)) {
+    if (!pcmk__is_set(operation->flags, cib__op_attr_modifies)) {
         rc = cib__perform_op_ro(op_function, request, &based_cib, &output);
 
     } else {

diff --git a/daemons/based/based_callbacks.h b/daemons/based/based_callbacks.h
@@ -10,16 +10,13 @@
 #ifndef BASED_CALLBACKS__H
 #define BASED_CALLBACKS__H
 
-#include <stdbool.h>
-
 #include <libxml/tree.h>                // xmlNode
 
 #include <crm/common/internal.h>        // pcmk__client_t
 
 void based_callbacks_init(void);
 void based_callbacks_cleanup(void);
 
-int based_process_request(xmlNode *request, bool privileged,
-                          const pcmk__client_t *client);
+int based_process_request(xmlNode *request, const pcmk__client_t *client);
 
 #endif // BASED_CALLBACKS__H
diff --git a/daemons/based/based_corosync.c b/daemons/based/based_corosync.c
@@ -9,7 +9,7 @@
 
 #include <crm_internal.h>
 
-#include <stdbool.h>
+#include <inttypes.h>               // PRIu32
 #include <stddef.h>                 // NULL, size_t
 #include <stdint.h>                 // uint32_t
 #include <stdlib.h>                 // free
@@ -20,41 +20,69 @@
 
 #include <crm_config.h>             // SUPPORT_COROSYNC
 #include <crm/cluster.h>            // pcmk_cluster_*
-#include <crm/cluster/internal.h>   // pcmk__cluster_*, etc.
-#include <crm/common/internal.h>    // pcmk__err, pcmk__xml_free, etc.
 #include <crm/common/results.h>     // CRM_EX_DISCONNECT, pcmk_rc_ok
 
 #include "pacemaker-based.h"
 
 static pcmk_cluster_t *cluster = NULL;
 
 static void
-based_peer_callback(xmlNode *msg, void *private_data)
+based_peer_message(pcmk__node_status_t *peer, xmlNode *xml)
 {
-    const char *reason = NULL;
-    const char *originator = pcmk__xe_get(msg, PCMK__XA_SRC);
-
-    if (pcmk__peer_cache == NULL) {
-        reason = "membership not established";
-        goto bail;
-    }
-
-    if (pcmk__xe_get(msg, PCMK__XA_CIB_CLIENTNAME) == NULL) {
-        pcmk__xe_set(msg, PCMK__XA_CIB_CLIENTNAME, originator);
-    }
-
-    based_process_request(msg, true, NULL);
-    return;
+    int rc = pcmk_rc_ok;
 
-  bail:
-    if (reason) {
-        const char *op = pcmk__xe_get(msg, PCMK__XA_CIB_OP);
+    if (based_shutting_down()) {
+        pcmk__info("Ignoring CPG message from %s[%" PRIu32 "] during shutdown",
+                   peer->name, peer->cluster_layer_id);
+        return;
 
-        pcmk__warn("Discarding %s message from %s: %s", op, originator, reason);
+    } else {
+        pcmk__request_t request = {
+            .ipc_client     = NULL,
+            .ipc_id         = 0,
+            .ipc_flags      = 0,
+            .peer           = peer->name,
+            .xml            = xml,
+            .call_options   = cib_none,
+            .result         = PCMK__UNKNOWN_RESULT,
+        };
+
+        rc = pcmk__xe_get_flags(xml, PCMK__XA_CIB_CALLOPT,
+                                (uint32_t *) &request.call_options, cib_none);
+        if (rc != pcmk_rc_ok) {
+            pcmk__warn("Couldn't parse options from request: %s",
+                       pcmk_rc_str(rc));
+        }
+
+        request.op = pcmk__xe_get_copy(request.xml, PCMK__XA_CIB_OP);
+        CRM_CHECK(request.op != NULL, return);
+
+        if (pcmk__is_set(request.call_options, cib_sync_call)) {
+            pcmk__set_request_flags(&request, pcmk__request_sync);
+        }
+
+        if (pcmk__xe_get(request.xml, PCMK__XA_CIB_CLIENTNAME) == NULL) {
+            pcmk__xe_set(request.xml, PCMK__XA_CIB_CLIENTNAME,
+                         pcmk__xe_get(request.xml, PCMK__XA_SRC));
+        }
+
+        based_process_request(request.xml, request.ipc_client);
+        pcmk__reset_request(&request);
     }
 }
 
 #if SUPPORT_COROSYNC
+/*!
+ * \internal
+ * \brief Callback for when a peer message is received
+ *
+ * \param[in]     handle      Cluster connection
+ * \param[in]     group_name  Group that \p nodeid is a member of
+ * \param[in]     nodeid      Peer node that sent \p msg
+ * \param[in]     pid         Process that sent \p msg
+ * \param[in,out] msg         Received message
+ * \param[in]     msg_len     Length of \p msg
+ */
 static void
 based_cpg_dispatch(cpg_handle_t handle, const struct cpg_name *group_name,
                    uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
@@ -69,12 +97,15 @@ based_cpg_dispatch(cpg_handle_t handle, const struct cpg_name *group_name,
 
     xml = pcmk__xml_parse(data);
     if (xml == NULL) {
-        pcmk__err("Invalid XML: '%.120s'", data);
-        free(data);
-        return;
+        pcmk__err("Bad message received from %s[%" PRIu32 "]: '%.120s'", from,
+                  nodeid, data);
+
+    } else {
+        pcmk__xe_set(xml, PCMK__XA_SRC, from);
+        based_peer_message(pcmk__get_node(nodeid, from, NULL,
+                                          pcmk__node_search_cluster_member),
+                           xml);
     }
-    pcmk__xe_set(xml, PCMK__XA_SRC, from);
-    based_peer_callback(xml, NULL);
 
     pcmk__xml_free(xml);
     free(data);
@@ -88,8 +119,8 @@ based_cpg_destroy(void *user_data)
         return;
     }
 
-    pcmk__crit("Exiting immediately after losing connection to cluster layer");
-    based_terminate(CRM_EX_DISCONNECT);
+    pcmk__crit("Exiting after losing connection to cluster layer");
+    based_quit_main_loop(CRM_EX_DISCONNECT);
 }
 #endif
 

diff --git a/daemons/based/based_io.c b/daemons/based/based_io.c
@@ -29,7 +29,6 @@
 
 #include <crm/cib/internal.h>       // cib_file_*
 #include <crm/cib/util.h>           // createEmptyCib
-#include <crm/common/internal.h>    // pcmk__assert_asprintf, PCMK__XE_*, etc.
 #include <crm/common/logging.h>     // CRM_CHECK
 #include <crm/common/mainloop.h>    // mainloop_*
 #include <crm/common/results.h>     // pcmk_legacy2rc, pcmk_rc_*
@@ -93,6 +92,10 @@ write_cib_async(void *user_data)
     pid_t pid = 0;
     int blackbox_state = qb_log_ctl(QB_LOG_BLACKBOX, QB_LOG_CONF_STATE_GET, 0);
 
+    if (based_shutting_down()) {
+        pcmk__info("Skipping CIB write during shutdown");
+    }
+
     /* Disable blackbox logging before the fork to avoid two processes writing
      * to the same shared memory. The disable should not be done in the child,
      * because this would close shared memory files in the parent.