diff --git a/include/crm/common/internal.h b/include/crm/common/internal.h
index a91a4bec50..a354f0cb32 100644
--- a/include/crm/common/internal.h
+++ b/include/crm/common/internal.h
@@ -1,359 +1,360 @@
 /*
  * Copyright 2015-2024 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #ifndef PCMK__CRM_COMMON_INTERNAL__H
 #define PCMK__CRM_COMMON_INTERNAL__H
 
 #include <unistd.h>             // pid_t, getpid()
 #include <stdbool.h>            // bool
 #include <stdint.h>             // uint8_t, uint64_t
 
 #include <glib.h>               // guint, GList, GHashTable
 #include <libxml/tree.h>        // xmlNode
 
 #include <crm/common/logging.h>  // do_crm_log_unlikely(), etc.
 #include <crm/common/mainloop.h> // mainloop_io_t, struct ipc_client_callbacks
 #include <crm/common/strings.h>  // crm_strdup_printf()
 #include <crm/common/actions_internal.h>
 #include <crm/common/digest_internal.h>
 #include <crm/common/health_internal.h>
 #include <crm/common/io_internal.h>
 #include <crm/common/iso8601_internal.h>
 #include <crm/common/results_internal.h>
 #include <crm/common/messages_internal.h>
 #include <crm/common/nvpair_internal.h>
 #include <crm/common/scores_internal.h>
 #include <crm/common/strings_internal.h>
 #include <crm/common/acl_internal.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* This says whether the current application is a Pacemaker daemon or not,
  * and is used to change default logging settings such as whether to log to
  * stderr, etc., as well as a few other details such as whether blackbox signal
  * handling is enabled.
  *
  * It is set when logging is initialized, and does not need to be set directly.
  */
 extern bool pcmk__is_daemon;
 
 // Number of elements in a statically defined array
 #define PCMK__NELEM(a) ((int) (sizeof(a)/sizeof(a[0])) )
 
 #if PCMK__ENABLE_CIBSECRETS
 /* internal CIB utilities (from cib_secrets.c) */
 
 int pcmk__substitute_secrets(const char *rsc_id, GHashTable *params);
 #endif
 
 
 /* internal main loop utilities (from mainloop.c) */
 
 int pcmk__add_mainloop_ipc(crm_ipc_t *ipc, int priority, void *userdata,
                            const struct ipc_client_callbacks *callbacks,
                            mainloop_io_t **source);
 guint pcmk__mainloop_timer_get_period(const mainloop_timer_t *timer);
 
 
 /* internal node-related XML utilities (from nodes.c) */
 
 /*!
  * \internal
  * \brief Add local node name and ID to an XML node
  *
  * \param[in,out] request  XML node to modify
  * \param[in]     node     The local node's name
  * \param[in]     nodeid   The local node's ID (can be 0)
  */
 void pcmk__xe_add_node(xmlNode *xml, const char *node, int nodeid);
 
 
 /* internal name/value utilities (from nvpair.c) */
 
 int pcmk__scan_nvpair(const char *input, char **name, char **value);
 char *pcmk__format_nvpair(const char *name, const char *value,
                           const char *units);
 
 /* internal procfs utilities (from procfs.c) */
 
 pid_t pcmk__procfs_pid_of(const char *name);
 unsigned int pcmk__procfs_num_cores(void);
 int pcmk__procfs_pid2path(pid_t pid, char path[], size_t path_size);
 bool pcmk__procfs_has_pids(void);
+void pcmk__sysrq_trigger(char t);
 
 /* internal functions related to process IDs (from pid.c) */
 
 /*!
  * \internal
  * \brief Check whether process exists (by PID and optionally executable path)
  *
  * \param[in] pid     PID of process to check
  * \param[in] daemon  If not NULL, path component to match with procfs entry
  *
  * \return Standard Pacemaker return code
  * \note Particular return codes of interest include pcmk_rc_ok for alive,
  *       ESRCH for process is not alive (verified by kill and/or executable path
  *       match), EACCES for caller unable or not allowed to check. A result of
  *       "alive" is less reliable when \p daemon is not provided or procfs is
  *       not available, since there is no guarantee that the PID has not been
  *       recycled for another process.
  * \note This function cannot be used to verify \e authenticity of the process.
  */
 int pcmk__pid_active(pid_t pid, const char *daemon);
 
 int pcmk__read_pidfile(const char *filename, pid_t *pid);
 int pcmk__pidfile_matches(const char *filename, pid_t expected_pid,
                           const char *expected_name, pid_t *pid);
 int pcmk__lock_pidfile(const char *filename, const char *name);
 
 
 // bitwise arithmetic utilities
 
 /*!
  * \internal
  * \brief Set specified flags in a flag group
  *
  * \param[in] function    Function name of caller
  * \param[in] line        Line number of caller
  * \param[in] log_level   Log a message at this level
  * \param[in] flag_type   Label describing this flag group (for logging)
  * \param[in] target      Name of object whose flags these are (for logging)
  * \param[in] flag_group  Flag group being manipulated
  * \param[in] flags       Which flags in the group should be set
  * \param[in] flags_str   Readable equivalent of \p flags (for logging)
  *
  * \return Possibly modified flag group
  */
 static inline uint64_t
 pcmk__set_flags_as(const char *function, int line, uint8_t log_level,
                    const char *flag_type, const char *target,
                    uint64_t flag_group, uint64_t flags, const char *flags_str)
 {
     uint64_t result = flag_group | flags;
 
     if (result != flag_group) {
         do_crm_log_unlikely(log_level,
                             "%s flags %#.8llx (%s) for %s set by %s:%d",
                             ((flag_type == NULL)? "Group of" : flag_type),
                             (unsigned long long) flags,
                             ((flags_str == NULL)? "flags" : flags_str),
                             ((target == NULL)? "target" : target),
                             function, line);
     }
     return result;
 }
 
 /*!
  * \internal
  * \brief Clear specified flags in a flag group
  *
  * \param[in] function    Function name of caller
  * \param[in] line        Line number of caller
  * \param[in] log_level   Log a message at this level
  * \param[in] flag_type   Label describing this flag group (for logging)
  * \param[in] target      Name of object whose flags these are (for logging)
  * \param[in] flag_group  Flag group being manipulated
  * \param[in] flags       Which flags in the group should be cleared
  * \param[in] flags_str   Readable equivalent of \p flags (for logging)
  *
  * \return Possibly modified flag group
  */
 static inline uint64_t
 pcmk__clear_flags_as(const char *function, int line, uint8_t log_level,
                      const char *flag_type, const char *target,
                      uint64_t flag_group, uint64_t flags, const char *flags_str)
 {
     uint64_t result = flag_group & ~flags;
 
     if (result != flag_group) {
         do_crm_log_unlikely(log_level,
                             "%s flags %#.8llx (%s) for %s cleared by %s:%d",
                             ((flag_type == NULL)? "Group of" : flag_type),
                             (unsigned long long) flags,
                             ((flags_str == NULL)? "flags" : flags_str),
                             ((target == NULL)? "target" : target),
                             function, line);
     }
     return result;
 }
 
 /*!
  * \internal
  * \brief Get readable string for whether specified flags are set
  *
  * \param[in] flag_group    Group of flags to check
  * \param[in] flags         Which flags in \p flag_group should be checked
  *
  * \return "true" if all \p flags are set in \p flag_group, otherwise "false"
  */
 static inline const char *
 pcmk__flag_text(uint64_t flag_group, uint64_t flags)
 {
     return pcmk__btoa(pcmk_all_flags_set(flag_group, flags));
 }
 
 
 // miscellaneous utilities (from utils.c)
 
 void pcmk__daemonize(const char *name, const char *pidfile);
 void pcmk__panic(const char *reason);
 pid_t pcmk__locate_sbd(void);
 void pcmk__sleep_ms(unsigned int ms);
 guint pcmk__create_timer(guint interval_ms, GSourceFunc fn, gpointer data);
 guint pcmk__timeout_ms2s(guint timeout_ms);
 
 extern int pcmk__score_red;
 extern int pcmk__score_green;
 extern int pcmk__score_yellow;
 
 /*!
  * \internal
  * \brief Allocate new zero-initialized memory, asserting on failure
  *
  * \param[in] file      File where \p function is located
  * \param[in] function  Calling function
  * \param[in] line      Line within \p file
  * \param[in] nmemb     Number of elements to allocate memory for
  * \param[in] size      Size of each element
  *
  * \return Newly allocated memory of of size <tt>nmemb * size</tt> (guaranteed
  *         not to be \c NULL)
  *
  * \note The caller is responsible for freeing the return value using \c free().
  */
 static inline void *
 pcmk__assert_alloc_as(const char *file, const char *function, uint32_t line,
                       size_t nmemb, size_t size)
 {
     void *ptr = calloc(nmemb, size);
 
     if (ptr == NULL) {
         crm_abort(file, function, line, "Out of memory", FALSE, TRUE);
         crm_exit(CRM_EX_OSERR);
     }
     return ptr;
 }
 
 /*!
  * \internal
  * \brief Allocate new zero-initialized memory, asserting on failure
  *
  * \param[in] nmemb  Number of elements to allocate memory for
  * \param[in] size   Size of each element
  *
  * \return Newly allocated memory of of size <tt>nmemb * size</tt> (guaranteed
  *         not to be \c NULL)
  *
  * \note The caller is responsible for freeing the return value using \c free().
  */
 #define pcmk__assert_alloc(nmemb, size) \
     pcmk__assert_alloc_as(__FILE__, __func__, __LINE__, nmemb, size)
 
 /*!
  * \internal
  * \brief Resize a dynamically allocated memory block
  *
  * \param[in] ptr   Memory block to resize (or NULL to allocate new memory)
  * \param[in] size  New size of memory block in bytes (must be > 0)
  *
  * \return Pointer to resized memory block
  *
  * \note This asserts on error, so the result is guaranteed to be non-NULL
  *       (which is the main advantage of this over directly using realloc()).
  */
 static inline void *
 pcmk__realloc(void *ptr, size_t size)
 {
     void *new_ptr;
 
     // realloc(p, 0) can replace free(p) but this wrapper can't
     pcmk__assert(size > 0);
 
     new_ptr = realloc(ptr, size);
     if (new_ptr == NULL) {
         free(ptr);
         abort();
     }
     return new_ptr;
 }
 
 static inline char *
 pcmk__getpid_s(void)
 {
     return crm_strdup_printf("%lu", (unsigned long) getpid());
 }
 
 // More efficient than g_list_length(list) == 1
 static inline bool
 pcmk__list_of_1(GList *list)
 {
     return list && (list->next == NULL);
 }
 
 // More efficient than g_list_length(list) > 1
 static inline bool
 pcmk__list_of_multiple(GList *list)
 {
     return list && (list->next != NULL);
 }
 
 /* convenience functions for failure-related node attributes */
 
 #define PCMK__FAIL_COUNT_PREFIX   "fail-count"
 #define PCMK__LAST_FAILURE_PREFIX "last-failure"
 
 /*!
  * \internal
  * \brief Generate a failure-related node attribute name for a resource
  *
  * \param[in] prefix       Start of attribute name
  * \param[in] rsc_id       Resource name
  * \param[in] op           Operation name
  * \param[in] interval_ms  Operation interval
  *
  * \return Newly allocated string with attribute name
  *
  * \note Failure attributes are named like PREFIX-RSC#OP_INTERVAL (for example,
  *       "fail-count-myrsc#monitor_30000"). The '#' is used because it is not
  *       a valid character in a resource ID, to reliably distinguish where the
  *       operation name begins. The '_' is used simply to be more comparable to
  *       action labels like "myrsc_monitor_30000".
  */
 static inline char *
 pcmk__fail_attr_name(const char *prefix, const char *rsc_id, const char *op,
                    guint interval_ms)
 {
     CRM_CHECK(prefix && rsc_id && op, return NULL);
     return crm_strdup_printf("%s-%s#%s_%u", prefix, rsc_id, op, interval_ms);
 }
 
 static inline char *
 pcmk__failcount_name(const char *rsc_id, const char *op, guint interval_ms)
 {
     return pcmk__fail_attr_name(PCMK__FAIL_COUNT_PREFIX, rsc_id, op,
                                 interval_ms);
 }
 
 static inline char *
 pcmk__lastfailure_name(const char *rsc_id, const char *op, guint interval_ms)
 {
     return pcmk__fail_attr_name(PCMK__LAST_FAILURE_PREFIX, rsc_id, op,
                                 interval_ms);
 }
 
 // internal resource agent functions (from agents.c)
 int pcmk__effective_rc(int rc);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // PCMK__CRM_COMMON_INTERNAL__H
diff --git a/lib/common/procfs.c b/lib/common/procfs.c
index 4053a50d06..91853aafe7 100644
--- a/lib/common/procfs.c
+++ b/lib/common/procfs.c
@@ -1,233 +1,255 @@
 /*
  * Copyright 2015-2024 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #include <crm_internal.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <ctype.h>
 
 #if HAVE_LINUX_PROCFS
 /*!
  * \internal
  * \brief Get process ID and name associated with a /proc directory entry
  *
  * \param[in]  entry    Directory entry (must be result of readdir() on /proc)
  * \param[out] name     If not NULL, a char[16] to hold the process name
  * \param[out] pid      If not NULL, will be set to process ID of entry
  *
  * \return Standard Pacemaker return code
  * \note This should be called only on Linux systems, as not all systems that
  *       support /proc store process names and IDs in the same way. The kernel
  *       limits the process name to the first 15 characters (plus terminator).
  *       It would be nice if there were a public kernel API constant for that
  *       limit, but there isn't.
  */
 static int
 pcmk__procfs_process_info(const struct dirent *entry, char *name, pid_t *pid)
 {
     int fd, local_pid;
     FILE *file;
     struct stat statbuf;
     char procpath[128] = { 0 };
 
     /* We're only interested in entries whose name is a PID,
      * so skip anything non-numeric or that is too long.
      *
      * 114 = 128 - strlen("/proc/") - strlen("/status") - 1
      */
     local_pid = atoi(entry->d_name);
     if ((local_pid <= 0) || (strlen(entry->d_name) > 114)) {
         return -1;
     }
     if (pid) {
         *pid = (pid_t) local_pid;
     }
 
     /* Get this entry's file information */
     strcpy(procpath, "/proc/");
     strcat(procpath, entry->d_name);
     fd = open(procpath, O_RDONLY);
     if (fd < 0 ) {
         return -1;
     }
     if (fstat(fd, &statbuf) < 0) {
         close(fd);
         return -1;
     }
     close(fd);
 
     /* We're only interested in subdirectories */
     if (!S_ISDIR(statbuf.st_mode)) {
         return -1;
     }
 
     /* Read the first entry ("Name:") from the process's status file.
      * We could handle the valgrind case if we parsed the cmdline file
      * instead, but that's more of a pain than it's worth.
      */
     if (name != NULL) {
         strcat(procpath, "/status");
         file = fopen(procpath, "r");
         if (!file) {
             return -1;
         }
         if (fscanf(file, "Name:\t%15[^\n]", name) != 1) {
             fclose(file);
             return -1;
         }
         name[15] = 0;
         fclose(file);
     }
 
     return 0;
 }
 #endif // HAVE_LINUX_PROCFS
 
 /*!
  * \internal
  * \brief Return process ID of a named process
  *
  * \param[in] name  Process name (as used in /proc/.../status)
  *
  * \return Process ID of named process if running, 0 otherwise
  *
  * \note This will return 0 if the process is being run via valgrind.
  *       This should be called only on Linux systems.
  */
 pid_t
 pcmk__procfs_pid_of(const char *name)
 {
 #if HAVE_LINUX_PROCFS
     DIR *dp;
     struct dirent *entry;
     pid_t pid = 0;
     char entry_name[64] = { 0 };
 
     dp = opendir("/proc");
     if (dp == NULL) {
         crm_notice("Can not read /proc directory to track existing components");
         return 0;
     }
 
     while ((entry = readdir(dp)) != NULL) {
         if ((pcmk__procfs_process_info(entry, entry_name, &pid) == pcmk_rc_ok)
             && pcmk__str_eq(entry_name, name, pcmk__str_casei)
             && (pcmk__pid_active(pid, NULL) == pcmk_rc_ok)) {
 
             crm_info("Found %s active as process %lld", name, (long long) pid);
             break;
         }
         pid = 0;
     }
     closedir(dp);
     return pid;
 #else
     return 0;
 #endif // HAVE_LINUX_PROCFS
 }
 
 /*!
  * \internal
  * \brief Calculate number of logical CPU cores from procfs
  *
  * \return Number of cores (or 1 if unable to determine)
  */
 unsigned int
 pcmk__procfs_num_cores(void)
 {
 #if HAVE_LINUX_PROCFS
     int cores = 0;
     FILE *stream = NULL;
 
     /* Parse /proc/stat instead of /proc/cpuinfo because it's smaller */
     stream = fopen("/proc/stat", "r");
     if (stream == NULL) {
         crm_perror(LOG_INFO, "Could not open /proc/stat");
     } else {
         char buffer[2048];
 
         while (fgets(buffer, sizeof(buffer), stream)) {
             if (pcmk__starts_with(buffer, "cpu") && isdigit(buffer[3])) {
                 ++cores;
             }
         }
         fclose(stream);
     }
     return cores? cores : 1;
 #else
     return 1;
 #endif // HAVE_LINUX_PROCFS
 }
 
 /*!
  * \internal
  * \brief Get the executable path corresponding to a process ID
  *
  * \param[in]  pid        Process ID to check
  * \param[out] path       Where to store executable path
  * \param[in]  path_size  Size of \p path in characters (ideally PATH_MAX)
  *
  * \return Standard Pacemaker error code (as possible errno values from
  *         readlink())
  */
 int
 pcmk__procfs_pid2path(pid_t pid, char path[], size_t path_size)
 {
 #if HAVE_LINUX_PROCFS
     char procfs_exe_path[PATH_MAX];
     ssize_t link_rc;
 
     if (snprintf(procfs_exe_path, PATH_MAX, "/proc/%lld/exe",
                  (long long) pid) >= PATH_MAX) {
         return ENAMETOOLONG; // Truncated (shouldn't be possible in practice)
     }
 
     link_rc = readlink(procfs_exe_path, path, path_size - 1);
     if (link_rc < 0) {
         return errno;
     } else if (link_rc >= (path_size - 1)) {
         return ENAMETOOLONG;
     }
 
     path[link_rc] = '\0';
     return pcmk_rc_ok;
 #else
     return EOPNOTSUPP;
 #endif // HAVE_LINUX_PROCFS
 }
 
 /*!
  * \internal
  * \brief Check whether process ID information is available from procfs
  *
  * \return true if process ID information is available, otherwise false
  */
 bool
 pcmk__procfs_has_pids(void)
 {
 #if HAVE_LINUX_PROCFS
     static bool have_pids = false;
     static bool checked = false;
 
     if (!checked) {
         char path[PATH_MAX];
 
         have_pids = pcmk__procfs_pid2path(getpid(), path, sizeof(path)) == pcmk_rc_ok;
         checked = true;
     }
     return have_pids;
 #else
     return false;
 #endif // HAVE_LINUX_PROCFS
 }
+
+/*!
+ * \internal
+ * \brief Trigger a sysrq command if supported on current platform
+ *
+ * \param[in] t  Sysrq command to trigger
+ */
+void
+pcmk__sysrq_trigger(char t)
+{
+#if HAVE_LINUX_PROCFS
+    // Root can always write here, regardless of kernel.sysrq value
+    FILE *procf = fopen("/proc/sysrq-trigger", "a");
+
+    if (procf == NULL) {
+        crm_warn("Could not open sysrq-trigger: %s", strerror(errno));
+    } else {
+        fprintf(procf, "%c\n", t);
+        fclose(procf);
+    }
+#endif // HAVE_LINUX_PROCFS
+}
diff --git a/lib/common/watchdog.c b/lib/common/watchdog.c
index 6196e571a9..e64487a9ad 100644
--- a/lib/common/watchdog.c
+++ b/lib/common/watchdog.c
@@ -1,315 +1,293 @@
 /*
  * Copyright 2013-2024 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #include <crm_internal.h>
 
 #include <sched.h>
 #include <sys/ioctl.h>
 #include <sys/reboot.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <ctype.h>
 #include <dirent.h>
 #include <signal.h>
 
 static pid_t sbd_pid = 0;
 
-/*!
- * \internal
- * \brief Trigger a sysrq command if supported on current platform
- *
- * \param[in] t  Sysrq command to trigger
- */
-static void
-sysrq_trigger(char t)
-{
-#if HAVE_LINUX_PROCFS
-    // Root can always write here, regardless of kernel.sysrq value
-    FILE *procf = fopen("/proc/sysrq-trigger", "a");
-
-    if (procf == NULL) {
-        crm_warn("Could not open sysrq-trigger: %s", strerror(errno));
-    } else {
-        fprintf(procf, "%c\n", t);
-        fclose(procf);
-    }
-#endif // HAVE_LINUX_PROCFS
-}
-
 /*!
  * \internal
  * \brief Tell pacemakerd to panic the local host
  *
  * \param[in] ppid  Process ID of parent process
  */
 static void
 panic_local_nonroot(pid_t ppid)
 {
     if (ppid > 1) { // pacemakerd is still our parent
         crm_emerg("Escalating panic to " PCMK__SERVER_PACEMAKERD "[%lld]",
                   (long long) ppid);
     } else { // Signal (non-parent) pacemakerd if possible
 #if HAVE_LINUX_PROCFS
         ppid = pcmk__procfs_pid_of(PCMK__SERVER_PACEMAKERD);
         if (ppid > 0) {
             union sigval signal_value;
 
             crm_emerg("Signaling " PCMK__SERVER_PACEMAKERD "[%lld] to panic",
                       (long long) ppid);
             memset(&signal_value, 0, sizeof(signal_value));
             if (sigqueue(ppid, SIGQUIT, signal_value) < 0) {
                 crm_emerg("Exiting after signal failure: %s", strerror(errno));
             }
         } else {
 #endif
             crm_emerg("Exiting with no known " PCMK__SERVER_PACEMAKERD
                       "process");
 #if HAVE_LINUX_PROCFS
         }
 #endif
     }
     crm_exit(CRM_EX_PANIC);
 }
 
 /*!
  * \internal
  * \brief Panic the local host (if root) or tell pacemakerd to do so
  */
 static void
 panic_local(void)
 {
     const char *full_panic_action = pcmk__env_option(PCMK__ENV_PANIC_ACTION);
     const char *panic_action = full_panic_action;
     int reboot_cmd = RB_AUTOBOOT; // Default panic action is reboot
 
     if (geteuid() != 0) { // Non-root caller such as the controller
         panic_local_nonroot(getppid());
         return;
     }
 
     if (pcmk__starts_with(full_panic_action, "sync-")) {
         panic_action += sizeof("sync-") - 1;
         sync();
     }
 
     if (pcmk__str_empty(full_panic_action)
         || pcmk__str_eq(panic_action, PCMK_VALUE_REBOOT, pcmk__str_none)) {
-        sysrq_trigger('b');
+        pcmk__sysrq_trigger('b');
 
     } else if (pcmk__str_eq(panic_action, PCMK_VALUE_CRASH, pcmk__str_none)) {
-        sysrq_trigger('c');
+        pcmk__sysrq_trigger('c');
 
     } else if (pcmk__str_eq(panic_action, PCMK_VALUE_OFF, pcmk__str_none)) {
-        sysrq_trigger('o');
+        pcmk__sysrq_trigger('o');
 #ifdef RB_POWER_OFF
         reboot_cmd = RB_POWER_OFF;
 #elif defined(RB_POWEROFF)
         reboot_cmd = RB_POWEROFF;
 #endif
     } else {
         crm_warn("Using default '" PCMK_VALUE_REBOOT "' for local option PCMK_"
                  PCMK__ENV_PANIC_ACTION " because '%s' is not a valid value",
                  full_panic_action);
-        sysrq_trigger('b');
+        pcmk__sysrq_trigger('b');
     }
 
     // sysrq failed or is not supported on this platform, so fall back to reboot
     reboot(reboot_cmd);
 
     // Even reboot failed, nothing left to do but exit
     crm_emerg("Exiting after reboot failed: %s", strerror(errno));
     if (getppid() > 1) { // pacemakerd is parent process
         crm_exit(CRM_EX_PANIC);
     } else { // This is pacemakerd, or an orphaned subdaemon
         crm_exit(CRM_EX_FATAL);
     }
 }
 
 /*!
  * \internal
  * \brief Tell sbd to kill the local host, then exit
  */
 static void
 panic_sbd(void)
 {
     union sigval signal_value;
     pid_t ppid = getppid();
 
     memset(&signal_value, 0, sizeof(signal_value));
     /* TODO: Arrange for a slightly less brutal option? */
     if(sigqueue(sbd_pid, SIGKILL, signal_value) < 0) {
         crm_emerg("Panicking directly because couldn't signal sbd");
         panic_local();
     }
 
     if(ppid > 1) {
         /* child daemon */
         crm_exit(CRM_EX_PANIC);
     } else {
         /* pacemakerd or orphan child */
         crm_exit(CRM_EX_FATAL);
     }
 }
 
 /*!
  * \internal
  * \brief Panic the local host
  *
  * Panic the local host either by sbd (if running), directly, or by asking
  * pacemakerd. If trace logging this function, exit instead.
  *
  * \param[in] reason  Why panic is needed (for logging only)
  */
 void
 pcmk__panic(const char *reason)
 {
     if (pcmk__locate_sbd() > 1) {
         crm_emerg("Signaling sbd[%lld] to panic the system: %s",
                   (long long) sbd_pid, reason);
         panic_sbd();
 
     } else {
         crm_emerg("Panicking the system directly: %s", reason);
         panic_local();
     }
 }
 
 /*!
  * \internal
  * \brief Return the process ID of sbd (or 0 if it is not running)
  */
 pid_t
 pcmk__locate_sbd(void)
 {
     char *pidfile = NULL;
     char *sbd_path = NULL;
     int rc;
 
     if(sbd_pid > 1) {
         return sbd_pid;
     }
 
     /* Look for the pid file */
     pidfile = crm_strdup_printf(PCMK__RUN_DIR "/sbd.pid");
     sbd_path = crm_strdup_printf("%s/sbd", SBIN_DIR);
 
     /* Read the pid file */
     rc = pcmk__pidfile_matches(pidfile, 0, sbd_path, &sbd_pid);
     if (rc == pcmk_rc_ok) {
         crm_trace("SBD detected at pid %lld (via PID file %s)",
                   (long long) sbd_pid, pidfile);
 
 #if HAVE_LINUX_PROCFS
     } else {
         /* Fall back to /proc for systems that support it */
         sbd_pid = pcmk__procfs_pid_of("sbd");
         crm_trace("SBD detected at pid %lld (via procfs)",
                   (long long) sbd_pid);
 #endif // HAVE_LINUX_PROCFS
     }
 
     if(sbd_pid < 0) {
         sbd_pid = 0;
         crm_trace("SBD not detected");
     }
 
     free(pidfile);
     free(sbd_path);
 
     return sbd_pid;
 }
 
 long
 pcmk__get_sbd_watchdog_timeout(void)
 {
     static long sbd_timeout = -2;
 
     if (sbd_timeout == -2) {
         sbd_timeout = crm_get_msec(getenv("SBD_WATCHDOG_TIMEOUT"));
     }
     return sbd_timeout;
 }
 
 bool
 pcmk__get_sbd_sync_resource_startup(void)
 {
     static int sync_resource_startup = PCMK__SBD_SYNC_DEFAULT;
     static bool checked_sync_resource_startup = false;
 
     if (!checked_sync_resource_startup) {
         const char *sync_env = getenv("SBD_SYNC_RESOURCE_STARTUP");
 
         if (sync_env == NULL) {
             crm_trace("Defaulting to %sstart-up synchronization with sbd",
                       (PCMK__SBD_SYNC_DEFAULT? "" : "no "));
 
         } else if (crm_str_to_boolean(sync_env, &sync_resource_startup) < 0) {
             crm_warn("Defaulting to %sstart-up synchronization with sbd "
                      "because environment value '%s' is invalid",
                      (PCMK__SBD_SYNC_DEFAULT? "" : "no "), sync_env);
         }
         checked_sync_resource_startup = true;
     }
     return sync_resource_startup != 0;
 }
 
 long
 pcmk__auto_stonith_watchdog_timeout(void)
 {
     long sbd_timeout = pcmk__get_sbd_watchdog_timeout();
 
     return (sbd_timeout <= 0)? 0 : (2 * sbd_timeout);
 }
 
 bool
 pcmk__valid_stonith_watchdog_timeout(const char *value)
 {
     /* @COMPAT At a compatibility break, accept either negative values or a
      * specific string like "auto" (but not both) to mean "auto-calculate the
      * timeout." Reject other values that aren't parsable as timeouts.
      */
     long st_timeout = value? crm_get_msec(value) : 0;
 
     if (st_timeout < 0) {
         st_timeout = pcmk__auto_stonith_watchdog_timeout();
         crm_debug("Using calculated value %ld for "
                   PCMK_OPT_STONITH_WATCHDOG_TIMEOUT " (%s)",
                   st_timeout, value);
     }
 
     if (st_timeout == 0) {
         crm_debug("Watchdog may be enabled but "
                   PCMK_OPT_STONITH_WATCHDOG_TIMEOUT " is disabled (%s)",
                   value? value : "default");
 
     } else if (pcmk__locate_sbd() == 0) {
         crm_emerg("Shutting down: " PCMK_OPT_STONITH_WATCHDOG_TIMEOUT
                   " configured (%s) but SBD not active",
                   pcmk__s(value, "auto"));
         crm_exit(CRM_EX_FATAL);
         return false;
 
     } else {
         long sbd_timeout = pcmk__get_sbd_watchdog_timeout();
 
         if (st_timeout < sbd_timeout) {
             crm_emerg("Shutting down: " PCMK_OPT_STONITH_WATCHDOG_TIMEOUT
                       " (%s) too short (must be >%ldms)",
                       value, sbd_timeout);
             crm_exit(CRM_EX_FATAL);
             return false;
         }
         crm_info("Watchdog configured with " PCMK_OPT_STONITH_WATCHDOG_TIMEOUT
                  " %s and SBD timeout %ldms",
                  value, sbd_timeout);
     }
     return true;
 }