From d6e5e62f7c084fc0aabfae7e6391b4b59f63252f Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Tue, 13 Sep 2022 14:40:24 -0500

Subject: [PATCH 01/24] Low: fencing: use a default timeout with metadata and

 validate

If the caller did not specify a timeout, use a default in

stonith_api_operations_t:metadata() and validate(). (Timeout is currently

ignored past that point, so this has no effect yet.)

Also, rename timeout argument for clarity.

---

 lib/fencing/st_client.c | 23 ++++++++++++++++-------

 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/lib/fencing/st_client.c b/lib/fencing/st_client.c

index 2b0d308..28791ff 100644

--- a/lib/fencing/st_client.c

+++ b/lib/fencing/st_client.c

@@ -504,7 +504,8 @@ stonith_api_device_list(stonith_t * stonith, int call_options, const char *names

 static int

 stonith_api_device_metadata(stonith_t * stonith, int call_options, const char *agent,

-                            const char *namespace, char **output, int timeout)

+                            const char *namespace, char **output,

+                            int timeout_sec)

 {

     /* By executing meta-data directly, we can get it from stonith_admin when

      * the cluster is not running, which is important for higher-level tools.

@@ -512,16 +513,20 @@ stonith_api_device_metadata(stonith_t * stonith, int call_options, const char *a

     enum stonith_namespace ns = stonith_get_namespace(agent, namespace);

+    if (timeout_sec <= 0) {

+        timeout_sec = CRMD_METADATA_CALL_TIMEOUT;

+    }

+

     crm_trace("Looking up metadata for %s agent %s",

               stonith_namespace2text(ns), agent);

     switch (ns) {

         case st_namespace_rhcs:

-            return stonith__rhcs_metadata(agent, timeout, output);

+            return stonith__rhcs_metadata(agent, timeout_sec, output);

 #if HAVE_STONITH_STONITH_H

         case st_namespace_lha:

-            return stonith__lha_metadata(agent, timeout, output);

+            return stonith__lha_metadata(agent, timeout_sec, output);

 #endif

         default:

@@ -1684,8 +1689,8 @@ stonith_api_delete(stonith_t * stonith)

 static int

 stonith_api_validate(stonith_t *st, int call_options, const char *rsc_id,

                      const char *namespace_s, const char *agent,

-                     stonith_key_value_t *params, int timeout, char **output,

-                     char **error_output)

+                     stonith_key_value_t *params, int timeout_sec,

+                     char **output, char **error_output)

 {

     /* Validation should be done directly via the agent, so we can get it from

      * stonith_admin when the cluster is not running, which is important for

@@ -1731,17 +1736,21 @@ stonith_api_validate(stonith_t *st, int call_options, const char *rsc_id,

         *error_output = NULL;

     }

+    if (timeout_sec <= 0) {

+        timeout_sec = CRMD_METADATA_CALL_TIMEOUT; // Questionable

+    }

+

     switch (stonith_get_namespace(agent, namespace_s)) {

         case st_namespace_rhcs:

             rc = stonith__rhcs_validate(st, call_options, target, agent,

-                                        params_table, host_arg, timeout,

+                                        params_table, host_arg, timeout_sec,

                                         output, error_output);

             break;

 #if HAVE_STONITH_STONITH_H

         case st_namespace_lha:

             rc = stonith__lha_validate(st, call_options, target, agent,

-                                       params_table, timeout, output,

+                                       params_table, timeout_sec, output,

                                        error_output);

             break;

 #endif

-- 

2.31.1

From 7404fc1238253b80eb97fd81af123c3f5aa1fde8 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Tue, 13 Sep 2022 14:00:00 -0500

Subject: [PATCH 02/24] Doc: fencer: improve

 stonith_api_operations_t:metadata() description

---

 include/crm/stonith-ng.h | 15 +++++++++++----

 lib/fencing/st_client.c  |  7 ++++---

 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/include/crm/stonith-ng.h b/include/crm/stonith-ng.h

index 4fe52ef..a41d411 100644

--- a/include/crm/stonith-ng.h

+++ b/include/crm/stonith-ng.h

@@ -206,14 +206,21 @@ typedef struct stonith_api_operations_s

         stonith_t *st, int options, const char *node, int level, stonith_key_value_t *device_list);

     /*!

-     * \brief Get the metadata documentation for a resource.

+     * \brief Retrieve a fence agent's metadata

      *

-     * \note Value is returned in output.  Output must be freed when set.

+     * \param[in,out] stonith       Fencer connection

+     * \param[in]     call_options  Group of enum stonith_call_options

+     *                              (currently ignored)

+     * \param[in]     agent         Fence agent to query

+     * \param[in]     namespace     Namespace of fence agent to query (optional)

+     * \param[out]    output        Where to store metadata

+     * \param[in]     timeout_sec   Error if not complete within this time

      *

      * \return Legacy Pacemaker return code

+     * \note The caller is responsible for freeing *output using free().

      */

-    int (*metadata)(stonith_t *st, int options,

-            const char *device, const char *provider, char **output, int timeout);

+    int (*metadata)(stonith_t *stonith, int call_options, const char *agent,

+                    const char *namespace, char **output, int timeout_sec);

     /*!

      * \brief Retrieve a list of installed stonith agents

diff --git a/lib/fencing/st_client.c b/lib/fencing/st_client.c

index 28791ff..6c252bc 100644

--- a/lib/fencing/st_client.c

+++ b/lib/fencing/st_client.c

@@ -502,10 +502,11 @@ stonith_api_device_list(stonith_t * stonith, int call_options, const char *names

     return count;

 }

+// See stonith_api_operations_t:metadata() documentation

 static int

-stonith_api_device_metadata(stonith_t * stonith, int call_options, const char *agent,

-                            const char *namespace, char **output,

-                            int timeout_sec)

+stonith_api_device_metadata(stonith_t *stonith, int call_options,

+                            const char *agent, const char *namespace,

+                            char **output, int timeout_sec)

 {

     /* By executing meta-data directly, we can get it from stonith_admin when

      * the cluster is not running, which is important for higher-level tools.

-- 

2.31.1

From 7b5d1610231252e209a57ef6d82a23e3667812a0 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Tue, 13 Sep 2022 14:16:54 -0500

Subject: [PATCH 03/24] Doc: fencing: add doxygen block for

 stonith__action_create()

... and rename a couple arguments for clarity

---

 include/crm/fencing/internal.h |  4 ++--

 lib/fencing/st_actions.c       | 33 ++++++++++++++++++++++++---------

 2 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/include/crm/fencing/internal.h b/include/crm/fencing/internal.h

index d2b49f8..e2ca85e 100644

--- a/include/crm/fencing/internal.h

+++ b/include/crm/fencing/internal.h

@@ -50,10 +50,10 @@ struct stonith_action_s;

 typedef struct stonith_action_s stonith_action_t;

 stonith_action_t *stonith_action_create(const char *agent,

-                                        const char *_action,

+                                        const char *action_name,

                                         const char *victim,

                                         uint32_t victim_nodeid,

-                                        int timeout,

+                                        int timeout_sec,

                                         GHashTable * device_args,

                                         GHashTable * port_map,

                                         const char * host_arg);

diff --git a/lib/fencing/st_actions.c b/lib/fencing/st_actions.c

index b3429f6..d16fa33 100644

--- a/lib/fencing/st_actions.c

+++ b/lib/fencing/st_actions.c

@@ -232,27 +232,42 @@ stonith__action_result(stonith_action_t *action)

 }

 #define FAILURE_MAX_RETRIES 2

+

+/*!

+ * \internal

+ * \brief Create a new fencing action to be executed

+ *

+ * \param[in] agent          Fence agent to use

+ * \param[in] action_name    Fencing action to be executed

+ * \param[in] victim         Name of target of fencing action (if known)

+ * \param[in] victim_nodeid  Node ID of target of fencing action (if known)

+ * \param[in] timeout_sec    Timeout to be used when executing action

+ * \param[in] device_args    Parameters to pass to fence agent

+ * \param[in] port_map       Mapping of target names to device ports

+ * \param[in] host_arg       Agent parameter used to pass target name

+ *

+ * \return Newly created fencing action (asserts on error, never NULL)

+ */

 stonith_action_t *

 stonith_action_create(const char *agent,

-                      const char *_action,

+                      const char *action_name,

                       const char *victim,

                       uint32_t victim_nodeid,

-                      int timeout, GHashTable * device_args,

+                      int timeout_sec, GHashTable * device_args,

                       GHashTable * port_map, const char *host_arg)

 {

-    stonith_action_t *action;

+    stonith_action_t *action = calloc(1, sizeof(stonith_action_t));

-    action = calloc(1, sizeof(stonith_action_t));

     CRM_ASSERT(action != NULL);

-    action->args = make_args(agent, _action, victim, victim_nodeid,

+    action->args = make_args(agent, action_name, victim, victim_nodeid,

                              device_args, port_map, host_arg);

     crm_debug("Preparing '%s' action for %s using agent %s",

-              _action, (victim? victim : "no target"), agent);

+              action_name, (victim? victim : "no target"), agent);

     action->agent = strdup(agent);

-    action->action = strdup(_action);

+    action->action = strdup(action_name);

     pcmk__str_update(&action->victim, victim);

-    action->timeout = action->remaining_timeout = timeout;

+    action->timeout = action->remaining_timeout = timeout_sec;

     action->max_retries = FAILURE_MAX_RETRIES;

     pcmk__set_result(&(action->result), PCMK_OCF_UNKNOWN, PCMK_EXEC_UNKNOWN,

@@ -262,7 +277,7 @@ stonith_action_create(const char *agent,

         char buffer[512];

         const char *value = NULL;

-        snprintf(buffer, sizeof(buffer), "pcmk_%s_retries", _action);

+        snprintf(buffer, sizeof(buffer), "pcmk_%s_retries", action_name);

         value = g_hash_table_lookup(device_args, buffer);

         if (value) {

-- 

2.31.1

From a82339a81c451566b9835e61bca7e1bf84b97c46 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Tue, 13 Sep 2022 14:20:24 -0500

Subject: [PATCH 04/24] Low: fencing: use requested timeout with RHCS metadata

 actions

... instead of hardcoded 5 seconds, and rename timeout argument for clarity

---

 lib/fencing/st_rhcs.c | 35 ++++++++++++++++-------------------

 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/lib/fencing/st_rhcs.c b/lib/fencing/st_rhcs.c

index dfccff2..1b3cd57 100644

--- a/lib/fencing/st_rhcs.c

+++ b/lib/fencing/st_rhcs.c

@@ -112,25 +112,24 @@ stonith_rhcs_parameter_not_required(xmlNode *metadata, const char *parameter)

 }

 /*!

- * \brief Execute RHCS-compatible agent's meta-data action

+ * \brief Execute RHCS-compatible agent's metadata action

  *

- * \param[in]  agent    Agent to execute

- * \param[in]  timeout  Action timeout

- * \param[out] metadata Where to store output xmlNode (or NULL to ignore)

- *

- * \todo timeout is currently ignored; shouldn't we use it?

+ * \param[in]  agent        Agent to execute

+ * \param[in]  timeout_sec  Action timeout

+ * \param[out] metadata     Where to store output xmlNode (or NULL to ignore)

  */

 static int

-stonith__rhcs_get_metadata(const char *agent, int timeout, xmlNode **metadata)

+stonith__rhcs_get_metadata(const char *agent, int timeout_sec,

+                           xmlNode **metadata)

 {

     xmlNode *xml = NULL;

     xmlNode *actions = NULL;

     xmlXPathObject *xpathObj = NULL;

-    pcmk__action_result_t *result = NULL;

-    stonith_action_t *action = stonith_action_create(agent, "metadata", NULL, 0,

-                                                     5, NULL, NULL, NULL);

+    stonith_action_t *action = stonith_action_create(agent, "metadata", NULL,

+                                                     0, timeout_sec, NULL,

+                                                     NULL, NULL);

     int rc = stonith__execute(action);

-    result = stonith__action_result(action);

+    pcmk__action_result_t *result = stonith__action_result(action);

     if (result == NULL) {

         if (rc < 0) {

@@ -208,21 +207,19 @@ stonith__rhcs_get_metadata(const char *agent, int timeout, xmlNode **metadata)

 }

 /*!

- * \brief Execute RHCS-compatible agent's meta-data action

- *

- * \param[in]  agent    Agent to execute

- * \param[in]  timeout  Action timeout

- * \param[out] output   Where to store action output (or NULL to ignore)

+ * \brief Retrieve metadata for RHCS-compatible fence agent

  *

- * \todo timeout is currently ignored; shouldn't we use it?

+ * \param[in]  agent        Agent to execute

+ * \param[in]  timeout_sec  Action timeout

+ * \param[out] output       Where to store action output (or NULL to ignore)

  */

 int

-stonith__rhcs_metadata(const char *agent, int timeout, char **output)

+stonith__rhcs_metadata(const char *agent, int timeout_sec, char **output)

 {

     char *buffer = NULL;

     xmlNode *xml = NULL;

-    int rc = stonith__rhcs_get_metadata(agent, timeout, &xml;;

+    int rc = stonith__rhcs_get_metadata(agent, timeout_sec, &xml;;

     if (rc != pcmk_ok) {

         free_xml(xml);

-- 

2.31.1

From 73d12e7bcab4d12b1d60ac3431fb713a36c5b6d3 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Tue, 13 Sep 2022 14:32:44 -0500

Subject: [PATCH 05/24] Refactor: fencing: make stonith_action_t:async bool

---

 lib/fencing/st_actions.c | 5 +++--

 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/fencing/st_actions.c b/lib/fencing/st_actions.c

index d16fa33..abd0d5a 100644

--- a/lib/fencing/st_actions.c

+++ b/lib/fencing/st_actions.c

@@ -9,6 +9,7 @@

 #include <crm_internal.h>

+#include <stdbool.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

@@ -32,7 +33,7 @@ struct stonith_action_s {

     char *victim;

     GHashTable *args;

     int timeout;

-    int async;

+    bool async;

     void *userdata;

     void (*done_cb) (int pid, const pcmk__action_result_t *result,

                      void *user_data);

@@ -671,7 +672,7 @@ stonith_action_execute_async(stonith_action_t * action,

     action->userdata = userdata;

     action->done_cb = done;

     action->fork_cb = fork_cb;

-    action->async = 1;

+    action->async = true;

     return internal_stonith_action_execute(action);

 }

-- 

2.31.1

From 537955ab3c19a1bfacc43fb739e38f036c5788fb Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Tue, 13 Sep 2022 14:59:28 -0500

Subject: [PATCH 06/24] Refactor: fencing: rename

 stonith_action_execute_async()

... to stonith__execute_async(), since it's internal

---

 daemons/fenced/fenced_commands.c |  4 ++--

 include/crm/fencing/internal.h   | 12 +++++-------

 lib/fencing/st_actions.c         | 11 +++++------

 3 files changed, 12 insertions(+), 15 deletions(-)

diff --git a/daemons/fenced/fenced_commands.c b/daemons/fenced/fenced_commands.c

index 94aa6b8..41a1936 100644

--- a/daemons/fenced/fenced_commands.c

+++ b/daemons/fenced/fenced_commands.c

@@ -510,8 +510,8 @@ stonith_device_execute(stonith_device_t * device)

     /* for async exec, exec_rc is negative for early error exit

        otherwise handling of success/errors is done via callbacks */

     cmd->activating_on = device;

-    exec_rc = stonith_action_execute_async(action, (void *)cmd,

-                                           cmd->done_cb, fork_cb);

+    exec_rc = stonith__execute_async(action, (void *)cmd, cmd->done_cb,

+                                     fork_cb);

     if (exec_rc < 0) {

         cmd->activating_on = NULL;

         cmd->done_cb(0, stonith__action_result(action), cmd);

diff --git a/include/crm/fencing/internal.h b/include/crm/fencing/internal.h

index e2ca85e..1797d9a 100644

--- a/include/crm/fencing/internal.h

+++ b/include/crm/fencing/internal.h

@@ -64,13 +64,11 @@ void stonith__xe_set_result(xmlNode *xml, const pcmk__action_result_t *result);

 void stonith__xe_get_result(xmlNode *xml, pcmk__action_result_t *result);

 xmlNode *stonith__find_xe_with_result(xmlNode *xml);

-int

-stonith_action_execute_async(stonith_action_t * action,

-                             void *userdata,

-                             void (*done) (int pid,

-                                           const pcmk__action_result_t *result,

-                                           void *user_data),

-                             void (*fork_cb) (int pid, void *user_data));

+int stonith__execute_async(stonith_action_t *action, void *userdata,

+                           void (*done) (int pid,

+                                         const pcmk__action_result_t *result,

+                                         void *user_data),

+                           void (*fork_cb) (int pid, void *user_data));

 xmlNode *create_level_registration_xml(const char *node, const char *pattern,

                                        const char *attr, const char *value,

diff --git a/lib/fencing/st_actions.c b/lib/fencing/st_actions.c

index abd0d5a..c4e32bd 100644

--- a/lib/fencing/st_actions.c

+++ b/lib/fencing/st_actions.c

@@ -658,12 +658,11 @@ internal_stonith_action_execute(stonith_action_t * action)

  * \return pcmk_ok if ownership of action has been taken, -errno otherwise

  */

 int

-stonith_action_execute_async(stonith_action_t * action,

-                             void *userdata,

-                             void (*done) (int pid,

-                                           const pcmk__action_result_t *result,

-                                           void *user_data),

-                             void (*fork_cb) (int pid, void *user_data))

+stonith__execute_async(stonith_action_t * action, void *userdata,

+                       void (*done) (int pid,

+                                     const pcmk__action_result_t *result,

+                                     void *user_data),

+                       void (*fork_cb) (int pid, void *user_data))

 {

     if (!action) {

         return -EINVAL;

-- 

2.31.1

From b56edde80bfe4cf900a5eb021986c8f6189d3307 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Tue, 13 Sep 2022 16:43:57 -0500

Subject: [PATCH 07/24] Refactor: fencing: add internal API for getting

 metadata async

Nothing uses it yet

---

 include/crm/fencing/internal.h |  6 +++

 lib/fencing/st_client.c        | 80 ++++++++++++++++++++++++++++++++++

 2 files changed, 86 insertions(+)

diff --git a/include/crm/fencing/internal.h b/include/crm/fencing/internal.h

index 1797d9a..513d1c4 100644

--- a/include/crm/fencing/internal.h

+++ b/include/crm/fencing/internal.h

@@ -70,6 +70,12 @@ int stonith__execute_async(stonith_action_t *action, void *userdata,

                                          void *user_data),

                            void (*fork_cb) (int pid, void *user_data));

+int stonith__metadata_async(const char *agent, int timeout_sec,

+                            void (*callback)(int pid,

+                                             const pcmk__action_result_t *result,

+                                             void *user_data),

+                            void *user_data);

+

 xmlNode *create_level_registration_xml(const char *node, const char *pattern,

                                        const char *attr, const char *value,

                                        int level,

diff --git a/lib/fencing/st_client.c b/lib/fencing/st_client.c

index 6c252bc..91075bd 100644

--- a/lib/fencing/st_client.c

+++ b/lib/fencing/st_client.c

@@ -2386,6 +2386,86 @@ stonith__device_parameter_flags(uint32_t *device_flags, const char *device_name,

     freeXpathObject(xpath);

 }

+/*!

+ * \internal

+ * \brief Retrieve fence agent meta-data asynchronously

+ *

+ * \param[in] agent        Agent to execute

+ * \param[in] timeout_sec  Error if not complete within this time

+ * \param[in] callback     Function to call with result (this will always be

+ *                         called, whether by this function directly or later

+ *                         via the main loop, and on success the metadata will

+ *                         be in its result argument's action_stdout)

+ * \param[in] user_data    User data to pass to callback

+ *

+ * \return Standard Pacemaker return code

+ * \note The caller must use a main loop. This function is not a

+ *       stonith_api_operations_t method because it does not need a stonith_t

+ *       object and does not go through the fencer, but executes the agent

+ *       directly.

+ */

+int

+stonith__metadata_async(const char *agent, int timeout_sec,

+                        void (*callback)(int pid,

+                                         const pcmk__action_result_t *result,

+                                         void *user_data),

+                        void *user_data)

+{

+    switch (stonith_get_namespace(agent, NULL)) {

+        case st_namespace_rhcs:

+            {

+                stonith_action_t *action = NULL;

+                int rc = pcmk_ok;

+

+                action = stonith_action_create(agent, "metadata", NULL, 0,

+                                               timeout_sec, NULL, NULL, NULL);

+

+                rc = stonith__execute_async(action, user_data, callback, NULL);

+                if (rc != pcmk_ok) {

+                    callback(0, stonith__action_result(action), user_data);

+                    stonith__destroy_action(action);

+                }

+                return pcmk_legacy2rc(rc);

+            }

+

+#if HAVE_STONITH_STONITH_H

+        case st_namespace_lha:

+            // LHA metadata is simply synthesized, so simulate async

+            {

+                pcmk__action_result_t result = {

+                    .exit_status = CRM_EX_OK,

+                    .execution_status = PCMK_EXEC_DONE,

+                    .exit_reason = NULL,

+                    .action_stdout = NULL,

+                    .action_stderr = NULL,

+                };

+

+                stonith__lha_metadata(agent, timeout_sec,

+                                      &result.action_stdout);

+                callback(0, &result, user_data);

+                pcmk__reset_result(&result);

+                return pcmk_rc_ok;

+            }

+#endif

+

+        default:

+            {

+                pcmk__action_result_t result = {

+                    .exit_status = CRM_EX_ERROR,

+                    .execution_status = PCMK_EXEC_ERROR_HARD,

+                    .exit_reason = crm_strdup_printf("No such agent '%s'",

+                                                     agent),

+                    .action_stdout = NULL,

+                    .action_stderr = NULL,

+                };

+

+                callback(0, &result, user_data);

+                pcmk__reset_result(&result);

+                return ENOENT;

+            }

+    }

+}

+

 /*!

  * \internal

  * \brief Return the exit status from an async action callback

-- 

2.31.1

From f12cdd204982548b4d5fed16c0a460d4a5ced217 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Tue, 13 Sep 2022 17:33:10 -0500

Subject: [PATCH 08/24] Refactor: liblrmd: add internal API for getting

 metadata async

Nothing uses it yet

---

 include/crm/lrmd_internal.h |  10 +++-

 lib/lrmd/lrmd_client.c      | 115 ++++++++++++++++++++++++++++++++++++

 2 files changed, 123 insertions(+), 2 deletions(-)

diff --git a/include/crm/lrmd_internal.h b/include/crm/lrmd_internal.h

index 284c4d6..5cb00d5 100644

--- a/include/crm/lrmd_internal.h

+++ b/include/crm/lrmd_internal.h

@@ -1,5 +1,5 @@

 /*

- * Copyright 2015-2021 the Pacemaker project contributors

+ * Copyright 2015-2022 the Pacemaker project contributors

  *

  * The version control history for this file may have further details.

  *

@@ -17,7 +17,7 @@

 #include <crm/common/mainloop.h>        // mainloop_io_t, ipc_client_callbacks

 #include <crm/common/output_internal.h> // pcmk__output_t

 #include <crm/common/remote_internal.h> // pcmk__remote_t

-#include <crm/lrmd.h>                   // lrmd_t, lrmd_event_data_t

+#include <crm/lrmd.h>           // lrmd_t, lrmd_event_data_t, lrmd_rsc_info_t

 int lrmd__new(lrmd_t **api, const char *nodename, const char *server, int port);

@@ -35,6 +35,12 @@ int lrmd_send_resource_alert(lrmd_t *lrmd, GList *alert_list,

 int lrmd__remote_send_xml(pcmk__remote_t *session, xmlNode *msg, uint32_t id,

                           const char *msg_type);

+int lrmd__metadata_async(lrmd_rsc_info_t *rsc,

+                         void (*callback)(int pid,

+                                          const pcmk__action_result_t *result,

+                                          void *user_data),

+                         void *user_data);

+

 void lrmd__set_result(lrmd_event_data_t *event, enum ocf_exitcode rc,

                       int op_status, const char *exit_reason);

diff --git a/lib/lrmd/lrmd_client.c b/lib/lrmd/lrmd_client.c

index 82afd6c..4b16bf0 100644

--- a/lib/lrmd/lrmd_client.c

+++ b/lib/lrmd/lrmd_client.c

@@ -2343,6 +2343,121 @@ lrmd_api_delete(lrmd_t * lrmd)

     free(lrmd);

 }

+struct metadata_cb {

+     void (*callback)(int pid, const pcmk__action_result_t *result,

+                      void *user_data);

+     void *user_data;

+};

+

+/*!

+ * \internal

+ * \brief Process asynchronous metadata completion

+ *

+ * \param[in] action  Metadata action that completed

+ */

+static void

+metadata_complete(svc_action_t *action)

+{

+    struct metadata_cb *metadata_cb = (struct metadata_cb *) action->cb_data;

+    pcmk__action_result_t result = PCMK__UNKNOWN_RESULT;

+

+    pcmk__set_result(&result, action->rc, action->status,

+                     services__exit_reason(action));

+    pcmk__set_result_output(&result, action->stdout_data, action->stderr_data);

+

+    metadata_cb->callback(0, &result, metadata_cb->user_data);

+    result.action_stdout = NULL; // Prevent free, because action owns it

+    result.action_stderr = NULL; // Prevent free, because action owns it

+    pcmk__reset_result(&result);

+    free(metadata_cb);

+}

+

+/*!

+ * \internal

+ * \brief Retrieve agent metadata asynchronously

+ *

+ * \param[in] rsc        Resource agent specification

+ * \param[in] callback   Function to call with result (this will always be

+ *                       called, whether by this function directly or later via

+ *                       the main loop, and on success the metadata will be in

+ *                       its result argument's action_stdout)

+ * \param[in] user_data  User data to pass to callback

+ *

+ * \return Standard Pacemaker return code

+ * \note This function is not a lrmd_api_operations_t method because it does not

+ *       need an lrmd_t object and does not go through the executor, but

+ *       executes the agent directly.

+ */

+int

+lrmd__metadata_async(lrmd_rsc_info_t *rsc,

+                     void (*callback)(int pid,

+                                      const pcmk__action_result_t *result,

+                                      void *user_data),

+                     void *user_data)

+{

+    svc_action_t *action = NULL;

+    struct metadata_cb *metadata_cb = NULL;

+    pcmk__action_result_t result = PCMK__UNKNOWN_RESULT;

+

+    CRM_CHECK(callback != NULL, return EINVAL);

+

+    if ((rsc == NULL) || (rsc->standard == NULL) || (rsc->type == NULL)) {

+        pcmk__set_result(&result, PCMK_OCF_NOT_CONFIGURED, PCMK_EXEC_ERROR,

+                         "Invalid resource specification");

+        callback(0, &result, user_data);

+        pcmk__reset_result(&result);

+        return EINVAL;

+    }

+

+    if (strcmp(rsc->standard, PCMK_RESOURCE_CLASS_STONITH) == 0) {

+        return stonith__metadata_async(rsc->type,

+                                       CRMD_METADATA_CALL_TIMEOUT / 1000,

+                                       callback, user_data);

+    }

+

+    action = services__create_resource_action(rsc->type, rsc->standard,

+                                              rsc->provider, rsc->type,

+                                              CRMD_ACTION_METADATA, 0,

+                                              CRMD_METADATA_CALL_TIMEOUT, NULL,

+                                              0);

+    if (action == NULL) {

+        pcmk__set_result(&result, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,

+                         "Out of memory");

+        callback(0, &result, user_data);

+        pcmk__reset_result(&result);

+        return ENOMEM;

+    }

+    if (action->rc != PCMK_OCF_UNKNOWN) {

+        pcmk__set_result(&result, action->rc, action->status,

+                         services__exit_reason(action));

+        callback(0, &result, user_data);

+        pcmk__reset_result(&result);

+        services_action_free(action);

+        return EINVAL;

+    }

+

+    action->cb_data = calloc(1, sizeof(struct metadata_cb));