data               63 attrd/commands.c send_attrd_message(crm_node_t * node, xmlNode * data)
data               65 attrd/commands.c     crm_xml_add(data, F_TYPE, T_ATTRD);
data               66 attrd/commands.c     crm_xml_add(data, F_ATTRD_IGNORE_LOCALLY, "atomic-version"); /* Tell older versions to ignore our messages */
data               67 attrd/commands.c     crm_xml_add(data, F_ATTRD_VERSION, ATTRD_PROTOCOL_VERSION);
data               68 attrd/commands.c     crm_xml_add_int(data, F_ATTRD_WRITER, election_state(writer));
data               70 attrd/commands.c     return send_cluster_message(node, crm_msg_attrd, data, TRUE);
data               74 attrd/commands.c attribute_timer_cb(gpointer data)
data               76 attrd/commands.c     attribute_t *a = data;
data               83 attrd/commands.c free_attribute_value(gpointer data)
data               85 attrd/commands.c     attribute_value_t *v = data;
data               94 attrd/commands.c free_attribute(gpointer data)
data               96 attrd/commands.c     attribute_t *a = data;
data              909 attrd/commands.c attrd_peer_change_cb(enum crm_status_type kind, crm_node_t *peer, const void *data)
data               63 attrd/internal.h void free_attribute(gpointer data);
data               66 attrd/internal.h void attrd_peer_change_cb(enum crm_status_type type, crm_node_t *peer, const void *data);
data               60 attrd/legacy.c #define register_cib_callback(call_id, data, fn, free_fn) \
data               62 attrd/legacy.c                                            data, #fn, fn, free_fn)
data               88 attrd/legacy.c free_hash_entry(gpointer data)
data               90 attrd/legacy.c     attr_hash_entry_t *entry = data;
data              108 attrd/legacy.c attrd_ipc_dispatch(qb_ipcs_connection_t * c, void *data, size_t size)
data              113 attrd/legacy.c     xmlNode *msg = crm_ipcs_recv(client, data, size, &id, &flags);
data              466 attrd/legacy.c     char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);
data              468 attrd/legacy.c     if(data == NULL) {
data              472 attrd/legacy.c         xml = string2xml(data);
data              474 attrd/legacy.c             crm_err("Bad message received: '%.120s'", data);
data              485 attrd/legacy.c     free(data);
data              766 attrd/legacy.c     struct attrd_callback_s *data = user_data;
data              768 attrd/legacy.c     free(data->attr);
data              769 attrd/legacy.c     free(data->value);
data              770 attrd/legacy.c     free(data);
data              777 attrd/legacy.c     struct attrd_callback_s *data = user_data;
data              779 attrd/legacy.c     if (data->value == NULL && rc == -ENXIO) {
data              783 attrd/legacy.c         crm_warn("Update %s=%s failed: %s", data->attr, data->value, pcmk_strerror(call_id));
data              789 attrd/legacy.c             crm_debug("Update %d for %s=%s passed", call_id, data->attr, data->value);
data              790 attrd/legacy.c             hash_entry = g_hash_table_lookup(attr_hash, data->attr);
data              795 attrd/legacy.c                 if (data->value != NULL) {
data              796 attrd/legacy.c                     hash_entry->stored_value = strdup(data->value);
data              806 attrd/legacy.c                      call_id, data->attr, data->value, pcmk_strerror(rc));
data              810 attrd/legacy.c                     call_id, data->attr, data->value, pcmk_strerror(rc));
data              818 attrd/legacy.c     struct attrd_callback_s *data = NULL;
data              878 attrd/legacy.c     data = calloc(1, sizeof(struct attrd_callback_s));
data              879 attrd/legacy.c     data->attr = strdup(hash_entry->id);
data              881 attrd/legacy.c         data->value = strdup(hash_entry->value);
data              883 attrd/legacy.c     register_cib_callback(rc, data, attrd_cib_callback, free_attrd_callback);
data              978 attrd/legacy.c remote_attr_callback(xmlNode *msg, int id, int rc, xmlNode *output, void *data)
data              981 attrd/legacy.c         crm_debug("%s succeeded " CRM_XS " call=%d", (char *) data, id);
data              984 attrd/legacy.c                    (char *) data, pcmk_strerror(rc), id, rc);
data               60 attrd/main.c       char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);
data               62 attrd/main.c       if(data == NULL) {
data               67 attrd/main.c           xml = string2xml(data);
data               71 attrd/main.c           crm_err("Bad message of class %d received from %s[%u]: '%.120s'", kind, from, nodeid, data);
data               79 attrd/main.c       free(data);
data              233 attrd/main.c   attrd_ipc_dispatch(qb_ipcs_connection_t * c, void *data, size_t size)
data              238 attrd/main.c       xmlNode *xml = crm_ipcs_recv(client, data, size, &id, &flags);
data               74 cib/callbacks.c gboolean cib_common_callback(qb_ipcs_connection_t * c, void *data, size_t size,
data              130 cib/callbacks.c cib_ipc_dispatch_rw(qb_ipcs_connection_t * c, void *data, size_t size)
data              135 cib/callbacks.c     return cib_common_callback(c, data, size, TRUE);
data              139 cib/callbacks.c cib_ipc_dispatch_ro(qb_ipcs_connection_t * c, void *data, size_t size)
data              144 cib/callbacks.c     return cib_common_callback(c, data, size, FALSE);
data              249 cib/callbacks.c cib_common_callback(qb_ipcs_connection_t * c, void *data, size_t size, gboolean privileged)
data              255 cib/callbacks.c     xmlNode *op_request = crm_ipcs_recv(cib_client, data, size, &id, &flags);
data              322 cib/callbacks.c cib_digester_cb(gpointer data)
data              472 cib/callbacks.c local_notify_destroy_callback(gpointer data)
data              474 cib/callbacks.c     cib_local_notify_t *notify = data;
data             1539 cib/callbacks.c cib_ccm_msg_callback(oc_ed_t event, void *cookie, size_t size, const void *data)
data             1542 cib/callbacks.c     const oc_ev_membership_t *membership = data;
data             1607 cib/callbacks.c cib_force_exit(gpointer data)
data               85 cib/callbacks.h extern void cib_ccm_msg_callback(oc_ed_t event, void *cookie, size_t size, const void *data);
data               22 cib/cibmessages.h                                  const char *verbose, xmlNode * data);
data               54 cib/common.c       xmlNode *data = NULL;
data               63 cib/common.c           data = first_named_child(root, XML_TAG_CIB);
data               66 cib/common.c           data = root;
data               70 cib/common.c       if (section != NULL && data != NULL && crm_str_eq(crm_element_name(data), XML_TAG_CIB, TRUE)) {
data               71 cib/common.c           data = get_object_root(section, data);
data               75 cib/common.c       return data;
data               79 cib/common.c   cib_prepare_none(xmlNode * request, xmlNode ** data, const char **section)
data               81 cib/common.c       *data = NULL;
data               87 cib/common.c   cib_prepare_data(xmlNode * request, xmlNode ** data, const char **section)
data               92 cib/common.c       *data = cib_prepare_common(input_fragment, *section);
data               98 cib/common.c   cib_prepare_sync(xmlNode * request, xmlNode ** data, const char **section)
data              100 cib/common.c       *data = NULL;
data              106 cib/common.c   cib_prepare_diff(xmlNode * request, xmlNode ** data, const char **section)
data              111 cib/common.c       *data = NULL;
data              122 cib/common.c       *data = cib_prepare_common(input_fragment, NULL);
data              127 cib/common.c   cib_cleanup_query(int options, xmlNode ** data, xmlNode ** output)
data              129 cib/common.c       CRM_LOG_ASSERT(*data == NULL);
data              138 cib/common.c   cib_cleanup_data(int options, xmlNode ** data, xmlNode ** output)
data              141 cib/common.c       *data = NULL;
data              146 cib/common.c   cib_cleanup_output(int options, xmlNode ** data, xmlNode ** output)
data              153 cib/common.c   cib_cleanup_none(int options, xmlNode ** data, xmlNode ** output)
data              155 cib/common.c       CRM_LOG_ASSERT(*data == NULL);
data              161 cib/common.c   cib_cleanup_sync(int options, xmlNode ** data, xmlNode ** output)
data              164 cib/common.c       CRM_LOG_ASSERT(*data == NULL);
data              382 cib/main.c         char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);
data              384 cib/main.c         if(data == NULL) {
data              388 cib/main.c             xml = string2xml(data);
data              390 cib/main.c                 crm_err("Invalid XML: '%.120s'", data);
data              391 cib/main.c                 free(data);
data              400 cib/main.c         free(data);
data              416 cib/main.c     cib_peer_update_callback(enum crm_status_type type, crm_node_t * node, const void *data)
data              424 cib/main.c                     uint32_t old = data? *(const uint32_t *)data : 0;
data               84 cib/remote.c   int cib_remote_listen(gpointer data);
data               85 cib/remote.c   int cib_remote_msg(gpointer data);
data              266 cib/remote.c   remote_auth_timeout_cb(gpointer data)
data              268 cib/remote.c       crm_client_t *client = data;
data              283 cib/remote.c   cib_remote_listen(gpointer data)
data              289 cib/remote.c       int ssock = *(int *)data;
data              468 cib/remote.c   cib_remote_msg(gpointer data)
data              471 cib/remote.c       crm_client_t *client = data;
data              567 cib/remote.c                        struct pam_response **response, void *data)
data              571 cib/remote.c       char *string = (char *)data;
data              573 cib/remote.c       CRM_CHECK(data, return PAM_CONV_ERR);
data              105 crmd/callbacks.c peer_update_callback(enum crm_status_type type, crm_node_t * node, const void *data)
data              138 crmd/callbacks.c             CRM_CHECK(safe_str_neq(data, node->state), return);
data              142 crmd/callbacks.c                      node->uname, state_text(node->state), state_text(data));
data              155 crmd/callbacks.c             if (data) {
data              156 crmd/callbacks.c                 old = *(const uint32_t *)data;
data               65 crmd/control.c election_timeout_popped(gpointer data)
data              340 crmd/control.c         fsa_data_t *fsa_data = gIter->data;
data              708 crmd/control.c crmd_ipc_dispatch(qb_ipcs_connection_t * c, void *data, size_t size)
data              714 crmd/control.c     xmlNode *msg = crm_ipcs_recv(client, data, size, &id, &flags);
data               57 crmd/corosync.c     char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);
data               59 crmd/corosync.c     if(data == NULL) {
data               62 crmd/corosync.c     xml = string2xml(data);
data               64 crmd/corosync.c         crm_err("Could not parse message content (%d): %.100s", kind, data);
data               65 crmd/corosync.c         free(data);
data              129 crmd/corosync.c             crm_err("Unexpected message class (%d): %.100s", kind, data);
data              133 crmd/corosync.c             crm_err("Invalid message class (%d): %.100s", kind, data);
data              136 crmd/corosync.c     free(data);
data               41 crmd/crmd_callbacks.h extern void peer_update_callback(enum crm_status_type type, crm_node_t * node, const void *data);
data               58 crmd/crmd_fsa.h      gboolean(*callback) (gpointer data);
data               77 crmd/crmd_fsa.h     void *data;
data               43 crmd/crmd_lrm.h void history_free(gpointer data);
data               47 crmd/crmd_messages.h                                   void *data, long long with_actions,
data               57 crmd/crmd_messages.h             ((fsa_data_t*)msg_data)->data, action, TRUE, __FUNCTION__); \
data               65 crmd/crmd_messages.h #  define register_fsa_input(cause, input, data) register_fsa_input_adv(cause, input, data, A_NOTHING, FALSE, __FUNCTION__)
data               76 crmd/crmd_messages.h #  define register_fsa_input_before(cause, input, data) register_fsa_input_adv(cause, input, data, A_NOTHING, TRUE, __FUNCTION__)
data               78 crmd/crmd_messages.h #  define register_fsa_input_later(cause, input, data) register_fsa_input_adv(cause, input, data, A_NOTHING, FALSE, __FUNCTION__)
data               31 crmd/crmd_utils.h #  define fsa_cib_delete(section, data, options, call_id, user_name)	\
data               34 crmd/crmd_utils.h 		fsa_cib_conn, CIB_OP_DELETE, NULL, section, data,	\
data               41 crmd/crmd_utils.h #  define fsa_cib_update(section, data, options, call_id, user_name)	\
data               44 crmd/crmd_utils.h 		fsa_cib_conn, CIB_OP_MODIFY, NULL, section, data,	\
data               51 crmd/crmd_utils.h #  define fsa_cib_anon_update(section, data, options)			\
data               54 crmd/crmd_utils.h 		fsa_cib_conn, section, data, options);			\
data               76 crmd/crmd_utils.h gboolean crm_timer_popped(gpointer data);
data              114 crmd/crmd_utils.h #  define fsa_register_cib_callback(id, flag, data, fn) do {            \
data              118 crmd/crmd_utils.h             flag, data, #fn, fn, free);                                 \
data              462 crmd/fsa.c         } else if (stored_msg->data == NULL) {
data               42 crmd/heartbeat.c void crmd_ccm_msg_callback(oc_ed_t event, void *cookie, size_t size, const void *data);
data              304 crmd/heartbeat.c crmd_ccm_msg_callback(oc_ed_t event, void *cookie, size_t size, const void *data)
data              307 crmd/heartbeat.c     const oc_ev_membership_t *membership = data;
data              312 crmd/heartbeat.c     CRM_ASSERT(data != NULL);
data              367 crmd/heartbeat.c         do_ccm_update_cache(C_CCM_CALLBACK, fsa_state, event, data, NULL);
data              226 crmd/join_dc.c     if (msg_data->data) {
data              125 crmd/lrm.c             lrmd_event_data_t *existing = iter->data;
data              151 crmd/lrm.c             lrmd_free_event(iter->data);
data              164 crmd/lrm.c     history_free(gpointer data)
data              166 crmd/lrm.c         rsc_history_t *history = (rsc_history_t*)data;
data              536 crmd/lrm.c             struct ra_param_s *param = (struct ra_param_s *) iter->data;
data              815 crmd/lrm.c                 build_operation_update(xml_rsc, &(entry->rsc), gIter->data, lrm_state->node_name, __FUNCTION__);
data             1228 crmd/lrm.c         struct cancel_data *data = user_data;
data             1231 crmd/lrm.c         if (crm_str_eq(op->op_key, data->key, TRUE)) {
data             1232 crmd/lrm.c             data->done = TRUE;
data             1233 crmd/lrm.c             remove = !cancel_op(data->lrm_state, data->rsc->id, key, op->call_id, data->remove);
data             1242 crmd/lrm.c         struct cancel_data data;
data             1247 crmd/lrm.c         data.key = key;
data             1248 crmd/lrm.c         data.rsc = rsc;
data             1249 crmd/lrm.c         data.done = FALSE;
data             1250 crmd/lrm.c         data.remove = remove;
data             1251 crmd/lrm.c         data.lrm_state = lrm_state;
data             1253 crmd/lrm.c         removed = g_hash_table_foreach_remove(lrm_state->pending_ops, cancel_action_by_key, &data);
data             1256 crmd/lrm.c         return data.done;
data             1610 crmd/lrm.c             xmlNode *data = do_lrm_query_internal(lrm_state, node_update_all);
data             1611 crmd/lrm.c             xmlNode *reply = create_reply(input->msg, data);
data             1618 crmd/lrm.c             free_xml(data);
data             2013 crmd/lrm.c             lrm_state_t *lrm_state = state_entry->data;
data             2145 crmd/lrm.c             struct stop_recurring_action_s data;
data             2147 crmd/lrm.c             data.rsc = rsc;
data             2148 crmd/lrm.c             data.lrm_state = lrm_state;
data             2150 crmd/lrm.c                 lrm_state->pending_ops, stop_recurring_action_by_rsc, &data);
data              174 crmd/lrm_state.c internal_lrm_state_destroy(gpointer data)
data              176 crmd/lrm_state.c     lrm_state_t *lrm_state = data;
data               60 crmd/messages.c                                I_NULL, cur_data ? cur_data->data : NULL,
data               75 crmd/messages.c                        void *data, long long with_actions,
data               92 crmd/messages.c                   raised_from, fsa_cause2string(cause), data, old_len);
data               99 crmd/messages.c         if (data == NULL) {
data              113 crmd/messages.c               fsa_input2string(input), fsa_cause2string(cause), data ? "with" : "without");
data              120 crmd/messages.c     fsa_data->data = NULL;
data              128 crmd/messages.c     if (data != NULL) {
data              136 crmd/messages.c                 CRM_CHECK(((ha_msg_input_t *) data)->msg != NULL,
data              138 crmd/messages.c                 fsa_data->data = copy_ha_msg_input(data);
data              145 crmd/messages.c                 fsa_data->data = lrmd_copy_event((lrmd_event_data_t *) data);
data              197 crmd/messages.c         fsa_data_t *data = (fsa_data_t *) lpc->data;
data              201 crmd/messages.c                             offset++, data->id, fsa_input2string(data->fsa_input),
data              202 crmd/messages.c                             data->origin, data->data, data->data_type,
data              203 crmd/messages.c                             fsa_cause2string(data->fsa_cause));
data              211 crmd/messages.c     xmlNodePtr data = NULL;
data              215 crmd/messages.c         data = copy_xml(orig->msg);
data              220 crmd/messages.c     copy = new_ha_msg_input(data);
data              238 crmd/messages.c     if (fsa_data->data != NULL) {
data              241 crmd/messages.c                 delete_ha_msg_input(fsa_data->data);
data              245 crmd/messages.c                 foo = fsa_data->data;
data              250 crmd/messages.c                 op = (lrmd_event_data_t *) fsa_data->data;
data              255 crmd/messages.c                 if (fsa_data->data != NULL) {
data              294 crmd/messages.c     } else if (fsa_data->data == NULL) {
data              302 crmd/messages.c         ret_val = fsa_data->data;
data              979 crmd/messages.c         xmlNode *data = get_message_xml(msg, F_CRM_DATA);
data              981 crmd/messages.c         process_te_message(msg, data);
data              992 crmd/messages.c         fsa_data.data = &fsa_input;
data              137 crmd/remote_lrmd_ra.c recurring_helper(gpointer data)
data              139 crmd/remote_lrmd_ra.c     remote_ra_cmd_t *cmd = data;
data              156 crmd/remote_lrmd_ra.c start_delay_helper(gpointer data)
data              158 crmd/remote_lrmd_ra.c     remote_ra_cmd_t *cmd = data;
data              406 crmd/remote_lrmd_ra.c retry_start_cmd_cb(gpointer data)
data              408 crmd/remote_lrmd_ra.c     lrm_state_t *lrm_state = data;
data              445 crmd/remote_lrmd_ra.c connection_takeover_timeout_cb(gpointer data)
data              448 crmd/remote_lrmd_ra.c     remote_ra_cmd_t *cmd = data;
data              462 crmd/remote_lrmd_ra.c monitor_timeout_cb(gpointer data)
data              465 crmd/remote_lrmd_ra.c     remote_ra_cmd_t *cmd = data;
data              754 crmd/remote_lrmd_ra.c         cmd = first->data;
data              923 crmd/remote_lrmd_ra.c         cmd = gIter->data;
data              930 crmd/remote_lrmd_ra.c         cmd = gIter->data;
data              953 crmd/remote_lrmd_ra.c         cmd = gIter->data;
data             1016 crmd/remote_lrmd_ra.c         cmd = gIter->data;
data             1023 crmd/remote_lrmd_ra.c         cmd = gIter->data;
data              464 crmd/te_actions.c         ha_msg_input_t data = {
data              471 crmd/te_actions.c             .data = &data,
data              749 crmd/te_callbacks.c tengine_stonith_callback(stonith_t * stonith, stonith_callback_data_t * data)
data              756 crmd/te_callbacks.c     int call_id = data->call_id;
data              757 crmd/te_callbacks.c     int rc = data->rc;
data              758 crmd/te_callbacks.c     char *userdata = data->userdata;
data              875 crmd/te_callbacks.c action_timer_callback(gpointer data)
data              879 crmd/te_callbacks.c     CRM_CHECK(data != NULL, return FALSE);
data              881 crmd/te_callbacks.c     timer = (crm_action_timer_t *) data;
data               27 crmd/te_callbacks.h extern gboolean global_timer_callback(gpointer data);
data               28 crmd/te_callbacks.h extern gboolean action_timer_callback(gpointer data);
data               34 crmd/te_callbacks.h extern void tengine_stonith_callback(stonith_t * stonith, stonith_callback_data_t * data);
data               51 crmd/te_events.c         synapse_t *synapse = (synapse_t *) gIter->data;
data               60 crmd/te_events.c             crm_action_t *action = (crm_action_t *) gIter2->data;
data              327 crmd/te_events.c         synapse_t *synapse = (synapse_t *) gIter->data;
data              331 crmd/te_events.c             crm_action_t *action = (crm_action_t *) gIter2->data;
data              354 crmd/te_events.c         synapse_t *synapse = (synapse_t *) gIter->data;
data              360 crmd/te_events.c             crm_action_t *action = (crm_action_t *) gIter2->data;
data              412 crmd/te_events.c         for (gIter2 = ((synapse_t*)gIter->data)->actions;
data              416 crmd/te_events.c             match = (crm_action_t*)gIter2->data;
data               70 crmd/te_utils.c         char *iter_name = tmp->data;
data               92 crmd/te_utils.c             char *target = iter->data;
data              112 crmd/te_utils.c         char *target = iter->data;
data              139 crmd/te_utils.c         synapse_t *synapse = (synapse_t *) lpc->data;
data              146 crmd/te_utils.c             crm_action_t *action = (crm_action_t *) lpc2->data;
data              377 crmd/throttle.c throttle_timer_cb(gpointer data)
data              104 crmd/utils.c   crm_timer_popped(gpointer data)
data              106 crmd/utils.c       fsa_timer_t *timer = (fsa_timer_t *) data;
data              231 fencing/admin.c fence_callback(stonith_t * stonith, stonith_callback_data_t * data)
data              233 fencing/admin.c     async_fence_data.rc = data->rc;
data              124 fencing/commands.c                                               xmlNode * data, int rc);
data              303 fencing/commands.c         async_command_t *cmd = gIter->data;
data              338 fencing/commands.c         cmd = first->data;
data              426 fencing/commands.c start_delay_helper(gpointer data)
data              428 fencing/commands.c     async_command_t *cmd = data;
data              500 fencing/commands.c free_device(gpointer data)
data              503 fencing/commands.c     stonith_device_t *device = data;
data              509 fencing/commands.c         async_command_t *cmd = gIter->data;
data             1247 fencing/commands.c free_topology_entry(gpointer data)
data             1249 fencing/commands.c     stonith_topology_t *tp = data;
data             1860 fencing/commands.c         stonith_device_t *device = g_hash_table_lookup(device_list, lpc->data);
data             2136 fencing/commands.c             next_device = g_hash_table_lookup(device_list, iter->data);
data             2148 fencing/commands.c         next_device = g_hash_table_lookup(device_list, cmd->device_next->data);
data             2173 fencing/commands.c         async_command_t *cmd_other = gIter->data;
data             2245 fencing/commands.c         device = g_hash_table_lookup(device_list, devices->data);
data             2313 fencing/commands.c stonith_construct_reply(xmlNode * request, const char *output, xmlNode * data, int rc)
data             2345 fencing/commands.c     if (data != NULL) {
data             2347 fencing/commands.c         add_message_xml(reply, F_STONITH_CALLDATA, data);
data             2353 fencing/commands.c stonith_construct_async_reply(async_command_t * cmd, const char *output, xmlNode * data, int rc)
data             2378 fencing/commands.c     if (data != NULL) {
data             2380 fencing/commands.c         add_message_xml(reply, F_STONITH_CALLDATA, data);
data             2454 fencing/commands.c     xmlNode *data = NULL;
data             2598 fencing/commands.c         rc = stonith_fence_history(request, &data);
data             2665 fencing/commands.c         reply = stonith_construct_reply(request, output, data, rc);
data             2670 fencing/commands.c     free_xml(data);
data              193 fencing/internal.h xmlNode *stonith_construct_reply(xmlNode * request, const char *output, xmlNode * data,
data              199 fencing/internal.h void do_stonith_notify(int options, const char *type, int result, xmlNode * data);
data              214 fencing/internal.h void free_device(gpointer data);
data              216 fencing/internal.h void free_topology_entry(gpointer data);
data               95 fencing/main.c st_ipc_dispatch(qb_ipcs_connection_t * qbc, void *data, size_t size)
data              109 fencing/main.c     request = crm_ipcs_recv(c, data, size, &id, &flags);
data              227 fencing/main.c     char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);
data              229 fencing/main.c     if(data == NULL) {
data              233 fencing/main.c         xml = string2xml(data);
data              235 fencing/main.c             crm_err("Invalid XML: '%.120s'", data);
data              236 fencing/main.c             free(data);
data              245 fencing/main.c     free(data);
data              376 fencing/main.c do_stonith_notify(int options, const char *type, int result, xmlNode * data)
data              388 fencing/main.c     if (data != NULL) {
data              389 fencing/main.c         add_message_xml(update_msg, F_STONITH_CALLDATA, data);
data              430 fencing/main.c     xmlNode *data = create_xml_node(NULL, XML_TAG_FENCING_LEVEL);
data              432 fencing/main.c     crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);
data              433 fencing/main.c     crm_xml_add_int(data, XML_ATTR_STONITH_INDEX, level);
data              434 fencing/main.c     crm_xml_add(data, XML_ATTR_STONITH_TARGET, node);
data              436 fencing/main.c     rc = stonith_level_remove(data, &desc);
data              439 fencing/main.c     free_xml(data);
data              622 fencing/main.c             cib_device_update(gIter->data, data_set);
data              673 fencing/main.c         xmlNode *data;
data              698 fencing/main.c         data = create_device_registration_xml(rsc_name(rsc), provider, agent, params, rsc_provides);
data              699 fencing/main.c         stonith_device_register(data, NULL, TRUE);
data              702 fencing/main.c         free_xml(data);
data              739 fencing/main.c         cib_device_update(gIter->data, &data_set);
data             1258 fencing/main.c st_peer_update_callback(enum crm_status_type type, crm_node_t * node, const void *data)
data               87 fencing/remote.c static void remote_op_done(remote_fencing_op_t * op, xmlNode * data, int rc, int dup);
data               88 fencing/remote.c extern xmlNode *stonith_create_op(int call_id, const char *token, const char *op, xmlNode * data,
data              102 fencing/remote.c free_remote_query(gpointer data)
data              104 fencing/remote.c     if (data) {
data              105 fencing/remote.c         st_query_result_t *query = data;
data              132 fencing/remote.c     struct peer_count_data *data = user_data;
data              134 fencing/remote.c     if (!props->executed[data->op->phase]
data              135 fencing/remote.c         && (!data->verified_only || props->verified)) {
data              136 fencing/remote.c         ++(data->count);
data              154 fencing/remote.c     struct peer_count_data data;
data              156 fencing/remote.c     data.op = op;
data              157 fencing/remote.c     data.verified_only = verified_only;
data              158 fencing/remote.c     data.count = 0;
data              160 fencing/remote.c         g_hash_table_foreach(peer->devices, count_peer_device, &data);
data              162 fencing/remote.c     return data.count;
data              230 fencing/remote.c free_remote_op(gpointer data)
data              232 fencing/remote.c     remote_fencing_op_t *op = data;
data              314 fencing/remote.c         GListPtr match = g_list_find_custom(op->devices_list, iter->data,
data              318 fencing/remote.c             op->devices_list = g_list_remove(op->devices_list, match->data);
data              385 fencing/remote.c handle_local_reply_and_notify(remote_fencing_op_t * op, xmlNode * data, int rc)
data              397 fencing/remote.c     crm_xml_add_int(data, "state", op->state);
data              398 fencing/remote.c     crm_xml_add(data, F_STONITH_TARGET, op->target);
data              399 fencing/remote.c     crm_xml_add(data, F_STONITH_OPERATION, op->action);
data              401 fencing/remote.c     reply = stonith_construct_reply(op->request, NULL, data, rc);
data              417 fencing/remote.c handle_duplicates(remote_fencing_op_t * op, xmlNode * data, int rc)
data              422 fencing/remote.c         remote_fencing_op_t *other = iter->data;
data              429 fencing/remote.c             remote_op_done(other, data, rc, TRUE);
data              464 fencing/remote.c remote_op_done(remote_fencing_op_t * op, xmlNode * data, int rc, int dup)
data              481 fencing/remote.c     if (!op->delegate && data && rc != -ENODEV && rc != -EHOSTUNREACH) {
data              482 fencing/remote.c         xmlNode *ndata = get_xpath_object("//@" F_STONITH_DELEGATE, data, LOG_TRACE);
data              486 fencing/remote.c             op->delegate = crm_element_value_copy(data, F_ORIG);
data              490 fencing/remote.c     if (data == NULL) {
data              491 fencing/remote.c         data = create_xml_node(NULL, "remote-op");
data              492 fencing/remote.c         local_data = data;
data              498 fencing/remote.c     subt = crm_element_value(data, F_SUBTYPE);
data              516 fencing/remote.c     handle_local_reply_and_notify(op, data, rc);
data              519 fencing/remote.c         handle_duplicates(op, data, rc);
data              599 fencing/remote.c remote_op_query_timeout(gpointer data)
data              601 fencing/remote.c     remote_fencing_op_t *op = data;
data              672 fencing/remote.c         op->automatic_list = g_list_remove(op->automatic_list, match->data);
data              687 fencing/remote.c         op->devices_list = g_list_append(op->devices_list, strdup(lpc->data));
data             1136 fencing/remote.c         st_query_result_t *peer = iter->data;
data             1174 fencing/remote.c             device = op->devices->data;
data             1311 fencing/remote.c                     const st_query_result_t *peer = iter->data;
data             1313 fencing/remote.c                     if (find_peer_device(op, peer, device_list->data)) {
data             1315 fencing/remote.c                                                             device_list->data);
data             1376 fencing/remote.c         remote_fencing_op_t *dup = iter->data;
data             1379 fencing/remote.c         report_timeout_period(iter->data, op_timeout);
data             1463 fencing/remote.c         device = op->devices->data;
data             1634 fencing/remote.c                 st_query_result_t *peer = iter->data;
data             1639 fencing/remote.c                 match = find_peer_device(op, peer, device->data);
data             1945 fencing/remote.c     if (op->devices && device && safe_str_neq(op->devices->data, device)) {
data             1948 fencing/remote.c                 device, op->devices->data, op->action, op->target);
data              267 fencing/standalone_config.c     xmlNode *data;
data              275 fencing/standalone_config.c         data = create_level_registration_xml(topo->node_name, NULL, NULL, NULL,
data              278 fencing/standalone_config.c         dump = dump_xml_formatted(data);
data              281 fencing/standalone_config.c         res |= stonith_level_register(data, NULL);
data              283 fencing/standalone_config.c         free_xml(data);
data              294 fencing/standalone_config.c     xmlNode *data;
data              311 fencing/standalone_config.c     data = create_device_registration_xml(dev->name, __FUNCTION__, dev->agent, params);
data              313 fencing/standalone_config.c     dump = dump_xml_formatted(data);
data              316 fencing/standalone_config.c     res = stonith_device_register(data, NULL, FALSE);
data              319 fencing/standalone_config.c     free_xml(data);
data              131 fencing/test.c st_global_callback(stonith_t * stonith, stonith_callback_data_t * data)
data              133 fencing/test.c     crm_notice("Call id %d completed with rc %d", data->call_id, data->rc);
data              369 fencing/test.c mainloop_callback(stonith_t * stonith, stonith_callback_data_t * data)
data              371 fencing/test.c     callback_rc = data->rc;
data              122 include/crm/cib.h     int (*create) (cib_t * cib, const char *section, xmlNode * data, int call_options);
data              123 include/crm/cib.h     int (*modify) (cib_t * cib, const char *section, xmlNode * data, int call_options);
data              124 include/crm/cib.h     int (*update) (cib_t * cib, const char *section, xmlNode * data, int call_options);
data              125 include/crm/cib.h     int (*replace) (cib_t * cib, const char *section, xmlNode * data, int call_options);
data              126 include/crm/cib.h     int (*delete) (cib_t * cib, const char *section, xmlNode * data, int call_options);
data              129 include/crm/cib.h     int (*delete_absolute) (cib_t * cib, const char *section, xmlNode * data, int call_options);
data              183 include/crm/cib.h #  define add_cib_op_callback(cib, id, flag, data, fn) do {             \
data              184 include/crm/cib.h         cib->cmds->register_callback(cib, id, 120, flag, data, #fn, fn); \
data              131 include/crm/cib/internal.h                        const char *section, xmlNode * data, int call_options,
data              135 include/crm/cib/internal.h void cib_native_notify(gpointer data, gpointer user_data);
data              212 include/crm/cib/internal.h                     const char *section, xmlNode * data,
data              150 include/crm/cluster.h                               xmlNode * data, gboolean ordered);
data              190 include/crm/cluster.h gboolean send_cluster_text(int class, const char *data, gboolean local,
data               55 include/crm/cluster/internal.h     char data[0];
data              217 include/crm/cluster/internal.h         memcpy(target->data, source->data, ais_data_len(target));
data              391 include/crm/cluster/internal.h gboolean check_message_sanity(const AIS_Message * msg, const char *data);
data               64 include/crm/common/internal.h void g_hash_destroy_str(gpointer data);
data               70 include/crm/common/internal.h bool crm_compress_string(const char *data, int length, int max, char **result,
data              124 include/crm/common/ipcs.h xmlNode *crm_ipcs_recv(crm_client_t * c, void *data, size_t size, uint32_t * id, uint32_t * flags);
data              103 include/crm/common/logging.h                       const char *prefix, xmlNode * data, int depth, gboolean formatted);
data              201 include/crm/common/xml.h int crm_element_value_int(xmlNode * data, const char *name, int *dest);
data              202 include/crm/common/xml.h char *crm_element_value_copy(xmlNode * data, const char *name);
data              203 include/crm/common/xml.h int crm_element_value_const_int(const xmlNode * data, const char *name, int *dest);
data              204 include/crm/common/xml.h const char *crm_element_value_const(const xmlNode * data, const char *name);
data              214 include/crm/common/xml.h const char *crm_element_value(xmlNode * data, const char *name);
data              405 include/crm/common/xml.h void crm_destroy_xml(gpointer data);
data              130 include/crm/compatibility.h         free(gIter->data);
data              255 include/crm/compatibility.h 	    child = (child_type *) __crm_iter_head->data;		\
data              249 include/crm/pengine/internal.h extern void destroy_ticket(gpointer data);
data              320 include/crm/pengine/internal.h bool remote_id_conflict(const char *remote_name, pe_working_set_t *data);
data              311 include/crm/stonith-ng.h         void (*callback)(stonith_t *st, stonith_callback_data_t *data));
data              353 include/crm_internal.h void crm_xml_dump(xmlNode * data, int options, char **buffer, int *offset, int *max, int depth);
data              385 include/crm_internal.h void remote_proxy_disconnected(gpointer data);
data              386 include/crm_internal.h void remote_proxy_free(gpointer data);
data              113 lib/ais/plugin.c gboolean check_message_sanity(const AIS_Message * msg, const char *data);
data              988 lib/ais/plugin.c     if (check_message_sanity(msg, ((const AIS_Message *)msg)->data) == FALSE) {
data             1001 lib/ais/plugin.c     AIS_ASSERT(check_message_sanity(mutable, mutable->data));
data             1170 lib/ais/plugin.c     struct member_loop_data *data = user_data;
data             1173 lib/ais/plugin.c     data->string = append_member(data->string, node);
data             1180 lib/ais/plugin.c     struct member_loop_data data;
data             1183 lib/ais/plugin.c     ais_malloc0(data.string, size);
data             1194 lib/ais/plugin.c     snprintf(data.string, size,
data             1199 lib/ais/plugin.c     g_hash_table_foreach(membership_list, member_loop_fn, &data);
data             1200 lib/ais/plugin.c     size = strlen(data.string);
data             1201 lib/ais/plugin.c     data.string = realloc_safe(data.string, size + 9);       /* 9 = </nodes> + nul */
data             1202 lib/ais/plugin.c     sprintf(data.string + size, "</nodes>");
data             1203 lib/ais/plugin.c     return data.string;
data             1209 lib/ais/plugin.c     char *data = pcmk_generate_membership_data();
data             1219 lib/ais/plugin.c         send_client_msg(async_conn, crm_class_members, crm_msg_none, data);
data             1221 lib/ais/plugin.c     ais_free(data);
data             1228 lib/ais/plugin.c     char *data = get_ais_data(ais_msg);
data             1233 lib/ais/plugin.c     if (data != NULL) {
data             1234 lib/ais/plugin.c         char *bcast = ais_concat("remove-peer", data, ':');
data             1241 lib/ais/plugin.c     ais_free(data);
data             1248 lib/ais/plugin.c     char *data = NULL;
data             1250 lib/ais/plugin.c     ais_malloc0(data, size);
data             1252 lib/ais/plugin.c     snprintf(data, size, "<quorum id=\"" U64T "\" quorate=\"%s\" expected=\"%u\" actual=\"%u\"/>",
data             1256 lib/ais/plugin.c     send_client_msg(conn, crm_class_quorum, crm_msg_none, data);
data             1257 lib/ais/plugin.c     ais_free(data);
data             1265 lib/ais/plugin.c     char *data = get_ais_data(ais_msg);
data             1275 lib/ais/plugin.c     if (data != NULL && strlen(data) > 0) {
data             1276 lib/ais/plugin.c         int value = ais_get_int(data, NULL);
data             1282 lib/ais/plugin.c     ais_free(data);
data             1289 lib/ais/plugin.c     char *data = get_ais_data(ais_msg);
data             1298 lib/ais/plugin.c     if (ais_str_eq("true", data)) {
data             1309 lib/ais/plugin.c     ais_free(data);
data             1334 lib/ais/plugin.c ghash_send_update(gpointer key, gpointer value, gpointer data)
data             1336 lib/ais/plugin.c     if (send_client_msg(value, crm_class_members, crm_msg_none, data) != 0) {
data             1356 lib/ais/plugin.c check_message_sanity(const AIS_Message * msg, const char *data)
data             1390 lib/ais/plugin.c     if (sane && data && msg->is_compressed == FALSE) {
data             1391 lib/ais/plugin.c         int str_size = strlen(data) + 1;
data             1403 lib/ais/plugin.c                 ais_trace("bad_data[%d]: %d / '%c'", lpc, data[lpc], data[lpc]);
data             1473 lib/ais/plugin.c     if (check_message_sanity(mutable, mutable->data) == FALSE) {
data             1592 lib/ais/plugin.c         ais_trace("Message sent: %.80s", mutable->data);
data             1595 lib/ais/plugin.c     AIS_CHECK(rc == 0, ais_err("Message not sent (%d): %.120s", rc, mutable->data));
data             1672 lib/ais/plugin.c ghash_send_removal(gpointer key, gpointer value, gpointer data)
data             1675 lib/ais/plugin.c     if (send_client_msg(value, crm_class_rmpeer, crm_msg_none, data) != 0) {
data             1732 lib/ais/plugin.c             char *node_id_s = gIter->data;
data             1747 lib/ais/plugin.c     char *data = get_ais_data(msg);
data             1754 lib/ais/plugin.c                msg->sender.uname == local_uname ? "false" : "true", ais_data_len(msg), data);
data             1756 lib/ais/plugin.c     if (data && len > 12 && strncmp("remove-peer:", data, 12) == 0) {
data             1757 lib/ais/plugin.c         char *node = data + 12;
data             1762 lib/ais/plugin.c     ais_free(data);
data               45 lib/ais/utils.c     char *data = get_ais_data(msg);
data               54 lib/ais/utils.c                                 ais_data_len(msg), data);
data               62 lib/ais/utils.c     ais_free(data);
data              282 lib/ais/utils.c destroy_ais_node(gpointer data)
data              284 lib/ais/utils.c     crm_node_t *node = data;
data              388 lib/ais/utils.c append_member(char *data, crm_node_t * node)
data              394 lib/ais/utils.c     if (data) {
data              395 lib/ais/utils.c         size = strlen(data);
data              412 lib/ais/utils.c     data = realloc_safe(data, size);
data              414 lib/ais/utils.c     offset += snprintf(data + offset, size - offset, "<node id=\"%u\" ", node->id);
data              416 lib/ais/utils.c         offset += snprintf(data + offset, size - offset, "uname=\"%s\" ", node->uname);
data              418 lib/ais/utils.c     offset += snprintf(data + offset, size - offset, "state=\"%s\" ", node->state);
data              419 lib/ais/utils.c     offset += snprintf(data + offset, size - offset, "born=\"" U64T "\" ", node->born);
data              420 lib/ais/utils.c     offset += snprintf(data + offset, size - offset, "seen=\"" U64T "\" ", node->last_seen);
data              421 lib/ais/utils.c     offset += snprintf(data + offset, size - offset, "votes=\"%d\" ", node->votes);
data              422 lib/ais/utils.c     offset += snprintf(data + offset, size - offset, "processes=\"%u\" ", node->processes);
data              424 lib/ais/utils.c         offset += snprintf(data + offset, size - offset, "addr=\"%s\" ", node->addr);
data              427 lib/ais/utils.c         offset += snprintf(data + offset, size - offset, "version=\"%s\" ", node->version);
data              429 lib/ais/utils.c     offset += snprintf(data + offset, size - offset, "/>");
data              431 lib/ais/utils.c     return data;
data              461 lib/ais/utils.c         uncompressed = strdup(msg->data);
data              466 lib/ais/utils.c         rc = BZ2_bzBuffToBuffDecompress(uncompressed, &new_size, (char *)msg->data,
data              479 lib/ais/utils.c send_plugin_msg(enum crm_ais_msg_types type, const char *host, const char *data)
data              488 lib/ais/utils.c     if (data != NULL) {
data              489 lib/ais/utils.c         data_len = 1 + strlen(data);
data              500 lib/ais/utils.c     if (data != NULL) {
data              501 lib/ais/utils.c         memcpy(ais_msg->data, data, data_len);
data              551 lib/ais/utils.c                 const char *data)
data              564 lib/ais/utils.c     if (data != NULL) {
data              565 lib/ais/utils.c         data_len = 1 + strlen(data);
data              577 lib/ais/utils.c     if (data != NULL) {
data              578 lib/ais/utils.c         memcpy(ais_msg->data, data, data_len);
data               82 lib/ais/utils.h extern void destroy_ais_node(gpointer data);
data               88 lib/ais/utils.h extern char *append_member(char *data, crm_node_t * node);
data              100 lib/ais/utils.h extern int send_plugin_msg(enum crm_ais_msg_types type, const char *host, const char *data);
data              102 lib/ais/utils.h                            enum crm_ais_msg_types type, const char *data);
data              144 lib/cib/cib_client.c cib_client_create(cib_t * cib, const char *section, xmlNode * data, int call_options)
data              147 lib/cib/cib_client.c     return cib_internal_op(cib, CIB_OP_CREATE, NULL, section, data, NULL, call_options, NULL);
data              151 lib/cib/cib_client.c cib_client_modify(cib_t * cib, const char *section, xmlNode * data, int call_options)
data              154 lib/cib/cib_client.c     return cib_internal_op(cib, CIB_OP_MODIFY, NULL, section, data, NULL, call_options, NULL);
data              158 lib/cib/cib_client.c cib_client_update(cib_t * cib, const char *section, xmlNode * data, int call_options)
data              161 lib/cib/cib_client.c     return cib_internal_op(cib, CIB_OP_MODIFY, NULL, section, data, NULL, call_options, NULL);
data              165 lib/cib/cib_client.c cib_client_replace(cib_t * cib, const char *section, xmlNode * data, int call_options)
data              168 lib/cib/cib_client.c     return cib_internal_op(cib, CIB_OP_REPLACE, NULL, section, data, NULL, call_options, NULL);
data              172 lib/cib/cib_client.c cib_client_delete(cib_t * cib, const char *section, xmlNode * data, int call_options)
data              175 lib/cib/cib_client.c     return cib_internal_op(cib, CIB_OP_DELETE, NULL, section, data, NULL, call_options, NULL);
data              179 lib/cib/cib_client.c cib_client_delete_absolute(cib_t * cib, const char *section, xmlNode * data, int call_options)
data              182 lib/cib/cib_client.c     return cib_internal_op(cib, CIB_OP_DELETE_ALT, NULL, section, data, NULL, call_options, NULL);
data              193 lib/cib/cib_client.c cib_destroy_op_callback(gpointer data)
data              195 lib/cib/cib_client.c     cib_callback_client_t *blob = data;
data              500 lib/cib/cib_client.c         cib_notify_client_t *client = (cib_notify_client_t *)l->data;
data              535 lib/cib/cib_client.c         cib_notify_client_t *list_client = list_item->data;
data              580 lib/cib/cib_client.c cib_async_timeout_handler(gpointer data)
data              582 lib/cib/cib_client.c     struct timer_rec_s *timer = data;
data               48 lib/cib/cib_file.c                         xmlNode * data, xmlNode ** output_data, int call_options);
data               51 lib/cib/cib_file.c                                  xmlNode * data, xmlNode ** output_data, int call_options,
data              766 lib/cib/cib_file.c                     xmlNode * data, xmlNode ** output_data, int call_options)
data              768 lib/cib/cib_file.c     return cib_file_perform_op_delegate(cib, op, host, section, data, output_data, call_options,
data              774 lib/cib/cib_file.c                              xmlNode * data, xmlNode ** output_data, int call_options,
data              818 lib/cib/cib_file.c     request = cib_create_op(cib->call_id, "dummy-token", op, host, section, data, call_options, user_name);
data              827 lib/cib/cib_file.c     if (section != NULL && data != NULL && crm_str_eq(crm_element_name(data), XML_TAG_CIB, TRUE)) {
data              828 lib/cib/cib_file.c         data = get_object_root(section, data);
data              832 lib/cib/cib_file.c                         section, request, data, TRUE, &changed, in_mem_cib, &result_cib, &cib_diff,
data               43 lib/cib/cib_native.c                           xmlNode * data, xmlNode ** output_data, int call_options);
data               46 lib/cib/cib_native.c                                    const char *section, xmlNode * data, xmlNode ** output_data,
data              329 lib/cib/cib_native.c                       xmlNode * data, xmlNode ** output_data, int call_options)
data              332 lib/cib/cib_native.c                                           data, output_data, call_options, NULL);
data              337 lib/cib/cib_native.c                                xmlNode * data, xmlNode ** output_data, int call_options,
data              378 lib/cib/cib_native.c         cib_create_op(cib->call_id, native->token, op, host, section, data, call_options,
data               83 lib/cib/cib_remote.c                           xmlNode * data, xmlNode ** output_data, int call_options,
data              486 lib/cib/cib_remote.c                       xmlNode * data, xmlNode ** output_data, int call_options, const char *name)
data              521 lib/cib/cib_remote.c         cib_create_op(cib->call_id, private->callback.token, op, host, section, data, call_options,
data              589 lib/cib/cib_utils.c               xmlNode * data, int call_options, const char *user_name)
data              612 lib/cib/cib_utils.c     if (data != NULL) {
data              613 lib/cib/cib_utils.c         add_message_xml(op_msg, F_CIB_CALLDATA, data);
data              670 lib/cib/cib_utils.c cib_native_notify(gpointer data, gpointer user_data)
data              673 lib/cib/cib_utils.c     cib_notify_client_t *entry = data;
data              836 lib/cib/cib_utils.c                 const char *section, xmlNode * data,
data              840 lib/cib/cib_utils.c                      const char *section, xmlNode * data,
data              850 lib/cib/cib_utils.c     return delegate(cib, op, host, section, data, output_data, call_options, user_name);
data              271 lib/cluster/cluster.c send_cluster_message(crm_node_t * node, enum crm_ais_msg_types service, xmlNode * data,
data              277 lib/cluster/cluster.c         return send_cluster_message_cs(data, FALSE, node, service);
data              282 lib/cluster/cluster.c         return send_ha_message(heartbeat_cluster, data, node ? node->uname : NULL, ordered);
data              377 lib/cluster/corosync.c check_message_sanity(const AIS_Message * msg, const char *data)
data              404 lib/cluster/corosync.c     if (sane && data && msg->is_compressed == FALSE) {
data              405 lib/cluster/corosync.c         int str_size = strlen(data) + 1;
data              417 lib/cluster/corosync.c                 crm_debug("bad_data[%d]: %d / '%c'", lpc, data[lpc], data[lpc]);
data               44 lib/cluster/cpg.c gboolean(*pcmk_cpg_dispatch_fn) (int kind, const char *from, const char *data) = NULL;
data              118 lib/cluster/cpg.c static ssize_t crm_cs_flush(gpointer data);
data              121 lib/cluster/cpg.c crm_cs_flush_cb(gpointer data)
data              124 lib/cluster/cpg.c     crm_cs_flush(data);
data              130 lib/cluster/cpg.c crm_cs_flush(gpointer data)
data              136 lib/cluster/cpg.c     cpg_handle_t *handle = (cpg_handle_t *)data;
data              158 lib/cluster/cpg.c         struct iovec *iov = cs_message_queue->data;
data              194 lib/cluster/cpg.c         cs_message_timer = g_timeout_add(delay_ms, crm_cs_flush_cb, data);
data              236 lib/cluster/cpg.c     char *data = NULL;
data              301 lib/cluster/cpg.c         rc = BZ2_bzBuffToBuffDecompress(uncompressed, &new_size, msg->data, msg->compressed_size, 1, 0);
data              312 lib/cluster/cpg.c         data = uncompressed;
data              314 lib/cluster/cpg.c     } else if (check_message_sanity(msg, data) == FALSE) {
data              317 lib/cluster/cpg.c     } else if (safe_str_eq("identify", data)) {
data              325 lib/cluster/cpg.c         data = strdup(msg->data);
data              334 lib/cluster/cpg.c         uint32_t id = crm_int_helper(data, NULL);
data              336 lib/cluster/cpg.c         crm_info("Removing peer %s/%u", data, id);
data              338 lib/cluster/cpg.c         free(data);
data              347 lib/cluster/cpg.c     crm_trace("Payload: %.200s", data);
data              348 lib/cluster/cpg.c     return data;
data              358 lib/cluster/cpg.c     free(data);
data              512 lib/cluster/cpg.c     char *data = NULL;
data              514 lib/cluster/cpg.c     data = dump_xml_unformatted(msg);
data              515 lib/cluster/cpg.c     rc = send_cluster_text(crm_class_cluster, data, local, node, dest);
data              516 lib/cluster/cpg.c     free(data);
data              521 lib/cluster/cpg.c send_cluster_text(int class, const char *data,
data              549 lib/cluster/cpg.c     if (data == NULL) {
data              550 lib/cluster/cpg.c         data = "";
data              594 lib/cluster/cpg.c     msg->size = 1 + strlen(data);
data              599 lib/cluster/cpg.c         memcpy(msg->data, data, msg->size);
data              604 lib/cluster/cpg.c         char *uncompressed = strdup(data);
data              610 lib/cluster/cpg.c             memcpy(msg->data, compressed, new_size);
data              617 lib/cluster/cpg.c             memcpy(msg->data, data, msg->size);
data              631 lib/cluster/cpg.c                   msg->compressed_size, data);
data              635 lib/cluster/cpg.c                   msg->size, data);
data              228 lib/cluster/legacy.c         xmlNode *xml = string2xml(msg->data);
data              231 lib/cluster/legacy.c             crm_err("Invalid membership update: %s", msg->data);
data              284 lib/cluster/legacy.c     char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);
data              286 lib/cluster/legacy.c     free(data);
data              595 lib/cluster/legacy.c     void (*callback) (gpointer data) = user_data;
data              730 lib/cluster/legacy.c check_message_sanity(const AIS_Message * msg, const char *data)
data              757 lib/cluster/legacy.c     if (sane && data && msg->is_compressed == FALSE) {
data              758 lib/cluster/legacy.c         int str_size = strlen(data) + 1;
data              770 lib/cluster/legacy.c                 crm_debug("bad_data[%d]: %d / '%c'", lpc, data[lpc], data[lpc]);
data              191 lib/cluster/membership.c     struct refresh_data *data = user_data;
data              192 lib/cluster/membership.c     const char *remote = crm_element_value(result, data->field);
data              199 lib/cluster/membership.c     if (data->has_state) {
data              259 lib/cluster/membership.c     struct refresh_data data;
data              270 lib/cluster/membership.c     data.field = "id";
data              271 lib/cluster/membership.c     data.has_state = TRUE;
data              273 lib/cluster/membership.c                              remote_cache_refresh_helper, &data);
data              281 lib/cluster/membership.c     data.field = "value";
data              282 lib/cluster/membership.c     data.has_state = FALSE;
data              284 lib/cluster/membership.c                              remote_cache_refresh_helper, &data);
data              285 lib/cluster/membership.c     data.field = "id";
data              286 lib/cluster/membership.c     data.has_state = FALSE;
data              288 lib/cluster/membership.c                              remote_cache_refresh_helper, &data);
data              404 lib/cluster/membership.c destroy_crm_node(gpointer data)
data              406 lib/cluster/membership.c     crm_node_t *node = data;
data              139 lib/common/cib_secrets.c         key = (char *)(l->data);
data              391 lib/common/ipc.c         struct iovec *event = c->event_queue->data;
data              445 lib/common/ipc.c crm_ipcs_recv(crm_client_t * c, void *data, size_t size, uint32_t * id, uint32_t * flags)
data              449 lib/common/ipc.c     char *text = ((char *)data) + sizeof(struct crm_ipc_response_header);
data              450 lib/common/ipc.c     struct crm_ipc_response_header *header = data;
data              453 lib/common/ipc.c         *id = ((struct qb_ipc_response_header *)data)->id;
data              502 lib/common/ipc.c crm_ipcs_flush_events_cb(gpointer data)
data              504 lib/common/ipc.c     crm_client_t *c = data;
data              546 lib/common/ipc.c         struct iovec *event = c->event_queue->data;
data              425 lib/common/mainloop.c     void *data;
data              431 lib/common/mainloop.c gio_read_socket(GIOChannel * gio, GIOCondition condition, gpointer data)
data              433 lib/common/mainloop.c     struct gio_to_qb_poll *adaptor = (struct gio_to_qb_poll *)data;
data              436 lib/common/mainloop.c     crm_trace("%p.%d %d", data, fd, condition);
data              442 lib/common/mainloop.c     return (adaptor->fn(fd, condition, adaptor->data) == 0);
data              446 lib/common/mainloop.c gio_poll_destroy(gpointer data)
data              448 lib/common/mainloop.c     struct gio_to_qb_poll *adaptor = (struct gio_to_qb_poll *)data;
data              461 lib/common/mainloop.c                          void *data, qb_ipcs_dispatch_fn_t fn, int32_t add)
data              501 lib/common/mainloop.c     adaptor->data = data;
data              529 lib/common/mainloop.c                       void *data, qb_ipcs_dispatch_fn_t fn)
data              531 lib/common/mainloop.c     return gio_poll_dispatch_update(p, fd, evts, data, fn, QB_TRUE);
data              536 lib/common/mainloop.c                       void *data, qb_ipcs_dispatch_fn_t fn)
data              538 lib/common/mainloop.c     return gio_poll_dispatch_update(p, fd, evts, data, fn, QB_FALSE);
data              642 lib/common/mainloop.c mainloop_gio_callback(GIOChannel * gio, GIOCondition condition, gpointer data)
data              645 lib/common/mainloop.c     mainloop_io_t *client = data;
data             1012 lib/common/mainloop.c         mainloop_child_t *child = iter->data;
data             1052 lib/common/mainloop.c         child = iter->data;
data               74 lib/common/strings.c g_hash_destroy_str(gpointer data)
data               76 lib/common/strings.c     free(data);
data              413 lib/common/strings.c crm_compress_string(const char *data, int length, int max, char **result, unsigned int *result_len)
data              417 lib/common/strings.c     char *uncompressed = strdup(data);
data              275 lib/common/xml.c __xml_acl_free(void *data)
data              277 lib/common/xml.c     if(data) {
data              278 lib/common/xml.c         xml_acl_t *acl = data;
data              286 lib/common/xml.c __xml_deleted_obj_free(void *data)
data              288 lib/common/xml.c     if(data) {
data              289 lib/common/xml.c         xml_deleted_obj_t *deleted_obj = data;
data              555 lib/common/xml.c         xml_acl_t *acl = aIter->data;
data              727 lib/common/xml.c         xml_acl_t *acl = aIter->data;
data             1117 lib/common/xml.c             xml_deleted_obj_t *deleted_obj = gIter->data;
data             1264 lib/common/xml.c         xml_deleted_obj_t *deleted_obj = gIter->data;
data             1384 lib/common/xml.c                   const char *prefix, xmlNode * data, int depth, int options);
data             1556 lib/common/xml.c         xml_deleted_obj_t *deleted_obj = gIter->data;
data             3306 lib/common/xml.c                   const char *prefix, xmlNode * data, int depth, int options)
data             3316 lib/common/xml.c     if(data == NULL) {
data             3320 lib/common/xml.c     name = crm_element_name(data);
data             3327 lib/common/xml.c         if (data->type == XML_COMMENT_NODE) {
data             3328 lib/common/xml.c             buffer_print(buffer, max, offset, "<!--%s-->", data->content);
data             3333 lib/common/xml.c             hidden = crm_element_value(data, "hidden");
data             3334 lib/common/xml.c             for (pIter = crm_first_attr(data); pIter != NULL; pIter = pIter->next) {
data             3358 lib/common/xml.c             if(xml_has_children(data) == FALSE) {
data             3373 lib/common/xml.c     if(data->type == XML_COMMENT_NODE) {
data             3376 lib/common/xml.c     } else if(xml_has_children(data) == FALSE) {
data             3383 lib/common/xml.c         for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) {
data             3401 lib/common/xml.c                          const char *prefix, xmlNode * data, int depth, int options)
data             3408 lib/common/xml.c     if(data == NULL) {
data             3412 lib/common/xml.c     p = data->_private;
data             3420 lib/common/xml.c                           prefix_m, data, depth, options|xml_log_option_open|xml_log_option_close|xml_log_option_children);
data             3443 lib/common/xml.c                           flags, data, depth, options|xml_log_option_open);
data             3445 lib/common/xml.c         for (pIter = crm_first_attr(data); pIter != NULL; pIter = pIter->next) {
data             3450 lib/common/xml.c                 const char *value = crm_element_value(data, aname);
data             3456 lib/common/xml.c                 const char *value = crm_element_value(data, aname);
data             3478 lib/common/xml.c         for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) {
data             3483 lib/common/xml.c                           prefix, data, depth, options|xml_log_option_close);
data             3486 lib/common/xml.c         for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) {
data             3497 lib/common/xml.c                  const char *prefix, xmlNode * data, int depth, int options)
data             3508 lib/common/xml.c     if (data == NULL) {
data             3515 lib/common/xml.c         __xml_log_change_element(log_level, file, function, line, prefix, data, depth, options);
data             3521 lib/common/xml.c             && (data->children == NULL || crm_element_value(data, XML_DIFF_MARKER))) {
data             3528 lib/common/xml.c                    && (data->children == NULL || crm_element_value(data, XML_DIFF_MARKER))) {
data             3539 lib/common/xml.c         for (a_child = __xml_first_child(data); a_child != NULL; a_child = __xml_next(a_child)) {
data             3543 lib/common/xml.c         __xml_log_element(log_level, file, function, line, prefix, data, depth,
data             3550 lib/common/xml.c dump_filtered_xml(xmlNode * data, int options, char **buffer, int *offset, int *max)
data             3560 lib/common/xml.c     for (xIter = crm_first_attr(data); xIter != NULL; xIter = xIter->next) {
data             3579 lib/common/xml.c dump_xml_element(xmlNode * data, int options, char **buffer, int *offset, int *max, int depth)
data             3587 lib/common/xml.c     if (data == NULL) {
data             3597 lib/common/xml.c     name = crm_element_name(data);
data             3604 lib/common/xml.c         dump_filtered_xml(data, options, buffer, offset, max);
data             3609 lib/common/xml.c         for (xIter = crm_first_attr(data); xIter != NULL; xIter = xIter->next) {
data             3614 lib/common/xml.c     if (data->children == NULL) {
data             3625 lib/common/xml.c     if (data->children) {
data             3627 lib/common/xml.c         for(xChild = data->children; xChild != NULL; xChild = xChild->next) {
data             3641 lib/common/xml.c dump_xml_text(xmlNode * data, int options, char **buffer, int *offset, int *max, int depth)
data             3647 lib/common/xml.c     if (data == NULL) {
data             3659 lib/common/xml.c     buffer_print(*buffer, *max, *offset, "%s", data->content);
data             3668 lib/common/xml.c dump_xml_comment(xmlNode * data, int options, char **buffer, int *offset, int *max, int depth)
data             3674 lib/common/xml.c     if (data == NULL) {
data             3687 lib/common/xml.c     buffer_print(*buffer, *max, *offset, "%s", data->content);
data             3696 lib/common/xml.c crm_xml_dump(xmlNode * data, int options, char **buffer, int *offset, int *max, int depth)
data             3698 lib/common/xml.c     if(data == NULL) {
data             3722 lib/common/xml.c         doc = getDocPtr(data);
data             3740 lib/common/xml.c         *max = xmlNodeDump(xml_buffer, doc, data, 0, (options & xml_log_option_formatted));
data             3747 lib/common/xml.c             crm_log_xml_trace(data, "Long time");
data             3756 lib/common/xml.c     switch(data->type) {
data             3759 lib/common/xml.c             dump_xml_element(data, options, buffer, offset, max, depth);
data             3764 lib/common/xml.c                 dump_xml_text(data, options, buffer, offset, max, depth);
data             3768 lib/common/xml.c             dump_xml_comment(data, options, buffer, offset, max, depth);
data             3771 lib/common/xml.c             crm_warn("Unhandled type: %d", data->type);
data             3844 lib/common/xml.c crm_element_value_int(xmlNode * data, const char *name, int *dest)
data             3846 lib/common/xml.c     const char *value = crm_element_value(data, name);
data             3857 lib/common/xml.c crm_element_value_const_int(const xmlNode * data, const char *name, int *dest)
data             3859 lib/common/xml.c     return crm_element_value_int((xmlNode *) data, name, dest);
data             3863 lib/common/xml.c crm_element_value_const(const xmlNode * data, const char *name)
data             3865 lib/common/xml.c     return crm_element_value((xmlNode *) data, name);
data             3869 lib/common/xml.c crm_element_value_copy(xmlNode * data, const char *name)
data             3872 lib/common/xml.c     const char *value = crm_element_value(data, name);
data             5000 lib/common/xml.c dump_pair(gpointer data, gpointer user_data)
data             5002 lib/common/xml.c     name_value_t *pair = data;
data             5165 lib/common/xml.c crm_element_value(xmlNode * data, const char *name)
data             5169 lib/common/xml.c     if (data == NULL) {
data             5171 lib/common/xml.c         CRM_LOG_ASSERT(data != NULL);
data             5175 lib/common/xml.c         crm_err("Couldn't find NULL in %s", crm_element_name(data));
data             5179 lib/common/xml.c     attr = xmlHasProp(data, (const xmlChar *)name);
data             5187 lib/common/xml.c crm_destroy_xml(gpointer data)
data             5189 lib/common/xml.c     free_xml(data);
data               89 lib/fencing/st_client.c     void (*op_callback) (stonith_t * st, stonith_callback_data_t * data);
data              102 lib/fencing/st_client.c     void (*callback) (stonith_t * st, stonith_callback_data_t * data);
data              151 lib/fencing/st_client.c xmlNode *stonith_create_op(int call_id, const char *token, const char *op, xmlNode * data,
data              153 lib/fencing/st_client.c int stonith_send_command(stonith_t * stonith, const char *op, xmlNode * data,
data              157 lib/fencing/st_client.c static void stonith_send_notification(gpointer data, gpointer user_data);
data              208 lib/fencing/st_client.c     xmlNode *data = create_xml_node(NULL, F_STONITH_DEVICE);
data              209 lib/fencing/st_client.c     xmlNode *args = create_xml_node(data, XML_TAG_ATTRS);
data              219 lib/fencing/st_client.c     crm_xml_add(data, XML_ATTR_ID, id);
data              220 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);
data              221 lib/fencing/st_client.c     crm_xml_add(data, "agent", agent);
data              222 lib/fencing/st_client.c     crm_xml_add(data, "namespace", namespace);
data              224 lib/fencing/st_client.c         crm_xml_add(data, "rsc_provides", rsc_provides);
data              231 lib/fencing/st_client.c     return data;
data              240 lib/fencing/st_client.c     xmlNode *data = NULL;
data              242 lib/fencing/st_client.c     data = create_device_registration_xml(id, namespace, agent, params, NULL);
data              244 lib/fencing/st_client.c     rc = stonith_send_command(st, STONITH_OP_DEVICE_ADD, data, NULL, call_options, 0);
data              245 lib/fencing/st_client.c     free_xml(data);
data              254 lib/fencing/st_client.c     xmlNode *data = NULL;
data              256 lib/fencing/st_client.c     data = create_xml_node(NULL, F_STONITH_DEVICE);
data              257 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);
data              258 lib/fencing/st_client.c     crm_xml_add(data, XML_ATTR_ID, name);
data              259 lib/fencing/st_client.c     rc = stonith_send_command(st, STONITH_OP_DEVICE_DEL, data, NULL, call_options, 0);
data              260 lib/fencing/st_client.c     free_xml(data);
data              271 lib/fencing/st_client.c     xmlNode *data = NULL;
data              275 lib/fencing/st_client.c     data = create_xml_node(NULL, XML_TAG_FENCING_LEVEL);
data              276 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);
data              279 lib/fencing/st_client.c         crm_xml_add(data, XML_ATTR_STONITH_TARGET, node);
data              282 lib/fencing/st_client.c         crm_xml_add(data, XML_ATTR_STONITH_TARGET_PATTERN, pattern);
data              285 lib/fencing/st_client.c         crm_xml_add(data, XML_ATTR_STONITH_TARGET_ATTRIBUTE, attr);
data              286 lib/fencing/st_client.c         crm_xml_add(data, XML_ATTR_STONITH_TARGET_VALUE, value);
data              289 lib/fencing/st_client.c     crm_xml_add_int(data, XML_ATTR_STONITH_INDEX, level);
data              290 lib/fencing/st_client.c     rc = stonith_send_command(st, STONITH_OP_LEVEL_DEL, data, NULL, options, 0);
data              291 lib/fencing/st_client.c     free_xml(data);
data              325 lib/fencing/st_client.c     xmlNode *data;
data              329 lib/fencing/st_client.c     data = create_xml_node(NULL, XML_TAG_FENCING_LEVEL);
data              330 lib/fencing/st_client.c     CRM_CHECK(data, return NULL);
data              332 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);
data              333 lib/fencing/st_client.c     crm_xml_add_int(data, XML_ATTR_ID, level);
data              334 lib/fencing/st_client.c     crm_xml_add_int(data, XML_ATTR_STONITH_INDEX, level);
data              337 lib/fencing/st_client.c         crm_xml_add(data, XML_ATTR_STONITH_TARGET, node);
data              340 lib/fencing/st_client.c         crm_xml_add(data, XML_ATTR_STONITH_TARGET_PATTERN, pattern);
data              343 lib/fencing/st_client.c         crm_xml_add(data, XML_ATTR_STONITH_TARGET_ATTRIBUTE, attr);
data              344 lib/fencing/st_client.c         crm_xml_add(data, XML_ATTR_STONITH_TARGET_VALUE, value);
data              358 lib/fencing/st_client.c             free_xml(data);
data              365 lib/fencing/st_client.c     crm_xml_add(data, XML_ATTR_STONITH_DEVICES, list);
data              368 lib/fencing/st_client.c     return data;
data              378 lib/fencing/st_client.c     xmlNode *data = create_level_registration_xml(node, pattern, attr, value,
data              380 lib/fencing/st_client.c     CRM_CHECK(data != NULL, return -EINVAL);
data              382 lib/fencing/st_client.c     rc = stonith_send_command(st, STONITH_OP_LEVEL_ADD, data, NULL, options, 0);
data              383 lib/fencing/st_client.c     free_xml(data);
data              603 lib/fencing/st_client.c st_child_term(gpointer data)
data              606 lib/fencing/st_client.c     stonith_action_t *track = data;
data              619 lib/fencing/st_client.c st_child_kill(gpointer data)
data              622 lib/fencing/st_client.c     stonith_action_t *track = data;
data             1410 lib/fencing/st_client.c     xmlNode *data = NULL;
data             1416 lib/fencing/st_client.c     data = create_xml_node(NULL, F_STONITH_DEVICE);
data             1417 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);
data             1418 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_TARGET, target);
data             1419 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ACTION, "off");
data             1420 lib/fencing/st_client.c     rc = stonith_send_command(stonith, STONITH_OP_QUERY, data, &output, call_options, timeout);
data             1447 lib/fencing/st_client.c     free_xml(data);
data             1458 lib/fencing/st_client.c     xmlNode *data = NULL;
data             1460 lib/fencing/st_client.c     data = create_xml_node(NULL, F_STONITH_DEVICE);
data             1461 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ORIGIN, __FUNCTION__);
data             1462 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_DEVICE, id);
data             1463 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ACTION, action);
data             1464 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_TARGET, victim);
data             1466 lib/fencing/st_client.c     rc = stonith_send_command(stonith, STONITH_OP_EXEC, data, output, call_options, timeout);
data             1467 lib/fencing/st_client.c     free_xml(data);
data             1516 lib/fencing/st_client.c     xmlNode *data = NULL;
data             1518 lib/fencing/st_client.c     data = create_xml_node(NULL, __FUNCTION__);
data             1519 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_TARGET, node);
data             1520 lib/fencing/st_client.c     crm_xml_add(data, F_STONITH_ACTION, action);
data             1521 lib/fencing/st_client.c     crm_xml_add_int(data, F_STONITH_TIMEOUT, timeout);
data             1522 lib/fencing/st_client.c     crm_xml_add_int(data, F_STONITH_TOLERANCE, tolerance);
data             1524 lib/fencing/st_client.c     rc = stonith_send_command(stonith, STONITH_OP_FENCE, data, NULL, call_options, timeout);
data             1525 lib/fencing/st_client.c     free_xml(data);
data             1541 lib/fencing/st_client.c     xmlNode *data = NULL;
data             1548 lib/fencing/st_client.c         data = create_xml_node(NULL, __FUNCTION__);
data             1549 lib/fencing/st_client.c         crm_xml_add(data, F_STONITH_TARGET, node);
data             1552 lib/fencing/st_client.c     rc = stonith_send_command(stonith, STONITH_OP_FENCE_HISTORY, data, &output,
data             1554 lib/fencing/st_client.c     free_xml(data);
data             1670 lib/fencing/st_client.c stonith_create_op(int call_id, const char *token, const char *op, xmlNode * data, int call_options)
data             1686 lib/fencing/st_client.c     if (data != NULL) {
data             1687 lib/fencing/st_client.c         add_message_xml(op_msg, F_STONITH_CALLDATA, data);
data             1694 lib/fencing/st_client.c stonith_destroy_op_callback(gpointer data)
data             1696 lib/fencing/st_client.c     stonith_callback_client_t *blob = data;
data             1904 lib/fencing/st_client.c         stonith_notify_client_t *list_client = list_item->data;
data             1919 lib/fencing/st_client.c stonith_async_timeout_handler(gpointer data)
data             1921 lib/fencing/st_client.c     struct timer_rec_s *timer = data;
data             1976 lib/fencing/st_client.c                 void (*callback) (stonith_t * st, stonith_callback_data_t * data))
data             1978 lib/fencing/st_client.c     stonith_callback_data_t data = { 0, };
data             1980 lib/fencing/st_client.c     data.call_id = call_id;
data             1981 lib/fencing/st_client.c     data.rc = rc;
data             1982 lib/fencing/st_client.c     data.userdata = userdata;
data             1984 lib/fencing/st_client.c     callback(st, &data);
data             1990 lib/fencing/st_client.c                          void (*callback) (stonith_t * st, stonith_callback_data_t * data))
data             2148 lib/fencing/st_client.c     xmlNode *data = get_xpath_object(data_addr, msg, LOG_DEBUG);
data             2157 lib/fencing/st_client.c         if (data) {
data             2158 lib/fencing/st_client.c             event->origin = crm_element_value_copy(data, F_STONITH_ORIGIN);
data             2159 lib/fencing/st_client.c             event->action = crm_element_value_copy(data, F_STONITH_ACTION);
data             2160 lib/fencing/st_client.c             event->target = crm_element_value_copy(data, F_STONITH_TARGET);
data             2161 lib/fencing/st_client.c             event->executioner = crm_element_value_copy(data, F_STONITH_DELEGATE);
data             2162 lib/fencing/st_client.c             event->id = crm_element_value_copy(data, F_STONITH_REMOTE_OP_ID);
data             2163 lib/fencing/st_client.c             event->client_origin = crm_element_value_copy(data, F_STONITH_CLIENTNAME);
data             2164 lib/fencing/st_client.c             event->device = crm_element_value_copy(data, F_STONITH_DEVICE);
data             2193 lib/fencing/st_client.c stonith_send_notification(gpointer data, gpointer user_data)
data             2196 lib/fencing/st_client.c     stonith_notify_client_t *entry = data;
data             2230 lib/fencing/st_client.c stonith_send_command(stonith_t * stonith, const char *op, xmlNode * data, xmlNode ** output_data,
data             2270 lib/fencing/st_client.c     op_msg = stonith_create_op(stonith->call_id, native->token, op, data, call_options);
data              138 lib/lrmd/lrmd_alerts.c         crm_alert_entry_t *entry = (crm_alert_entry_t *)(iter->data);
data              357 lib/lrmd/lrmd_client.c             lrmd_dispatch_internal(lrmd, iter->data);
data              463 lib/lrmd/lrmd_client.c lrmd_create_op(const char *token, const char *op, xmlNode *data, int timeout,
data              478 lib/lrmd/lrmd_client.c     if (data != NULL) {
data              479 lib/lrmd/lrmd_client.c         add_message_xml(op_msg, F_LRMD_CALLDATA, data);
data              792 lib/lrmd/lrmd_client.c lrmd_send_command(lrmd_t *lrmd, const char *op, xmlNode *data,
data              814 lib/lrmd/lrmd_client.c     op_msg = lrmd_create_op(native->token, op, data, timeout, options);
data              866 lib/lrmd/lrmd_client.c     xmlNode *data = create_xml_node(NULL, F_LRMD_RSC);
data              868 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ORIGIN, __FUNCTION__);
data              869 lib/lrmd/lrmd_client.c     rc = lrmd_send_command(lrmd, LRMD_OP_POKE, data, NULL, 0, 0, native->type == CRM_CLIENT_IPC ? TRUE : FALSE);
data              870 lib/lrmd/lrmd_client.c     free_xml(data);
data              881 lib/lrmd/lrmd_client.c     xmlNode *data = create_xml_node(NULL, F_LRMD_OPERATION);
data              883 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ORIGIN, __FUNCTION__);
data              886 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_WATCHDOG, value);
data              888 lib/lrmd/lrmd_client.c     rc = lrmd_send_command(lrmd, LRMD_OP_CHECK, data, NULL, 0, 0, native->type == CRM_CLIENT_IPC ? TRUE : FALSE);
data              889 lib/lrmd/lrmd_client.c     free_xml(data);
data             1012 lib/lrmd/lrmd_client.c             key->data = gnutls_malloc(key_cache_len + 1);
data             1014 lib/lrmd/lrmd_client.c             memcpy(key->data, key_cache, key_cache_len);
data             1032 lib/lrmd/lrmd_client.c     key->data = gnutls_malloc(read_len);
data             1038 lib/lrmd/lrmd_client.c             key->data = gnutls_realloc(key->data, buf_len);
data             1045 lib/lrmd/lrmd_client.c         key->data[cur_len] = next;
data             1052 lib/lrmd/lrmd_client.c         gnutls_free(key->data);
data             1053 lib/lrmd/lrmd_client.c         key->data = 0;
data             1059 lib/lrmd/lrmd_client.c         memcpy(key_cache, key->data, key->size);
data             1157 lib/lrmd/lrmd_client.c     gnutls_free(psk_key.data);
data             1238 lib/lrmd/lrmd_client.c     gnutls_free(psk_key.data);
data             1421 lib/lrmd/lrmd_client.c     xmlNode *data = NULL;
data             1430 lib/lrmd/lrmd_client.c     data = create_xml_node(NULL, F_LRMD_RSC);
data             1432 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ORIGIN, __FUNCTION__);
data             1433 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_RSC_ID, rsc_id);
data             1434 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_CLASS, class);
data             1435 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_PROVIDER, provider);
data             1436 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_TYPE, type);
data             1437 lib/lrmd/lrmd_client.c     rc = lrmd_send_command(lrmd, LRMD_OP_RSC_REG, data, NULL, 0, options, TRUE);
data             1438 lib/lrmd/lrmd_client.c     free_xml(data);
data             1447 lib/lrmd/lrmd_client.c     xmlNode *data = create_xml_node(NULL, F_LRMD_RSC);
data             1449 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ORIGIN, __FUNCTION__);
data             1450 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_RSC_ID, rsc_id);
data             1451 lib/lrmd/lrmd_client.c     rc = lrmd_send_command(lrmd, LRMD_OP_RSC_UNREG, data, NULL, 0, options, TRUE);
data             1452 lib/lrmd/lrmd_client.c     free_xml(data);
data             1491 lib/lrmd/lrmd_client.c     xmlNode *data = create_xml_node(NULL, F_LRMD_RSC);
data             1497 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ORIGIN, __FUNCTION__);
data             1498 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_RSC_ID, rsc_id);
data             1499 lib/lrmd/lrmd_client.c     lrmd_send_command(lrmd, LRMD_OP_RSC_INFO, data, &output, 0, options, TRUE);
data             1500 lib/lrmd/lrmd_client.c     free_xml(data);
data             1636 lib/lrmd/lrmd_client.c     xmlNode *data = create_xml_node(NULL, F_LRMD_RSC);
data             1637 lib/lrmd/lrmd_client.c     xmlNode *args = create_xml_node(data, XML_TAG_ATTRS);
data             1640 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ORIGIN, __FUNCTION__);
data             1641 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_RSC_ID, rsc_id);
data             1642 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_RSC_ACTION, action);
data             1643 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_RSC_USERDATA_STR, userdata);
data             1644 lib/lrmd/lrmd_client.c     crm_xml_add_int(data, F_LRMD_RSC_INTERVAL, interval);
data             1645 lib/lrmd/lrmd_client.c     crm_xml_add_int(data, F_LRMD_TIMEOUT, timeout);
data             1646 lib/lrmd/lrmd_client.c     crm_xml_add_int(data, F_LRMD_RSC_START_DELAY, start_delay);
data             1652 lib/lrmd/lrmd_client.c     rc = lrmd_send_command(lrmd, LRMD_OP_RSC_EXEC, data, NULL, timeout, options, TRUE);
data             1653 lib/lrmd/lrmd_client.c     free_xml(data);
data             1665 lib/lrmd/lrmd_client.c     xmlNode *data = create_xml_node(NULL, F_LRMD_ALERT);
data             1666 lib/lrmd/lrmd_client.c     xmlNode *args = create_xml_node(data, XML_TAG_ATTRS);
data             1669 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ORIGIN, __FUNCTION__);
data             1670 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ALERT_ID, alert_id);
data             1671 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ALERT_PATH, alert_path);
data             1672 lib/lrmd/lrmd_client.c     crm_xml_add_int(data, F_LRMD_TIMEOUT, timeout);
data             1678 lib/lrmd/lrmd_client.c     rc = lrmd_send_command(lrmd, LRMD_OP_ALERT_EXEC, data, NULL, timeout,
data             1680 lib/lrmd/lrmd_client.c     free_xml(data);
data             1690 lib/lrmd/lrmd_client.c     xmlNode *data = create_xml_node(NULL, F_LRMD_RSC);
data             1692 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_ORIGIN, __FUNCTION__);
data             1693 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_RSC_ACTION, action);
data             1694 lib/lrmd/lrmd_client.c     crm_xml_add(data, F_LRMD_RSC_ID, rsc_id);
data             1695 lib/lrmd/lrmd_client.c     crm_xml_add_int(data, F_LRMD_RSC_INTERVAL, interval);
data             1696 lib/lrmd/lrmd_client.c     rc = lrmd_send_command(lrmd, LRMD_OP_RSC_CANCEL, data, NULL, 0, 0, TRUE);
data             1697 lib/lrmd/lrmd_client.c     free_xml(data);
data             1739 lib/lrmd/lrmd_client.c             *resources = lrmd_list_add(*resources, (const char *)gIter->data);
data             1765 lib/lrmd/lrmd_client.c         if (safe_str_eq(agent, gIter2->data)) {
data             1785 lib/lrmd/lrmd_client.c         provider = gIter->data;
data             1788 lib/lrmd/lrmd_client.c             *providers = lrmd_list_add(*providers, (const char *)gIter->data);
data             1807 lib/lrmd/lrmd_client.c         *supported = lrmd_list_add(*supported, (const char *)gIter->data);
data              117 lib/lrmd/proxy_common.c remote_proxy_free(gpointer data)
data              119 lib/lrmd/proxy_common.c     remote_proxy_t *proxy = data;
data               41 lib/pengine/clone.c         resource_t *child = (resource_t *) gIter->data;
data              255 lib/pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              303 lib/pengine/clone.c     if ((target_role == NULL) && rsc->children && rsc->children->data) {
data              304 lib/pengine/clone.c         target_role = g_hash_table_lookup(((resource_t*)rsc->children->data)->meta,
data              343 lib/pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              366 lib/pengine/clone.c         if(is_set_recursive(gIter->data, flag, any)) {
data              428 lib/pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              501 lib/pengine/clone.c         node_t *host = gIter->data;
data              515 lib/pengine/clone.c         node_t *host = gIter->data;
data              564 lib/pengine/clone.c                 node_t *node = (node_t *)nIter->data;
data              595 lib/pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              626 lib/pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              467 lib/pengine/common.c         pe_node_t *host = node->details->remote_rsc->container->running_on->data;
data              872 lib/pengine/complex.c             resource_t *child_rsc = (resource_t *) gIter->data;
data               62 lib/pengine/container.c allocate_ip(container_variant_data_t *data, container_grouping_t *tuple, char *buffer, int max) 
data               64 lib/pengine/container.c     if(data->ip_range_start == NULL) {
data               67 lib/pengine/container.c     } else if(data->ip_last) {
data               68 lib/pengine/container.c         tuple->ipaddr = next_ip(data->ip_last);
data               71 lib/pengine/container.c         tuple->ipaddr = strdup(data->ip_range_start);
data               74 lib/pengine/container.c     data->ip_last = tuple->ipaddr;
data               77 lib/pengine/container.c                     data->prefix, tuple->offset, tuple->ipaddr,
data               78 lib/pengine/container.c                     data->prefix, tuple->offset, data->prefix, tuple->offset);
data               80 lib/pengine/container.c     if (data->type == PE_CONTAINER_TYPE_DOCKER) {
data               82 lib/pengine/container.c                         data->prefix, tuple->offset, tuple->ipaddr);
data               83 lib/pengine/container.c     } else if (data->type == PE_CONTAINER_TYPE_RKT) {
data               85 lib/pengine/container.c                         tuple->ipaddr, data->prefix, tuple->offset);
data              118 lib/pengine/container.c valid_network(container_variant_data_t *data)
data              120 lib/pengine/container.c     if(data->ip_range_start) {
data              123 lib/pengine/container.c     if(data->control_port) {
data              124 lib/pengine/container.c         if(data->replicas_per_host > 1) {
data              125 lib/pengine/container.c             pe_err("Specifying the 'control-port' for %s requires 'replicas-per-host=1'", data->prefix);
data              126 lib/pengine/container.c             data->replicas_per_host = 1;
data              136 lib/pengine/container.c     resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
data              139 lib/pengine/container.c     if(data->ip_range_start) {
data              144 lib/pengine/container.c         id = crm_strdup_printf("%s-ip-%s", data->prefix, tuple->ipaddr);
data              150 lib/pengine/container.c         crm_xml_set_id(xml_obj, "%s-attributes-%d", data->prefix, tuple->offset);
data              153 lib/pengine/container.c         if(data->host_network) {
data              154 lib/pengine/container.c             crm_create_nvpair_xml(xml_obj, NULL, "nic", data->host_network);
data              157 lib/pengine/container.c         if(data->host_netmask) {
data              159 lib/pengine/container.c                                   "cidr_netmask", data->host_netmask);
data              182 lib/pengine/container.c     resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
data              195 lib/pengine/container.c         id = crm_strdup_printf("%s-docker-%d", data->prefix, tuple->offset);
data              201 lib/pengine/container.c         crm_xml_set_id(xml_obj, "%s-attributes-%d", data->prefix, tuple->offset);
data              203 lib/pengine/container.c         crm_create_nvpair_xml(xml_obj, NULL, "image", data->image);
data              215 lib/pengine/container.c         if (data->ip_range_start != NULL) {
data              217 lib/pengine/container.c                                data->prefix, tuple->offset);
data              222 lib/pengine/container.c         if(data->docker_network) {
data              224 lib/pengine/container.c             offset += snprintf(buffer+offset, max-offset, " --net=%s", data->docker_network);
data              227 lib/pengine/container.c         if(data->control_port) {
data              228 lib/pengine/container.c             offset += snprintf(buffer+offset, max-offset, " -e PCMK_remote_port=%s", data->control_port);
data              233 lib/pengine/container.c         for(GListPtr pIter = data->mounts; pIter != NULL; pIter = pIter->next) {
data              234 lib/pengine/container.c             container_mount_t *mount = pIter->data;
data              238 lib/pengine/container.c                     "%s/%s-%d", mount->source, data->prefix, tuple->offset);
data              255 lib/pengine/container.c         for(GListPtr pIter = data->ports; pIter != NULL; pIter = pIter->next) {
data              256 lib/pengine/container.c             container_port_t *port = pIter->data;
data              261 lib/pengine/container.c             } else if(safe_str_neq(data->docker_network, "host")) {
data              267 lib/pengine/container.c         if(data->docker_run_options) {
data              268 lib/pengine/container.c             offset += snprintf(buffer+offset, max-offset, " %s", data->docker_run_options);
data              271 lib/pengine/container.c         if(data->docker_host_options) {
data              272 lib/pengine/container.c             offset += snprintf(buffer+offset, max-offset, " %s", data->docker_host_options);
data              282 lib/pengine/container.c             if(data->docker_run_command) {
data              284 lib/pengine/container.c                                       "run_cmd", data->docker_run_command);
data              311 lib/pengine/container.c             if(data->docker_run_command) {
data              313 lib/pengine/container.c                                       "run_cmd", data->docker_run_command);
data              339 lib/pengine/container.c     resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
data              354 lib/pengine/container.c         id = crm_strdup_printf("%s-rkt-%d", data->prefix, tuple->offset);
data              360 lib/pengine/container.c         crm_xml_set_id(xml_obj, "%s-attributes-%d", data->prefix, tuple->offset);
data              362 lib/pengine/container.c         crm_create_nvpair_xml(xml_obj, NULL, "image", data->image);
data              372 lib/pengine/container.c         if (data->ip_range_start != NULL) {
data              374 lib/pengine/container.c                                data->prefix, tuple->offset);
data              379 lib/pengine/container.c         if(data->docker_network) {
data              381 lib/pengine/container.c             offset += snprintf(buffer+offset, max-offset, " --net=%s", data->docker_network);
data              384 lib/pengine/container.c         if(data->control_port) {
data              385 lib/pengine/container.c             offset += snprintf(buffer+offset, max-offset, " --environment=PCMK_remote_port=%s", data->control_port);
data              390 lib/pengine/container.c         for(GListPtr pIter = data->mounts; pIter != NULL; pIter = pIter->next) {
data              391 lib/pengine/container.c             container_mount_t *mount = pIter->data;
data              395 lib/pengine/container.c                     "%s/%s-%d", mount->source, data->prefix, tuple->offset);
data              418 lib/pengine/container.c         for(GListPtr pIter = data->ports; pIter != NULL; pIter = pIter->next) {
data              419 lib/pengine/container.c             container_port_t *port = pIter->data;
data              429 lib/pengine/container.c         if(data->docker_run_options) {
data              430 lib/pengine/container.c             offset += snprintf(buffer+offset, max-offset, " %s", data->docker_run_options);
data              433 lib/pengine/container.c         if(data->docker_host_options) {
data              434 lib/pengine/container.c             offset += snprintf(buffer+offset, max-offset, " %s", data->docker_host_options);
data              444 lib/pengine/container.c             if(data->docker_run_command) {
data              445 lib/pengine/container.c                 crm_create_nvpair_xml(xml_obj, NULL, "run_cmd", data->docker_run_command);
data              471 lib/pengine/container.c             if(data->docker_run_command) {
data              473 lib/pengine/container.c                                       data->docker_run_command);
data              517 lib/pengine/container.c             disallow_node((resource_t *) (child->data), uname);
data              524 lib/pengine/container.c     resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
data              527 lib/pengine/container.c     if (tuple->child && valid_network(data)) {
data              532 lib/pengine/container.c         char *id = crm_strdup_printf("%s-%d", data->prefix, tuple->offset);
data              550 lib/pengine/container.c         if (data->control_port == NULL) {
data              562 lib/pengine/container.c                                           (data->control_port?
data              563 lib/pengine/container.c                                            data->control_port : port_s));
data              605 lib/pengine/container.c             disallow_node((resource_t *) (rsc_iter->data), uname);
data              660 lib/pengine/container.c     resource_t *parent, container_variant_data_t *data, container_grouping_t *tuple,
data              664 lib/pengine/container.c     if (data->type == PE_CONTAINER_TYPE_DOCKER &&
data              665 lib/pengine/container.c           create_docker_resource(parent, data, tuple, data_set) == FALSE) {
data              668 lib/pengine/container.c     if (data->type == PE_CONTAINER_TYPE_RKT &&
data              669 lib/pengine/container.c           create_rkt_resource(parent, data, tuple, data_set) == FALSE) {
data              673 lib/pengine/container.c     if(create_ip_resource(parent, data, tuple, data_set) == FALSE) {
data              676 lib/pengine/container.c     if(create_remote_resource(parent, data, tuple, data_set) == FALSE) {
data              745 lib/pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              812 lib/pengine/container.c         node = tuple->docker->running_on->data;
data             1064 lib/pengine/container.c             tuple->child = childIter->data;
data             1099 lib/pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data             1136 lib/pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)(iter->data);
data             1179 lib/pengine/container.c             container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data             1256 lib/pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data             1293 lib/pengine/container.c         node = tuple->docker->running_on->data;
data             1327 lib/pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              292 lib/pengine/failcounts.c             resource_t *filler = (resource_t *) gIter->data;
data              108 lib/pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              136 lib/pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              176 lib/pengine/group.c             resource_t *child_rsc = (resource_t *) gIter->data;
data              204 lib/pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              224 lib/pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data               38 lib/pengine/native.c         node_t *a_node = (node_t *) gIter->data;
data              103 lib/pengine/native.c                         resource_t *child = (resource_t *) gIter->data;
data              170 lib/pengine/native.c             node_t *loc = (node_t *) iter->data;
data              231 lib/pengine/native.c         resource_t *child = (resource_t *) gIter->data;
data              290 lib/pengine/native.c         node_t *a_node = (node_t *) gIter->data;
data              457 lib/pengine/native.c             node_t *node = (node_t *) gIter->data;
data              652 lib/pengine/native.c             node_t *n = (node_t *) gIter->data;
data              738 lib/pengine/native.c         node = rsc->running_on->data;
data              772 lib/pengine/native.c             resource_t *child = (resource_t *) gIter->data;
data              792 lib/pengine/native.c             node_t *node = (node_t *) gIter->data;
data              810 lib/pengine/native.c         resource_t *rsc = (resource_t *) gIter->data;
data              847 lib/pengine/native.c                 node_t *node = (node_t *) gIter2->data;
data              873 lib/pengine/native.c destroy_node_table(gpointer data)
data              875 lib/pengine/native.c     GHashTable *node_table = data;
data               80 lib/pengine/remote.c             resource_t *filler = (resource_t *) gIter->data;
data              124 lib/pengine/remote.c         resource_t *rsc = (resource_t *) iter->data;
data              829 lib/pengine/rules.c unpack_attr_set(gpointer data, gpointer user_data)
data              831 lib/pengine/rules.c     sorted_set_t *pair = data;
data              853 lib/pengine/rules.c unpack_versioned_attr_set(gpointer data, gpointer user_data)
data              855 lib/pengine/rules.c     sorted_set_t *pair = data;
data              869 lib/pengine/rules.c                              gboolean overwrite, crm_time_t * now, unpack_data_t * data)
data              904 lib/pengine/rules.c         data->hash = hash;
data              905 lib/pengine/rules.c         data->node_hash = node_hash;
data              906 lib/pengine/rules.c         data->now = now;
data              907 lib/pengine/rules.c         data->overwrite = overwrite;
data              908 lib/pengine/rules.c         data->top = top;
data              923 lib/pengine/rules.c     unpack_data_t data;
data              925 lib/pengine/rules.c                                                   always_first, overwrite, now, &data);
data              928 lib/pengine/rules.c         g_list_foreach(pairs, unpack_attr_set, &data);
data              938 lib/pengine/rules.c     unpack_data_t data;
data              940 lib/pengine/rules.c                                                   NULL, FALSE, now, &data);
data              943 lib/pengine/rules.c         g_list_foreach(pairs, unpack_versioned_attr_set, &data);
data              119 lib/pengine/status.c         rsc = (resource_t *) iterator->data;
data              134 lib/pengine/status.c         pe_free_action(iterator->data);
data              148 lib/pengine/status.c         node_t *node = (node_t *) iterator->data;
data              260 lib/pengine/status.c         resource_t *parent = rIter->data;
data              290 lib/pengine/status.c         node_t *node = (node_t *) gIter->data;
data              306 lib/pengine/status.c         node_t *node = (node_t *) gIter->data;
data              342 lib/pengine/unpack.c     op_digest_cache_t *data = ptr;
data              344 lib/pengine/unpack.c     free_xml(data->params_all);
data              345 lib/pengine/unpack.c     free_xml(data->params_secure);
data              346 lib/pengine/unpack.c     free_xml(data->params_restart);
data              348 lib/pengine/unpack.c     free(data->digest_all_calc);
data              349 lib/pengine/unpack.c     free(data->digest_restart_calc);
data              350 lib/pengine/unpack.c     free(data->digest_secure_calc);
data              352 lib/pengine/unpack.c     free(data);
data              418 lib/pengine/unpack.c remote_id_conflict(const char *remote_name, pe_working_set_t *data) 
data              422 lib/pengine/unpack.c     pe_find_resource(data->resources, remote_name);
data              424 lib/pengine/unpack.c     if (data->name_check == NULL) {
data              425 lib/pengine/unpack.c         data->name_check = g_hash_table_new(crm_str_hash, g_str_equal);
data              430 lib/pengine/unpack.c             g_hash_table_insert(data->name_check, (char *) id, (char *) id);
data              433 lib/pengine/unpack.c     if (g_hash_table_lookup(data->name_check, remote_name)) {
data              447 lib/pengine/unpack.c expand_remote_rsc_meta(xmlNode *xml_obj, xmlNode *parent, pe_working_set_t *data)
data              489 lib/pengine/unpack.c     if (remote_id_conflict(remote_name, data)) {
data              588 lib/pengine/unpack.c             resource_t *child_rsc = (resource_t *) gIter->data;
data              713 lib/pengine/unpack.c destroy_tag(gpointer data)
data              715 lib/pengine/unpack.c     tag_t *tag = data;
data              775 lib/pengine/unpack.c         resource_t *rsc = (resource_t *) gIter->data;
data             1269 lib/pengine/unpack.c         node_t *this_node = gIter->data;
data             1437 lib/pengine/unpack.c         host = rsc->running_on->data;
data             1705 lib/pengine/unpack.c         resource_t *child = rIter->data;
data             1714 lib/pengine/unpack.c             node_t *childnode = nIter->data;
data             1743 lib/pengine/unpack.c             resource_t *child = rIter->data;
data             2071 lib/pengine/unpack.c             action_t *stop = (action_t *) gIter->data;
data             2096 lib/pengine/unpack.c         xmlNode *rsc_op = (xmlNode *) gIter->data;
data             2153 lib/pengine/unpack.c         xmlNode *rsc_op = (xmlNode *) gIter->data;
data             2241 lib/pengine/unpack.c         xmlNode *rsc_op = (xmlNode *) gIter->data;
data             3398 lib/pengine/unpack.c         xmlNode *rsc_op = (xmlNode *) gIter->data;
data              169 lib/pengine/utils.c         node_t *node = (node_t *) gIter->data;
data              189 lib/pengine/utils.c         node_t *node = (node_t *) gIter->data;
data              206 lib/pengine/utils.c         node_t *this_node = (node_t *) gIter->data;
data              261 lib/pengine/utils.c             node_t *node = (node_t *) gIter->data;
data              299 lib/pengine/utils.c             resource_t *child = (resource_t *) gIter->data;
data             1265 lib/pengine/utils.c             resource_t *rsc = (resource_t *) gIter->data;
data             1336 lib/pengine/utils.c         action_t *action = (action_t *) gIter->data;
data             1392 lib/pengine/utils.c         action_t *action = (action_t *) gIter->data;
data             1423 lib/pengine/utils.c         action_t *action = (action_t *) gIter->data;
data             1463 lib/pengine/utils.c         action_t *action = (action_t *) gIter->data;
data             1500 lib/pengine/utils.c             resource_t *child_rsc = (resource_t *) gIter->data;
data             1526 lib/pengine/utils.c             node_t *node_iter = (node_t *) gIter->data;
data             1748 lib/pengine/utils.c         action_wrapper_t *after = (action_wrapper_t *) gIter->data;
data             1795 lib/pengine/utils.c destroy_ticket(gpointer data)
data             1797 lib/pengine/utils.c     ticket_t *ticket = data;
data             1892 lib/pengine/utils.c     op_digest_cache_t *data = NULL;
data             1894 lib/pengine/utils.c     data = g_hash_table_lookup(node->details->digest_cache, key);
data             1895 lib/pengine/utils.c     if (data == NULL) {
data             1907 lib/pengine/utils.c         data = calloc(1, sizeof(op_digest_cache_t));
data             1908 lib/pengine/utils.c         CRM_ASSERT(data != NULL);
data             1915 lib/pengine/utils.c         data->params_all = create_xml_node(NULL, XML_TAG_PARAMS);
data             1918 lib/pengine/utils.c         if (container_fix_remote_addr_in(rsc, data->params_all, "addr")) {
data             1922 lib/pengine/utils.c         g_hash_table_foreach(local_rsc_params, hash2field, data->params_all);
data             1923 lib/pengine/utils.c         g_hash_table_foreach(action->extra, hash2field, data->params_all);
data             1924 lib/pengine/utils.c         g_hash_table_foreach(rsc->parameters, hash2field, data->params_all);
data             1925 lib/pengine/utils.c         g_hash_table_foreach(action->meta, hash2metafield, data->params_all);
data             1941 lib/pengine/utils.c         append_versioned_params(local_versioned_params, ra_version, data->params_all);
data             1942 lib/pengine/utils.c         append_versioned_params(rsc->versioned_parameters, ra_version, data->params_all);
data             1946 lib/pengine/utils.c             append_versioned_params(details->versioned_parameters, ra_version, data->params_all);
data             1950 lib/pengine/utils.c         filter_action_parameters(data->params_all, op_version);
data             1955 lib/pengine/utils.c         data->digest_all_calc = calculate_operation_digest(data->params_all, op_version);
data             1958 lib/pengine/utils.c             data->params_secure = copy_xml(data->params_all);
data             1960 lib/pengine/utils.c                 filter_parameters(data->params_secure, secure_list, FALSE);
data             1962 lib/pengine/utils.c             data->digest_secure_calc = calculate_operation_digest(data->params_secure, op_version);
data             1966 lib/pengine/utils.c             data->params_restart = copy_xml(data->params_all);
data             1968 lib/pengine/utils.c                 filter_parameters(data->params_restart, restart_list, TRUE);
data             1970 lib/pengine/utils.c             data->digest_restart_calc = calculate_operation_digest(data->params_restart, op_version);
data             1973 lib/pengine/utils.c         g_hash_table_insert(node->details->digest_cache, strdup(key), data);
data             1976 lib/pengine/utils.c     return data;
data             1983 lib/pengine/utils.c     op_digest_cache_t *data = NULL;
data             2003 lib/pengine/utils.c     data = rsc_action_digest(rsc, task, key, node, xml_op, data_set);
data             2005 lib/pengine/utils.c     data->rc = RSC_DIGEST_MATCH;
data             2006 lib/pengine/utils.c     if (digest_restart && data->digest_restart_calc && strcmp(data->digest_restart_calc, digest_restart) != 0) {
data             2009 lib/pengine/utils.c                  crm_str(digest_restart), data->digest_restart_calc,
data             2011 lib/pengine/utils.c         data->rc = RSC_DIGEST_RESTART;
data             2015 lib/pengine/utils.c         data->rc = RSC_DIGEST_UNKNOWN;
data             2017 lib/pengine/utils.c     } else if (strcmp(digest_all, data->digest_all_calc) != 0) {
data             2020 lib/pengine/utils.c                  crm_str(digest_all), data->digest_all_calc,
data             2023 lib/pengine/utils.c         data->rc = RSC_DIGEST_ALL;
data             2027 lib/pengine/utils.c     return data;
data             2036 lib/pengine/utils.c     op_digest_cache_t *data = rsc_action_digest(rsc, STONITH_DIGEST_TASK, key, node, NULL, data_set);
data             2046 lib/pengine/utils.c     char *search_all = crm_strdup_printf("%s:%s:%s", rsc->id, (const char*)g_hash_table_lookup(rsc->meta, XML_ATTR_TYPE), data->digest_all_calc);
data             2047 lib/pengine/utils.c     char *search_secure = crm_strdup_printf("%s:%s:%s", rsc->id, (const char*)g_hash_table_lookup(rsc->meta, XML_ATTR_TYPE), data->digest_secure_calc);
data             2049 lib/pengine/utils.c     data->rc = RSC_DIGEST_ALL;
data             2052 lib/pengine/utils.c         data->rc = RSC_DIGEST_UNKNOWN;
data             2055 lib/pengine/utils.c         data->rc = RSC_DIGEST_MATCH;
data             2057 lib/pengine/utils.c     } else if(digest_secure && data->digest_secure_calc) {
data             2063 lib/pengine/utils.c             data->rc = RSC_DIGEST_MATCH;
data             2067 lib/pengine/utils.c     if (data->rc == RSC_DIGEST_ALL && is_set(data_set->flags, pe_flag_sanitized) && data->digest_secure_calc) {
data             2072 lib/pengine/utils.c                    data->digest_secure_calc);
data             2080 lib/pengine/utils.c     return data;
data             2098 lib/pengine/utils.c         resource_t *child_rsc = (resource_t *) gIter->data;
data             2111 lib/pengine/utils.c         resource_t *child_rsc = (resource_t *) gIter->data;
data             2121 lib/pengine/utils.c         resource_t *candidate = gIter->data;
data             2179 lib/pengine/utils.c                 resource_t *match = gIter->data;
data             2180 lib/pengine/utils.c                 op_digest_cache_t *data = fencing_action_digest_cmp(match, node, data_set);
data             2182 lib/pengine/utils.c                 if(data->rc == RSC_DIGEST_ALL) {
data             2193 lib/pengine/utils.c                     "%s:%s:%s,", match->id, (const char*)g_hash_table_lookup(match->meta, XML_ATTR_TYPE), data->digest_all_calc);
data             2197 lib/pengine/utils.c                     "%s:%s:%s,", match->id, (const char*)g_hash_table_lookup(match->meta, XML_ATTR_TYPE), data->digest_secure_calc);
data             2275 lib/pengine/utils.c         const char *existing_ref = (const char *) gIter->data;
data               53 lib/pengine/variant.h #    define get_clone_variant_data(data, rsc)				\
data               56 lib/pengine/variant.h 	data = (clone_variant_data_t *)rsc->variant_opaque;
data              124 lib/pengine/variant.h #    define get_container_variant_data(data, rsc)                       \
data              128 lib/pengine/variant.h 	data = (container_variant_data_t *)rsc->variant_opaque;		\
data              145 lib/pengine/variant.h #    define get_group_variant_data(data, rsc)				\
data              149 lib/pengine/variant.h 	data = (group_variant_data_t *)rsc->variant_opaque;		\
data              157 lib/pengine/variant.h #    define get_native_variant_data(data, rsc)				\
data              161 lib/pengine/variant.h 	data = (native_variant_data_t *)rsc->variant_opaque;
data              284 lib/services/dbus.c pcmk_dbus_lookup_result(DBusMessage *reply, struct db_getall_data *data)
data              293 lib/services/dbus.c                 data->target, data->object, error.message);
data              300 lib/services/dbus.c         crm_err("Invalid reply from %s for %s", data->target, data->object);
data              324 lib/services/dbus.c                     if(data->name && strcmp(name.str, data->name) != 0) {
data              333 lib/services/dbus.c                         crm_trace("Property %s[%s] is '%s'", data->object, name.str, value.str);
data              334 lib/services/dbus.c                         if(data->callback) {
data              335 lib/services/dbus.c                             data->callback(name.str, value.str, data->userdata);
data              342 lib/services/dbus.c                         if(data->name) {
data              356 lib/services/dbus.c     if(data->name && data->callback) {
data              357 lib/services/dbus.c         crm_trace("No value for property %s[%s]", data->object, data->name);
data              358 lib/services/dbus.c         data->callback(data->name, NULL, data->userdata);
data              362 lib/services/dbus.c     free(data->target);
data              363 lib/services/dbus.c     free(data->object);
data              364 lib/services/dbus.c     free(data->name);
data              365 lib/services/dbus.c     free(data);
data              451 lib/services/dbus.c                               DBusDispatchStatus new_status, void *data)
data              465 lib/services/dbus.c         DBusConnection *connection = gIter->data;
data              544 lib/services/dbus.c pcmk_dbus_watch_add(DBusWatch *watch, void *data)
data              557 lib/services/dbus.c pcmk_dbus_watch_toggle(DBusWatch *watch, void *data)
data              566 lib/services/dbus.c pcmk_dbus_watch_remove(DBusWatch *watch, void *data)
data              570 lib/services/dbus.c     crm_trace("Removed client %p (%p)", client, data);
data              575 lib/services/dbus.c pcmk_dbus_timeout_dispatch(gpointer data)
data              577 lib/services/dbus.c     crm_info("Timeout %p expired", data);
data              578 lib/services/dbus.c     dbus_timeout_handle(data);
data              583 lib/services/dbus.c pcmk_dbus_timeout_add(DBusTimeout *timeout, void *data)
data              597 lib/services/dbus.c pcmk_dbus_timeout_remove(DBusTimeout *timeout, void *data)
data              602 lib/services/dbus.c     crm_trace("Removing timeout %p (%p)", timeout, data);
data              611 lib/services/dbus.c pcmk_dbus_timeout_toggle(DBusTimeout *timeout, void *data)
data              618 lib/services/dbus.c         pcmk_dbus_timeout_add(timeout, data);
data              620 lib/services/dbus.c         pcmk_dbus_timeout_remove(timeout, data);
data              862 lib/services/services.c         op = gIter->data;
data              889 lib/services/services.c         op = gIter->data;
data              904 lib/services/services.c         op = gIter->data;
data               41 lib/services/services_linux.c     char *data = NULL;
data               54 lib/services/services_linux.c         data = op->stderr_data;
data               59 lib/services/services_linux.c         data = op->stdout_data;
data               71 lib/services/services_linux.c             data = realloc_safe(data, len + rc + 1);
data               72 lib/services/services_linux.c             len += sprintf(data + len, "%s", buf);
data               85 lib/services/services_linux.c         op->stderr_data = data;
data               87 lib/services/services_linux.c         op->stdout_data = data;
data              199 lib/services/services_linux.c recurring_action_timer(gpointer data)
data              201 lib/services/services_linux.c     svc_action_t *op = data;
data              892 lib/services/services_linux.c         GList *tmp2 = resources_os_list_ocf_agents(gIter->data);
data              914 lib/services/services_linux.c         const char *plugin = gIter->data;
data               73 lib/services/services_private.h gboolean recurring_action_timer(gpointer data);
data               41 lib/transition/graph.c         crm_action_t *prereq = (crm_action_t *) lpc->data;
data               74 lib/transition/graph.c         crm_action_t *action = (crm_action_t *) lpc->data;
data              109 lib/transition/graph.c         synapse_t *synapse = (synapse_t *) lpc->data;
data              142 lib/transition/graph.c         crm_action_t *prereq = (crm_action_t *) lpc->data;
data              157 lib/transition/graph.c         crm_action_t *a = (crm_action_t *) lpc->data;
data              226 lib/transition/graph.c         crm_action_t *action = (crm_action_t *) lpc->data;
data              271 lib/transition/graph.c         synapse_t *synapse = (synapse_t *) lpc->data;
data              285 lib/transition/graph.c         synapse_t *synapse = (synapse_t *) lpc->data;
data              130 lib/transition/utils.c         synapse_t *synapse = (synapse_t *) sIter->data;
data              133 lib/transition/utils.c             crm_action_t *action = (crm_action_t *) aIter->data;
data              165 lib/transition/utils.c             crm_action_t *input = (crm_action_t *) lpc->data;
data              182 lib/transition/utils.c         crm_action_t *action = (crm_action_t *) lpc->data;
data              197 lib/transition/utils.c             crm_action_t *input = (crm_action_t *) lpc->data;
data              240 lib/transition/utils.c         synapse_t *synapse = (synapse_t *) lpc->data;
data              107 libltdl/libltdl/lt__private.h   void *		data;
data               44 libltdl/libltdl/lt_dlloader.h typedef lt_module   lt_module_open	(lt_user_data data,
data               47 libltdl/libltdl/lt_dlloader.h typedef int	    lt_module_close	(lt_user_data data,
data               49 libltdl/libltdl/lt_dlloader.h typedef void *	    lt_find_sym		(lt_user_data data, lt_module module,
data               51 libltdl/libltdl/lt_dlloader.h typedef int	    lt_dlloader_init	(lt_user_data data);
data               52 libltdl/libltdl/lt_dlloader.h typedef int	    lt_dlloader_exit	(lt_user_data data);
data               82 libltdl/libltdl/lt_dlloader.h typedef  const lt_dlvtable *lt_get_vtable	(lt_user_data data);
data              102 libltdl/ltdl.c typedef int	file_worker_func      (const char *filename, void *data);
data              111 libltdl/ltdl.c static	int	find_handle_callback  (char *filename, void *data,
data              158 libltdl/ltdl.c 				       lt_user_data data);
data              186 libltdl/ltdl.c loader_init (lt_get_vtable *vtable_func, lt_user_data data)
data              193 libltdl/ltdl.c       vtable = (*vtable_func) (data);
data              218 libltdl/ltdl.c LT_SCOPE const lt_dlvtable *	get_vtable (lt_user_data data);
data              775 libltdl/ltdl.c find_handle_callback (char *filename, void *data, void *data2)
data              777 libltdl/ltdl.c   lt_dlhandle  *phandle		= (lt_dlhandle *) data;
data             1898 libltdl/ltdl.c 		  int (*func) (const char *filename, void *data),
data             1899 libltdl/ltdl.c 		  void *data)
data             1909 libltdl/ltdl.c 				   foreachfile_callback, fpptr, data);
data             1915 libltdl/ltdl.c 				   foreachfile_callback, fpptr, data);
data             1919 libltdl/ltdl.c 				       foreachfile_callback, fpptr, data);
data             1926 libltdl/ltdl.c 				       foreachfile_callback, fpptr, data);
data             1933 libltdl/ltdl.c 				       foreachfile_callback, fpptr, data);
data             1971 libltdl/ltdl.c       lt_user_data data = cur->vtable->dlloader_data;
data             1982 libltdl/ltdl.c       errors += cur->vtable->module_close (data, cur->module);
data             2012 libltdl/ltdl.c   lt_user_data data;
data             2046 libltdl/ltdl.c   data = handle->vtable->dlloader_data;
data             2068 libltdl/ltdl.c       address = handle->vtable->find_sym (data, handle->module, sym);
data             2091 libltdl/ltdl.c   address = handle->vtable->find_sym (data, handle->module, sym);
data             2315 libltdl/ltdl.c lt_dlcaller_set_data (lt_dlinterface_id key, lt_dlhandle handle, void *data)
data             2330 libltdl/ltdl.c 	  stale = cur->interface_data[i].data;
data             2355 libltdl/ltdl.c   cur->interface_data[i].data = data;
data             2375 libltdl/ltdl.c 	      result = cur->interface_data[i].data;
data             2441 libltdl/ltdl.c 		 int (*func) (lt_dlhandle handle, void *data), void *data)
data             2459 libltdl/ltdl.c       if ((errorcode = (*func) (cur, data)) != 0)
data               64 libltdl/ltdl.h 			int (*func) (const char *filename, void *data),
data               65 libltdl/ltdl.h 			void *data);
data              125 libltdl/ltdl.h 					  lt_dlhandle handle, void *data);
data              150 libltdl/ltdl.h 				int (*func) (lt_dlhandle handle, void *data),
data              151 libltdl/ltdl.h 				void *data);
data              221 lrmd/ipc_proxy.c ipc_proxy_dispatch(qb_ipcs_connection_t * c, void *data, size_t size)
data              246 lrmd/ipc_proxy.c     request = crm_ipcs_recv(client, data, size, &id, &flags);
data              415 lrmd/ipc_proxy.c         ipc_client = gIter->data;
data              233 lrmd/lrmd.c    stonith_recurring_op_helper(gpointer data)
data              235 lrmd/lrmd.c        lrmd_cmd_t *cmd = data;
data              263 lrmd/lrmd.c    start_delay_helper(gpointer data)
data              265 lrmd/lrmd.c        lrmd_cmd_t *cmd = data;
data              290 lrmd/lrmd.c            dup = gIter->data;
data              300 lrmd/lrmd.c            dup = gIter->data;
data             1056 lrmd/lrmd.c    lrmd_stonith_callback(stonith_t * stonith, stonith_callback_data_t * data)
data             1058 lrmd/lrmd.c        stonith_action_complete(data->userdata, data->rc);
data             1093 lrmd/lrmd.c            stonith_action_complete(cmd_iter->data, -ENOTCONN);
data             1271 lrmd/lrmd.c            cmd = first->data;
data             1317 lrmd/lrmd.c    free_rsc(gpointer data)
data             1320 lrmd/lrmd.c        lrmd_rsc_t *rsc = data;
data             1326 lrmd/lrmd.c            lrmd_cmd_t *cmd = gIter->data;
data             1340 lrmd/lrmd.c            lrmd_cmd_t *cmd = gIter->data;
data             1554 lrmd/lrmd.c            lrmd_cmd_t *cmd = gIter->data;
data             1567 lrmd/lrmd.c                lrmd_cmd_t *cmd = gIter->data;
data             1611 lrmd/lrmd.c            lrmd_cmd_t *cmd = cmd_iter->data;
data             1686 lrmd/lrmd.c            xmlNode *data = get_message_xml(request, F_LRMD_CALLDATA); 
data             1687 lrmd/lrmd.c            const char *timeout = crm_element_value(data, F_LRMD_WATCHDOG);
data             1688 lrmd/lrmd.c            CRM_LOG_ASSERT(data != NULL);
data               81 lrmd/lrmd_private.h void free_rsc(gpointer data);
data               54 lrmd/main.c    static gboolean lrmd_exit(gpointer data);
data              124 lrmd/main.c    lrmd_ipc_dispatch(qb_ipcs_connection_t * c, void *data, size_t size)
data              129 lrmd/main.c        xmlNode *request = crm_ipcs_recv(client, data, size, &id, &flags);
data              276 lrmd/main.c    lrmd_exit(gpointer data)
data              123 lrmd/remote_ctl.c timeout_err(gpointer data)
data              151 lrmd/test.c    timeout_err(gpointer data)
data               53 lrmd/tls_backend.c lrmd_remote_client_msg(gpointer data)
data               59 lrmd/tls_backend.c     crm_client_t *client = data;
data              174 lrmd/tls_backend.c lrmd_auth_timeout_cb(gpointer data)
data              176 lrmd/tls_backend.c     crm_client_t *client = data;
data              192 lrmd/tls_backend.c lrmd_remote_listen(gpointer data)
data              356 mcp/pacemaker.c escalate_shutdown(gpointer data)
data              359 mcp/pacemaker.c     pcmk_child_t *child = data;
data              482 mcp/pacemaker.c pcmk_ipc_dispatch(qb_ipcs_connection_t * qbc, void *data, size_t size)
data              488 mcp/pacemaker.c     xmlNode *msg = crm_ipcs_recv(c, data, size, &id, &flags);
data              432 pengine/allocate.c         xmlNode *rsc_op = (xmlNode *) gIter->data;
data              498 pengine/allocate.c             resource_t *child = (resource_t *) gIter->data;
data              533 pengine/allocate.c             resource_t *child = (resource_t *) gIter->data;
data              588 pengine/allocate.c                                 resource_t *rsc = (resource_t *) gIter->data;
data              612 pengine/allocate.c         rsc_to_node_t *cons = (rsc_to_node_t *) gIter->data;
data              697 pengine/allocate.c             resource_t *child_rsc = (resource_t *) gIter->data;
data              748 pengine/allocate.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              761 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data              845 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data              861 pengine/allocate.c                 resource_t *rsc = (resource_t *) gIter2->data;
data              901 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data              930 pengine/allocate.c             resource_t *rsc = (resource_t *) gIter2->data;
data              950 pengine/allocate.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              975 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data              991 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data              995 pengine/allocate.c             resource_t *rsc = (resource_t *) gIter2->data;
data             1015 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data             1034 pengine/allocate.c sort_rsc_process_order(gconstpointer a, gconstpointer b, gpointer data)
data             1042 pengine/allocate.c     const GListPtr nodes = (GListPtr) data;
data             1122 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data             1179 pengine/allocate.c             resource_t *rsc = (resource_t *) gIter->data;
data             1194 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data             1249 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data             1294 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data             1306 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data             1353 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data             1360 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data             1379 pengine/allocate.c         resource_t *child_rsc = (resource_t *) gIter->data;
data             1396 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data             1512 pengine/allocate.c         node_t *node = (node_t *) gIter->data;
data             1596 pengine/allocate.c             action_t *node_stop = (action_t *) gIter->data;
data             1620 pengine/allocate.c                 stonith_op = (action_t *) gIter2->data;
data             1720 pengine/allocate.c         action_t *rh_action_iter = (action_t *) gIter->data;
data             1786 pengine/allocate.c         action_t *lh_action_iter = (action_t *) gIter->data;
data             1925 pengine/allocate.c         cluster_node = remote_rsc->running_on->data;
data             2009 pengine/allocate.c         cluster_node = remote_rsc->running_on->data;
data             2122 pengine/allocate.c         action_t *action = (action_t *) gIter->data;
data             2201 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data             2255 pengine/allocate.c             start = actions->data;
data             2269 pengine/allocate.c             action_wrapper_t *before = (action_wrapper_t *) actions->data;
data             2278 pengine/allocate.c                     before = (action_wrapper_t *) clone_actions->data;
data             2306 pengine/allocate.c                 action_t *probe = (action_t *) pIter->data;
data             2332 pengine/allocate.c         order_constraint_t *order = (order_constraint_t *) gIter->data;
data             2355 pengine/allocate.c         action_t *action = (action_t *) gIter->data;
data             2365 pengine/allocate.c         action_t *action = (action_t *) gIter->data;
data             2372 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data             2429 pengine/allocate.c         resource_t *rsc = (resource_t *) gIter->data;
data             2445 pengine/allocate.c         action_t *action = (action_t *) gIter->data;
data             2487 pengine/allocate.c         action_t *action = (action_t *) gIter->data;
data               68 pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              113 pengine/clone.c         node1 = resource1->running_on->data;
data              116 pengine/clone.c         node2 = resource2->running_on->data;
data              230 pengine/clone.c         n = node_copy(resource1->running_on->data);
data              233 pengine/clone.c         n = node_copy(resource2->running_on->data);
data              238 pengine/clone.c                 rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              248 pengine/clone.c                 rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              260 pengine/clone.c                 rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              270 pengine/clone.c                 rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              486 pengine/clone.c         rsc_colocation_t *cons = (rsc_colocation_t *) gIter->data;
data              495 pengine/clone.c         rsc_colocation_t *cons = (rsc_colocation_t *) gIter->data;
data              518 pengine/clone.c         pe_node_t *node = nIter->data;
data              538 pengine/clone.c         resource_t *child = (resource_t *) gIter->data;
data              542 pengine/clone.c             node_t *child_node = child->running_on->data;
data              543 pengine/clone.c             node_t *local_node = parent_node_instance(child, child->running_on->data);
data              568 pengine/clone.c         resource_t *child = (resource_t *) gIter->data;
data              571 pengine/clone.c             node_t *child_node = child->running_on->data;
data              572 pengine/clone.c             node_t *local_node = parent_node_instance(child, child->running_on->data);
data              620 pengine/clone.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              627 pengine/clone.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              661 pengine/clone.c             resource_t *child = (resource_t *) gIter->data;
data              679 pengine/clone.c         action_t *action = (action_t *) gIter->data;
data              726 pengine/clone.c             action_t *op = (action_t *) gIter->data;
data              782 pengine/clone.c         resource_t *child = (resource_t *) gIter->data;
data              838 pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              906 pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              936 pengine/clone.c             resource_t *child_rsc = (resource_t *) gIter->data;
data              999 pengine/clone.c         node_t *node = (node_t *) gIter->data;
data             1080 pengine/clone.c             resource_t *child_rsc = (resource_t *) gIter->data;
data             1096 pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data             1106 pengine/clone.c     resource_t *child = (resource_t *) action->rsc->children->data;
data             1153 pengine/clone.c         resource_t *child = (resource_t *) gIter->data;
data             1201 pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data             1217 pengine/clone.c         action_t *op = (action_t *) gIter->data;
data             1250 pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data             1279 pengine/clone.c             resource_t *child = (resource_t *) gIter->data;
data             1297 pengine/clone.c             node_t *node = (node_t *) gIter->data;
data             1318 pengine/clone.c         resource_t *child = (resource_t *) gIter->data;
data             1324 pengine/clone.c             node_t *known = (node_t *) gIter2->data;
data             1386 pengine/clone.c             resource_t *child_rsc = (resource_t *) gIter->data;
data             1401 pengine/clone.c         child = rsc->children->data;
data             1407 pengine/clone.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              183 pengine/constraints.c         resource_t *parent = rIter->data;
data              395 pengine/constraints.c             resource_t *child = rIter->data;
data              520 pengine/constraints.c                     const char *obj_ref = (const char *) gIter->data;
data              552 pengine/constraints.c             xmlNode *tag_ref = gIter->data;
data              615 pengine/constraints.c             const char *obj_ref = (const char *) gIter->data;
data              682 pengine/constraints.c             resource_t *r = rIter->data;
data             1060 pengine/constraints.c             node_t *node = (node_t *) gIter->data;
data             1068 pengine/constraints.c         node_t *node = (node_t *) gIter->data;
data             1648 pengine/constraints.c         resource = (resource_t *) set_iter->data;
data             1667 pengine/constraints.c                 resource_t *then_rsc = (resource_t *) gIter->data;
data             1714 pengine/constraints.c         resource = (resource_t *) set_iter->data;
data               30 pengine/container.c is_child_container_node(container_variant_data_t *data, pe_node_t *node)
data               32 pengine/container.c     for (GListPtr gIter = data->tuples; gIter != NULL; gIter = gIter->next) {
data               33 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data               48 pengine/container.c     container_variant_data_t *data = NULL;
data               51 pengine/container.c         get_container_variant_data(data, rsc);
data               52 pengine/container.c         for (GListPtr gIter = data->tuples; gIter != NULL; gIter = gIter->next) {
data               53 pengine/container.c             container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data               63 pengine/container.c     container_variant_data_t *data = NULL;
data               66 pengine/container.c         get_container_variant_data(data, rsc);
data               67 pengine/container.c         for (GListPtr gIter = data->tuples; gIter != NULL; gIter = gIter->next) {
data               68 pengine/container.c             container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              141 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              213 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              271 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              356 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              386 pengine/container.c         node_t *node = (node_t *) gIter->data;
data              435 pengine/container.c                 container_variant_data_t *data = NULL;
data              436 pengine/container.c                 get_container_variant_data(data, rsc);
data              437 pengine/container.c                 return data->replicas_per_host;
data              481 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              507 pengine/container.c     container_variant_data_t *data = NULL;
data              509 pengine/container.c     get_container_variant_data(data, action->rsc);
data              510 pengine/container.c     if(data->child) {
data              511 pengine/container.c         enum action_tasks task = get_complex_task(data->child, action->task, TRUE);
data              520 pengine/container.c                 return summary_action_flags(action, data->child->children, node);
data              549 pengine/container.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              569 pengine/container.c         container_variant_data_t *data = NULL;
data              570 pengine/container.c         get_container_variant_data(data, rsc);
data              571 pengine/container.c         for (GListPtr gIter = data->tuples; gIter != NULL; gIter = gIter->next) {
data              572 pengine/container.c             container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              600 pengine/container.c         resource_t *then_child = (resource_t *) gIter->data;
data              762 pengine/container.c             resource_t *then_child = (resource_t *) gIter->data;
data              776 pengine/container.c                         action_wrapper_t *next = (action_wrapper_t *) lpc->data;
data              801 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              831 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              869 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              897 pengine/container.c                     container_grouping_t *other = (container_grouping_t *)tIter->data;
data              955 pengine/container.c         container_grouping_t *tuple = (container_grouping_t *)gIter->data;
data              465 pengine/graph.c         action_t *action = (action_t *) gIter->data;
data              504 pengine/graph.c         resource_t *child = (resource_t *)gIter->data;
data              512 pengine/graph.c         rsc_colocation_t *colocate_with = (rsc_colocation_t *)gIter->data;
data              557 pengine/graph.c         action_wrapper_t *other = (action_wrapper_t *) lpc->data;
data              673 pengine/graph.c                 action_wrapper_t *other = (action_wrapper_t *) lpc2->data;
data              703 pengine/graph.c             action_wrapper_t *other = (action_wrapper_t *) lpc->data;
data              721 pengine/graph.c         action_t *action = (action_t *) lpc->data;
data              775 pengine/graph.c         rsc_stonith_ordering((resource_t *) r->data, stonith_op, data_set);
data              794 pengine/graph.c         began_on = action->node->details->remote_rsc->running_on->data;
data              889 pengine/graph.c         node_t *node = (node_t *) gIter->data;
data              974 pengine/graph.c             input = ((action_wrapper_t *) iter->data)->action;
data             1238 pengine/graph.c                         host = action->node->details->remote_rsc->container->running_on->data;
data             1315 pengine/graph.c             action_wrapper_t *wrapper = (action_wrapper_t *) lpc->data;
data             1636 pengine/graph.c         action_wrapper_t *wrapper_before = (action_wrapper_t *) lpc->data;
data             1737 pengine/graph.c         action_wrapper_t *wrapper = (action_wrapper_t *) lpc->data;
data               71 pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              101 pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              157 pengine/group.c         action_t *action = (action_t *) gIter->data;
data              190 pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              326 pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              367 pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              380 pengine/group.c         resource_t *child = (resource_t *) gIter->data;
data              425 pengine/group.c         resource_t *child = (resource_t *) gIter->data;
data              452 pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              476 pengine/group.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              503 pengine/group.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data               65 pengine/main.c pe_ipc_dispatch(qb_ipcs_connection_t * qbc, void *data, size_t size)
data               70 pengine/main.c     xmlNode *msg = crm_ipcs_recv(c, data, size, &id, &flags);
data              111 pengine/master.c             resource_t *child = (resource_t *) gIter->data;
data              123 pengine/master.c         action_t *action = (action_t *) gIter->data;
data              145 pengine/master.c         rsc_to_node_t *cons = (rsc_to_node_t *) gIter->data;
data              181 pengine/master.c             resource_t *child = (resource_t *) gIter->data;
data              292 pengine/master.c         resource_t *child = (resource_t *) gIter->data;
data              300 pengine/master.c         resource_t *child = (resource_t *) gIter->data;
data              321 pengine/master.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              341 pengine/master.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              361 pengine/master.c         rsc_ticket_t *rsc_ticket = (rsc_ticket_t *) gIter->data;
data              375 pengine/master.c         resource_t *child = (resource_t *) gIter->data;
data              405 pengine/master.c         resource_t *child = rIter->data;
data              426 pengine/master.c         resource_t *child = rIter->data;
data              478 pengine/master.c             resource_t *child = (resource_t *) gIter->data;
data              571 pengine/master.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              628 pengine/master.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              644 pengine/master.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              694 pengine/master.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              745 pengine/master.c             rsc_colocation_t *cons = (rsc_colocation_t *) gIter2->data;
data              764 pengine/master.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              846 pengine/master.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              903 pengine/master.c         resource_t *child_rsc = (resource_t *) gIter->data;
data              948 pengine/master.c         resource_t *child_rsc = (resource_t *) gIter->data;
data             1012 pengine/master.c             resource_t *child_rsc = (resource_t *) gIter->data;
data             1021 pengine/master.c             resource_t *child_rsc = (resource_t *) gIter->data;
data              168 pengine/native.c                     node_t *tmp = (node_t *) iter->data;
data              341 pengine/native.c             work = rsc_merge_weights(last->data, rhs, NULL, attr, factor, flags);
data              354 pengine/native.c             work = rsc_merge_weights(iter->data, rhs, work, attr, factor, flags);
data              385 pengine/native.c             gIter = ((resource_t*)last->data)->rsc_cons_lhs;
data              387 pengine/native.c                       g_list_length(gIter), ((resource_t*)last->data)->id);
data              396 pengine/native.c             rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              459 pengine/native.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              487 pengine/native.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              525 pengine/native.c             assign_to = rsc->running_on->data;
data              528 pengine/native.c             assign_to = rsc->running_on->data;
data              531 pengine/native.c             assign_to = rsc->running_on->data;
data              706 pengine/native.c             action_t *op = (action_t *) gIter->data;
data              933 pengine/native.c         node_t *stop_node = (node_t *) gIter->data;
data              977 pengine/native.c                 action_t *probe = (action_t *) pIter->data;
data              995 pengine/native.c             action_t *stop = (action_t *) local_gIter->data;
data             1170 pengine/native.c         current = rsc->running_on->data;
data             1174 pengine/native.c         node_t *n = (node_t *) gIter->data;
data             1183 pengine/native.c         node_t *current = (node_t *) gIter->data;
data             1437 pengine/native.c             node_t *current = (node_t *) gIter->data;
data             1810 pengine/native.c             resource_t *child_rsc = (resource_t *) gIter->data;
data             1844 pengine/native.c                     node_t *node = (node_t *) gIter->data;
data             1908 pengine/native.c                    && then->node->details == ((node_t *) then_rsc->running_on->data)->details) {
data             2104 pengine/native.c         node_t *node = (node_t *) gIter->data;
data             2146 pengine/native.c         action_t *action = (action_t *) gIter->data;
data             2153 pengine/native.c         resource_t *child_rsc = (resource_t *) gIter->data;
data             2309 pengine/native.c             resource_t *child_rsc = (resource_t *) gIter->data;
data             2321 pengine/native.c             current = rsc->running_on->data;
data             2354 pengine/native.c         start = possible_matches->data;
data             2365 pengine/native.c         stop = possible_matches->data;
data             2374 pengine/native.c         promote = possible_matches->data;
data             2382 pengine/native.c         demote = possible_matches->data;
data             2394 pengine/native.c             migrate_op = possible_matches->data;
data             2439 pengine/native.c             node_t *node = (node_t *) gIter->data;
data             2444 pengine/native.c                 stop_op = possible_matches->data;
data             2496 pengine/native.c         node_t *current = (node_t *) gIter->data;
data             2586 pengine/native.c         action_t *start = (action_t *) gIter->data;
data             2606 pengine/native.c         action_t *promote = (action_t *) gIter->data;
data             2625 pengine/native.c         node_t *current = (node_t *) gIter->data;
data             2848 pengine/native.c             resource_t *child_rsc = (resource_t *) gIter->data;
data             3065 pengine/native.c         action_t *action = (action_t *) gIter->data;
data             3121 pengine/native.c         action_t *action = (action_t *) gIter->data;
data             3218 pengine/native.c         action_t *action = (action_t *) gIter->data;
data             3254 pengine/native.c             resource_t *child_rsc = (resource_t *) gIter->data;
data             3283 pengine/native.c             resource_t *child_rsc = (resource_t *) gIter->data;
data              104 pengine/notif.c         node_t *node = (node_t *) gIter->data;
data              127 pengine/notif.c                 node = node->details->remote_rsc->container->running_on->data;
data              172 pengine/notif.c         notify_entry_t *entry = (notify_entry_t *) gIter->data;
data              302 pengine/notif.c             action_t *mon = (action_t *) gIter->data;
data              448 pengine/notif.c             resource_t *child = (resource_t *) gIter->data;
data              462 pengine/notif.c             entry->node = rsc->running_on->data;
data              498 pengine/notif.c             action_t *op = (action_t *) gIter->data;
data              650 pengine/notif.c             resource_t *child = (resource_t *) gIter->data;
data              661 pengine/notif.c         action_t *op = (action_t *) gIter->data;
data              690 pengine/notif.c                 node_t *current_node = (node_t *) gIter->data;
data              251 pengine/pengine.c             resource_t *rsc = (resource_t *) gIter->data;
data              290 pengine/pengine.c             action_t *action = (action_t *) gIter->data;
data              387 pengine/ptest.c         action_t *action = (action_t *) lpc->data;
data              431 pengine/ptest.c         action_t *action = (action_t *) lpc->data;
data              436 pengine/ptest.c             action_wrapper_t *before = (action_wrapper_t *) lpc2->data;
data               44 pengine/utilization.c     struct compare_data *data = user_data;
data               48 pengine/utilization.c         crm_parse_int(g_hash_table_lookup(data->node2->details->utilization, key), "0");
data               51 pengine/utilization.c         data->result--;
data               53 pengine/utilization.c         data->result++;
data               62 pengine/utilization.c     struct compare_data *data = user_data;
data               64 pengine/utilization.c     if (g_hash_table_lookup_extended(data->node1->details->utilization, key, NULL, NULL)) {
data               72 pengine/utilization.c         data->result--;
data               74 pengine/utilization.c         data->result++;
data               84 pengine/utilization.c     struct compare_data data;
data               86 pengine/utilization.c     data.node1 = node1;
data               87 pengine/utilization.c     data.node2 = node2;
data               88 pengine/utilization.c     data.result = 0;
data               90 pengine/utilization.c     g_hash_table_foreach(node1->details->utilization, do_compare_capacity1, &data);
data               91 pengine/utilization.c     g_hash_table_foreach(node2->details->utilization, do_compare_capacity2, &data);
data               93 pengine/utilization.c     return data.result;
data              106 pengine/utilization.c     struct calculate_data *data = user_data;
data              108 pengine/utilization.c     current = g_hash_table_lookup(data->current_utilization, key);
data              109 pengine/utilization.c     if (data->plus) {
data              111 pengine/utilization.c         g_hash_table_replace(data->current_utilization, strdup(key), result);
data              115 pengine/utilization.c         g_hash_table_replace(data->current_utilization, strdup(key), result);
data              126 pengine/utilization.c     struct calculate_data data;
data              128 pengine/utilization.c     data.current_utilization = current_utilization;
data              129 pengine/utilization.c     data.plus = plus;
data              131 pengine/utilization.c     g_hash_table_foreach(utilization, do_calculate_utilization, &data);
data              146 pengine/utilization.c     struct capacity_data *data = user_data;
data              149 pengine/utilization.c     remaining = crm_parse_int(g_hash_table_lookup(data->node->details->utilization, key), "0");
data              152 pengine/utilization.c         CRM_ASSERT(data->rsc_id);
data              153 pengine/utilization.c         CRM_ASSERT(data->node);
data              156 pengine/utilization.c                   data->node->details->uname, (char *)key, data->rsc_id, required, remaining);
data              157 pengine/utilization.c         data->is_enough = FALSE;
data              164 pengine/utilization.c     struct capacity_data data;
data              166 pengine/utilization.c     data.node = node;
data              167 pengine/utilization.c     data.rsc_id = rsc_id;
data              168 pengine/utilization.c     data.is_enough = TRUE;
data              170 pengine/utilization.c     g_hash_table_foreach(utilization, check_capacity, &data);
data              172 pengine/utilization.c     return data.is_enough;
data              211 pengine/utilization.c             resource_t *child = (resource_t *) gIter1->data;
data              221 pengine/utilization.c                     resource_t *grandchild = (resource_t *) gIter2->data;
data              235 pengine/utilization.c             resource_t *first_child = (resource_t *) rsc->children->data;
data              257 pengine/utilization.c         resource_t *listed_rsc = (resource_t *) gIter->data;
data              288 pengine/utilization.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              310 pengine/utilization.c         rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
data              436 pengine/utilization.c             resource_t *child_rsc = (resource_t *) gIter->data;
data              463 pengine/utilization.c             resource_t *child_rsc = (resource_t *) gIter->data;
data               30 pengine/utils.c         order_constraint_t *order = iterator->data;
data               49 pengine/utils.c         rsc_to_node_t *cons = iterator->data;
data              138 pengine/utils.c sort_node_weight(gconstpointer a, gconstpointer b, gpointer data)
data              142 pengine/utils.c     const node_t *active = (node_t *) data;
data              286 pengine/utils.c             action_t *op = (action_t *) gIter->data;
data              389 pengine/utils.c             action_wrapper_t *other = (action_wrapper_t *) gIter->data;
data              398 pengine/utils.c             action_wrapper_t *other = (action_wrapper_t *) gIter->data;
data               50 tools/cibadmin.c gboolean admin_message_timeout(gpointer data);
data              207 tools/crm_mon.c mon_timer_popped(gpointer data)
data              869 tools/crm_mon.c         count += count_resources(data_set, gIter->data);
data              896 tools/crm_mon.c         node_t *node = (node_t *) gIter->data;
data             1196 tools/crm_mon.c         resource_t *rsc = (resource_t *) rsc_iter->data;
data             1537 tools/crm_mon.c         xmlNode *xml_op = (xmlNode *) gIter->data;
data             1625 tools/crm_mon.c         resource_t *rsc = (resource_t *) gIter->data;
data             1703 tools/crm_mon.c create_attr_list(gpointer name, gpointer value, gpointer data)
data             1730 tools/crm_mon.c     struct mon_attr_data *data = (struct mon_attr_data *) user_data;
data             1732 tools/crm_mon.c     value = pe_node_attribute_raw(data->node, name);
data             1743 tools/crm_mon.c             fprintf(data->stream, "   <li>%s: %s",
data             1748 tools/crm_mon.c             fprintf(data->stream,
data             1758 tools/crm_mon.c     print_attr_msg(data->stream, data->node, data->node->details->running_rsc,
data             1770 tools/crm_mon.c             fprintf(data->stream, "</li>\n");
data             1774 tools/crm_mon.c             fprintf(data->stream, " />\n");
data             1836 tools/crm_mon.c print_ticket(gpointer name, gpointer value, gpointer data)
data             1839 tools/crm_mon.c     FILE *stream = (FILE *) data;
data             1961 tools/crm_mon.c             node_t *host_node = (node_t *) node->details->remote_rsc->running_on->data;
data             2079 tools/crm_mon.c         rsc_to_node_t *location = (rsc_to_node_t *) gIter->data;
data             2083 tools/crm_mon.c             node_t *node = (node_t *) gIter2->data;
data             2116 tools/crm_mon.c             crm_mon_get_parameters(gIter->data, data_set);
data             2157 tools/crm_mon.c         crm_mon_get_parameters(gIter->data, data_set);
data             2162 tools/crm_mon.c         struct mon_attr_data data;
data             2164 tools/crm_mon.c         data.stream = stream;
data             2165 tools/crm_mon.c         data.node = (node_t *) gIter->data;
data             2167 tools/crm_mon.c         if (data.node && data.node->details && data.node->details->online) {
data             2168 tools/crm_mon.c             print_node_start(stream, data.node);
data             2169 tools/crm_mon.c             g_hash_table_foreach(data.node->details->attrs, create_attr_list, NULL);
data             2170 tools/crm_mon.c             g_list_foreach(attr_list, print_node_attribute, &data);
data             2937 tools/crm_mon.c         node_t *node = (node_t *) gIter->data;
data             3020 tools/crm_mon.c                     resource_t *rsc = (resource_t *) gIter2->data;
data             3110 tools/crm_mon.c         node_t *node = (node_t *) gIter->data;
data             3147 tools/crm_mon.c                 resource_t *rsc = (resource_t *) lpc2->data;
data             3239 tools/crm_mon.c         node_t *node = (node_t *) gIter->data;
data             3269 tools/crm_mon.c                 resource_t *rsc = (resource_t *) lpc2->data;
data              258 tools/crm_node.c             crm_node_t *peer = iter->data;
data              417 tools/crm_node.c ccm_age_callback(oc_ed_t event, void *cookie, size_t size, const void *data)
data              421 tools/crm_node.c     const oc_ev_membership_t *oc = (const oc_ev_membership_t *)data;
data              697 tools/crm_node.c     char *data = pcmk_message_common_cs(handle, nodeid, pid, msg, &kind, &from);
data              705 tools/crm_node.c             free(data);
data              724 tools/crm_node.c             crm_node_t *node = (crm_node_t *) lpc->data;
data              736 tools/crm_node.c             crm_node_t *node = (crm_node_t *) lpc->data;
data              745 tools/crm_node.c     free(data);
data               45 tools/crm_resource.c resource_ipc_timeout(gpointer data)
data              887 tools/crm_resource.c             rsc = (resource_t *) lpc->data;
data              922 tools/crm_resource.c             resource_t *r = (resource_t *) lpc->data;
data              933 tools/crm_resource.c             resource_t *r = (resource_t *) lpc->data;
data              945 tools/crm_resource.c             rsc = (resource_t *) lpc->data;
data             1020 tools/crm_resource.c             node_t *current = rsc->running_on->data;
data             1029 tools/crm_resource.c                 resource_t *child = (resource_t *)iter->data;
data             1034 tools/crm_resource.c                     current = child->running_on->data;
data             1172 tools/crm_resource.c                 node = node->details->remote_rsc->running_on->data;
data             1210 tools/crm_resource.c             rsc = rIter->data;
data               71 tools/crm_resource_ban.c             node_t *target = n->data;
data              224 tools/crm_resource_ban.c             node_t *target = n->data;
data               94 tools/crm_resource_print.c         node_t *tmp = rsc->running_on->data;
data              106 tools/crm_resource_print.c         resource_t *child = (resource_t *) lpc->data;
data              124 tools/crm_resource_print.c         resource_t *child = (resource_t *) lpc->data;
data              143 tools/crm_resource_print.c         resource_t *rsc = (resource_t *) lpc->data;
data              175 tools/crm_resource_print.c         xmlNode *xml_op = (xmlNode *) lpc->data;
data              218 tools/crm_resource_print.c         rsc_to_node_t *cons = (rsc_to_node_t *) lpc->data;
data              223 tools/crm_resource_print.c             node_t *node = (node_t *) lpc2->data;
data              256 tools/crm_resource_print.c         rsc_colocation_t *cons = (rsc_colocation_t *) lpc->data;
data              323 tools/crm_resource_print.c         current = rsc->running_on->data;
data               35 tools/crm_resource_runtime.c         node_t *node = (node_t *) lpc->data;
data               67 tools/crm_resource_runtime.c             found += do_find_resource(requested_name, iter->data, data_set);
data               78 tools/crm_resource_runtime.c             found += do_find_resource(requested_name, iter->data, data_set);
data              206 tools/crm_resource_runtime.c         resource_t *child = rsc->children->data;
data              360 tools/crm_resource_runtime.c                 resource_t *r = (resource_t *) lpc->data;
data              369 tools/crm_resource_runtime.c             rsc_colocation_t *cons = (rsc_colocation_t *) lpc->data;
data              480 tools/crm_resource_runtime.c             node = node->details->remote_rsc->running_on->data;
data              578 tools/crm_resource_runtime.c             resource_t *child = (resource_t *) lpc->data;
data              611 tools/crm_resource_runtime.c             node = (node_t *) lpc->data;
data              790 tools/crm_resource_runtime.c         pe_node_t *node = (pe_node_t *) hIter->data;
data              832 tools/crm_resource_runtime.c         resource_t *rsc = (resource_t *) rIter->data;
data              857 tools/crm_resource_runtime.c             crm_info("Comparing %s with %s", candidate->data, item->data);
data              858 tools/crm_resource_runtime.c             if(strcmp(candidate->data, item->data) == 0) {
data              859 tools/crm_resource_runtime.c                 result = g_list_remove(result, candidate->data);
data              874 tools/crm_resource_runtime.c         crm_trace("%s[%d]: %s", tag, lpc, (char*)item->data);
data              884 tools/crm_resource_runtime.c         fprintf(stdout, "%s%s\n", tag, (const char *)item->data);
data             1015 tools/crm_resource_runtime.c             resource_t *child = (resource_t *)iter->data;
data             1046 tools/crm_resource_runtime.c         resource_t *rsc = pe_find_resource(data_set->resources, (const char *)item->data);
data             1365 tools/crm_resource_runtime.c         if (action_is_pending((action_t *) action->data)) {
data             1387 tools/crm_resource_runtime.c         action_t *a = (action_t *) action->data;
data             1499 tools/crm_resource_runtime.c         rsc = rsc->children->data;
data             1644 tools/crm_resource_runtime.c             resource_t *child = (resource_t *)iter->data;
data             1671 tools/crm_resource_runtime.c         current = rsc->running_on->data;
data             1729 tools/crm_resource_runtime.c         resource_t *rsc = (resource_t *) lpc->data;
data             1767 tools/crm_resource_runtime.c         resource_t *rsc = (resource_t *) lpc->data;
data             1773 tools/crm_resource_runtime.c         resource_t *rsc = (resource_t *) lpc->data;
data               96 tools/crm_simulate.c         node_t *node = (node_t *) gIter->data;
data              196 tools/crm_simulate.c         resource_t *rsc = (resource_t *) gIter->data;
data              290 tools/crm_simulate.c         action_t *action = (action_t *) gIter->data;
data              335 tools/crm_simulate.c         action_t *action = (action_t *) gIter->data;
data              340 tools/crm_simulate.c             action_wrapper_t *before = (action_wrapper_t *) gIter2->data;
data              601 tools/crm_simulate.c         count += count_resources(data_set, gIter->data);
data              897 tools/crm_simulate.c                 resource_t *rsc = (resource_t *) gIter->data;
data              495 tools/crm_ticket.c         const char *key = (const char *)list_iter->data;
data              525 tools/crm_ticket.c         const char *key = (const char *)list_iter->data;
data              551 tools/crm_ticket.c         const char *key = (const char *)list_iter->data;
data               57 tools/crmadmin.c gboolean admin_message_timeout(gpointer data);
data              475 tools/crmadmin.c         xmlNode *data = get_message_xml(xml, F_CRM_DATA);
data              476 tools/crmadmin.c         const char *state = crm_element_value(data, "crmd_state");
data              479 tools/crmadmin.c                crm_element_value(data, XML_PING_ATTR_SYSFROM),
data              481 tools/crmadmin.c                state, crm_element_value(data, XML_PING_ATTR_STATUS));
data              510 tools/crmadmin.c admin_message_timeout(gpointer data)
data              452 tools/fake_transition.c         char *node = (char *)gIter->data;
data              466 tools/fake_transition.c         char *node = (char *)gIter->data;
data              489 tools/fake_transition.c         char *node = (char *)gIter->data;
data              503 tools/fake_transition.c         char *ticket_id = (char *)gIter->data;
data              513 tools/fake_transition.c         char *ticket_id = (char *)gIter->data;
data              523 tools/fake_transition.c         char *ticket_id = (char *)gIter->data;
data              533 tools/fake_transition.c         char *ticket_id = (char *)gIter->data;
data              543 tools/fake_transition.c         char *spec = (char *)gIter->data;
data              704 tools/fake_transition.c         char *spec = (char *)gIter->data;