root/lib/pacemaker/libpacemaker_private.h

/* */

INCLUDED FROM

DEFINITIONS

1. pcmk__colocation_node_attr

   1 /*
   2  * Copyright 2021-2024 the Pacemaker project contributors
   3  *
   4  * The version control history for this file may have further details.
   5  *
   6  * This source code is licensed under the GNU Lesser General Public License
   7  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
   8  */
   9 
  10 #ifndef PCMK__LIBPACEMAKER_PRIVATE__H
  11 #  define PCMK__LIBPACEMAKER_PRIVATE__H
  12 
  13 /* This header is for the sole use of libpacemaker, so that functions can be
  14  * declared with G_GNUC_INTERNAL for efficiency.
  15  */
  16 
  17 #include <crm/lrmd_events.h>      // lrmd_event_data_t
  18 #include <crm/common/scheduler.h> // pcmk_action_t, pcmk_node_t, etc.
  19 #include <crm/pengine/internal.h> // pcmk__location_t
  20 
  21 // Colocation flags
  22 enum pcmk__coloc_flags {
  23     pcmk__coloc_none        = 0U,
  24 
  25     // Primary is affected even if already active
  26     pcmk__coloc_influence   = (1U << 0),
  27 
  28     // Colocation was explicitly configured in CIB
  29     pcmk__coloc_explicit    = (1U << 1),
  30 };
  31 
  32 // Flags to modify the behavior of add_colocated_node_scores()
  33 enum pcmk__coloc_select {
  34     // With no other flags, apply all "with this" colocations
  35     pcmk__coloc_select_default      = 0,
  36 
  37     // Apply "this with" colocations instead of "with this" colocations
  38     pcmk__coloc_select_this_with    = (1 << 0),
  39 
  40     // Apply only colocations with non-negative scores
  41     pcmk__coloc_select_nonnegative  = (1 << 1),
  42 
  43     // Apply only colocations with at least one matching node
  44     pcmk__coloc_select_active       = (1 << 2),
  45 };
  46 
  47 // Flags the update_ordered_actions() method can return
  48 enum pcmk__updated {
  49     pcmk__updated_none      = 0,        // Nothing changed
  50     pcmk__updated_first     = (1 << 0), // First action was updated
  51     pcmk__updated_then      = (1 << 1), // Then action was updated
  52 };
  53 
  54 #define pcmk__set_updated_flags(au_flags, action, flags_to_set) do {        \
  55         au_flags = pcmk__set_flags_as(__func__, __LINE__,                   \
  56                                       LOG_TRACE, "Action update",           \
  57                                       (action)->uuid, au_flags,             \
  58                                       (flags_to_set), #flags_to_set);       \
  59     } while (0)
  60 
  61 #define pcmk__clear_updated_flags(au_flags, action, flags_to_clear) do {    \
  62         au_flags = pcmk__clear_flags_as(__func__, __LINE__,                 \
  63                                         LOG_TRACE, "Action update",         \
  64                                         (action)->uuid, au_flags,           \
  65                                         (flags_to_clear), #flags_to_clear); \
  66     } while (0)
  67 
  68 // Resource assignment methods
  69 struct resource_alloc_functions_s {
  70     /*!
  71      * \internal
  72      * \brief Assign a resource to a node
  73      *
  74      * \param[in,out] rsc           Resource to assign to a node
  75      * \param[in]     prefer        Node to prefer, if all else is equal
  76      * \param[in]     stop_if_fail  If \c true and \p rsc can't be assigned to a
  77      *                              node, set next role to stopped and update
  78      *                              existing actions (if \p rsc is not a
  79      *                              primitive, this applies to its primitive
  80      *                              descendants instead)
  81      *
  82      * \return Node that \p rsc is assigned to, if assigned entirely to one node
  83      *
  84      * \note If \p stop_if_fail is \c false, then \c pcmk__unassign_resource()
  85      *       can completely undo the assignment. A successful assignment can be
  86      *       either undone or left alone as final. A failed assignment has the
  87      *       same effect as calling pcmk__unassign_resource(); there are no side
  88      *       effects on roles or actions.
  89      */
  90     pcmk_node_t *(*assign)(pcmk_resource_t *rsc, const pcmk_node_t *prefer,
  91                            bool stop_if_fail);
  92 
  93     /*!
  94      * \internal
  95      * \brief Create all actions needed for a given resource
  96      *
  97      * \param[in,out] rsc  Resource to create actions for
  98      */
  99     void (*create_actions)(pcmk_resource_t *rsc);
 100 
 101     /*!
 102      * \internal
 103      * \brief Schedule any probes needed for a resource on a node
 104      *
 105      * \param[in,out] rsc   Resource to create probe for
 106      * \param[in,out] node  Node to create probe on
 107      *
 108      * \return true if any probe was created, otherwise false
 109      */
 110     bool (*create_probe)(pcmk_resource_t *rsc, pcmk_node_t *node);
 111 
 112     /*!
 113      * \internal
 114      * \brief Create implicit constraints needed for a resource
 115      *
 116      * \param[in,out] rsc  Resource to create implicit constraints for
 117      */
 118     void (*internal_constraints)(pcmk_resource_t *rsc);
 119 
 120     /*!
 121      * \internal
 122      * \brief Apply a colocation's score to node scores or resource priority
 123      *
 124      * Given a colocation constraint, apply its score to the dependent's
 125      * allowed node scores (if we are still placing resources) or priority (if
 126      * we are choosing promotable clone instance roles).
 127      *
 128      * \param[in,out] dependent      Dependent resource in colocation
 129      * \param[in]     primary        Primary resource in colocation
 130      * \param[in]     colocation     Colocation constraint to apply
 131      * \param[in]     for_dependent  true if called on behalf of dependent
 132      *
 133      * \return The score added to the dependent's priority
 134      */
 135     int (*apply_coloc_score)(pcmk_resource_t *dependent,
 136                              const pcmk_resource_t *primary,
 137                              const pcmk__colocation_t *colocation,
 138                              bool for_dependent);
 139 
 140     /*!
 141      * \internal
 142      * \brief Create list of all resources in colocations with a given resource
 143      *
 144      * Given a resource, create a list of all resources involved in mandatory
 145      * colocations with it, whether directly or via chained colocations.
 146      *
 147      * \param[in]     rsc             Resource to add to colocated list
 148      * \param[in]     orig_rsc        Resource originally requested
 149      * \param[in,out] colocated_rscs  Existing list
 150      *
 151      * \return List of given resource and all resources involved in colocations
 152      *
 153      * \note This function is recursive; top-level callers should pass NULL as
 154      *       \p colocated_rscs and \p orig_rsc, and the desired resource as
 155      *       \p rsc. The recursive calls will use other values.
 156      */
 157     GList *(*colocated_resources)(const pcmk_resource_t *rsc,
 158                                   const pcmk_resource_t *orig_rsc,
 159                                   GList *colocated_rscs);
 160 
 161     /*!
 162      * \internal
 163      * \brief Add colocations affecting a resource as primary to a list
 164      *
 165      * Given a resource being assigned (\p orig_rsc) and a resource somewhere in
 166      * its chain of ancestors (\p rsc, which may be \p orig_rsc), get
 167      * colocations that affect the ancestor as primary and should affect the
 168      * resource, and add them to a given list.
 169      *
 170      * \param[in]     rsc       Resource whose colocations should be added
 171      * \param[in]     orig_rsc  Affected resource (\p rsc or a descendant)
 172      * \param[in,out] list      List of colocations to add to
 173      *
 174      * \note All arguments should be non-NULL.
 175      * \note The pcmk__with_this_colocations() wrapper should usually be used
 176      *       instead of using this method directly.
 177      */
 178     void (*with_this_colocations)(const pcmk_resource_t *rsc,
 179                                   const pcmk_resource_t *orig_rsc,
 180                                   GList **list);
 181 
 182     /*!
 183      * \internal
 184      * \brief Add colocations affecting a resource as dependent to a list
 185      *
 186      * Given a resource being assigned (\p orig_rsc) and a resource somewhere in
 187      * its chain of ancestors (\p rsc, which may be \p orig_rsc), get
 188      * colocations that affect the ancestor as dependent and should affect the
 189      * resource, and add them to a given list.
 190      *
 191      *
 192      * \param[in]     rsc       Resource whose colocations should be added
 193      * \param[in]     orig_rsc  Affected resource (\p rsc or a descendant)
 194      * \param[in,out] list      List of colocations to add to
 195      *
 196      * \note All arguments should be non-NULL.
 197      * \note The pcmk__this_with_colocations() wrapper should usually be used
 198      *       instead of using this method directly.
 199      */
 200     void (*this_with_colocations)(const pcmk_resource_t *rsc,
 201                                   const pcmk_resource_t *orig_rsc,
 202                                   GList **list);
 203 
 204     /*!
 205      * \internal
 206      * \brief Update nodes with scores of colocated resources' nodes
 207      *
 208      * Given a table of nodes and a resource, update the nodes' scores with the
 209      * scores of the best nodes matching the attribute used for each of the
 210      * resource's relevant colocations.
 211      *
 212      * \param[in,out] source_rsc  Resource whose node scores to add
 213      * \param[in]     target_rsc  Resource on whose behalf to update \p *nodes
 214      * \param[in]     log_id      Resource ID for logs (if \c NULL, use
 215      *                            \p source_rsc ID)
 216      * \param[in,out] nodes       Nodes to update (set initial contents to
 217      *                            \c NULL to copy allowed nodes from
 218      *                            \p source_rsc)
 219      * \param[in]     colocation  Original colocation constraint (used to get
 220      *                            configured primary resource's stickiness, and
 221      *                            to get colocation node attribute; if \c NULL,
 222      *                            <tt>source_rsc</tt>'s own matching node scores
 223      *                            will not be added, and \p *nodes must be
 224      *                            \c NULL as well)
 225      * \param[in]     factor      Incorporate scores multiplied by this factor
 226      * \param[in]     flags       Bitmask of enum pcmk__coloc_select values
 227      *
 228      * \note \c NULL \p target_rsc, \c NULL \p *nodes, \c NULL \p colocation,
 229      *       and the \c pcmk__coloc_select_this_with flag are used together (and
 230      *       only by \c cmp_resources()).
 231      * \note The caller remains responsible for freeing \p *nodes.
 232      */
 233     void (*add_colocated_node_scores)(pcmk_resource_t *source_rsc,
 234                                       const pcmk_resource_t *target_rsc,
 235                                       const char *log_id, GHashTable **nodes,
 236                                       const pcmk__colocation_t *colocation,
 237                                       float factor, uint32_t flags);
 238 
 239     /*!
 240      * \internal
 241      * \brief Apply a location constraint to a resource's allowed node scores
 242      *
 243      * \param[in,out] rsc       Resource to apply constraint to
 244      * \param[in,out] location  Location constraint to apply
 245      */
 246     void (*apply_location)(pcmk_resource_t *rsc, pcmk__location_t *location);
 247 
 248     /*!
 249      * \internal
 250      * \brief Return action flags for a given resource action
 251      *
 252      * \param[in,out] action  Action to get flags for
 253      * \param[in]     node    If not NULL, limit effects to this node
 254      *
 255      * \return Flags appropriate to \p action on \p node
 256      * \note For primitives, this will be the same as action->flags regardless
 257      *       of node. For collective resources, the flags can differ due to
 258      *       multiple instances possibly being involved.
 259      */
 260     uint32_t (*action_flags)(pcmk_action_t *action, const pcmk_node_t *node);
 261 
 262     /*!
 263      * \internal
 264      * \brief Update two actions according to an ordering between them
 265      *
 266      * Given information about an ordering of two actions, update the actions'
 267      * flags (and runnable_before members if appropriate) as appropriate for the
 268      * ordering. Effects may cascade to other orderings involving the actions as
 269      * well.
 270      *
 271      * \param[in,out] first      'First' action in an ordering
 272      * \param[in,out] then       'Then' action in an ordering
 273      * \param[in]     node       If not NULL, limit scope of ordering to this
 274      *                           node (only used when interleaving instances)
 275      * \param[in]     flags      Action flags for \p first for ordering purposes
 276      * \param[in]     filter     Action flags to limit scope of certain updates
 277      *                           (may include pcmk_action_optional to affect
 278      *                           only mandatory actions and pcmk_action_runnable
 279      *                           to affect only runnable actions)
 280      * \param[in]     type       Group of enum pcmk__action_relation_flags
 281      * \param[in,out] scheduler  Scheduler data
 282      *
 283      * \return Group of enum pcmk__updated flags indicating what was updated
 284      */
 285     uint32_t (*update_ordered_actions)(pcmk_action_t *first,
 286                                        pcmk_action_t *then,
 287                                        const pcmk_node_t *node, uint32_t flags,
 288                                        uint32_t filter, uint32_t type,
 289                                        pcmk_scheduler_t *scheduler);
 290 
 291     /*!
 292      * \internal
 293      * \brief Output a summary of scheduled actions for a resource
 294      *
 295      * \param[in,out] rsc  Resource to output actions for
 296      */
 297     void (*output_actions)(pcmk_resource_t *rsc);
 298 
 299     /*!
 300      * \internal
 301      * \brief Add a resource's actions to the transition graph
 302      *
 303      * \param[in,out] rsc  Resource whose actions should be added
 304      */
 305     void (*add_actions_to_graph)(pcmk_resource_t *rsc);
 306 
 307     /*!
 308      * \internal
 309      * \brief Add meta-attributes relevant to transition graph actions to XML
 310      *
 311      * If a given resource supports variant-specific meta-attributes that are
 312      * needed for transition graph actions, add them to a given XML element.
 313      *
 314      * \param[in]     rsc  Resource whose meta-attributes should be added
 315      * \param[in,out] xml  Transition graph action attributes XML to add to
 316      */
 317     void (*add_graph_meta)(const pcmk_resource_t *rsc, xmlNode *xml);
 318 
 319     /*!
 320      * \internal
 321      * \brief Add a resource's utilization to a table of utilization values
 322      *
 323      * This function is used when summing the utilization of a resource and all
 324      * resources colocated with it, to determine whether a node has sufficient
 325      * capacity. Given a resource and a table of utilization values, it will add
 326      * the resource's utilization to the existing values, if the resource has
 327      * not yet been assigned to a node.
 328      *
 329      * \param[in]     rsc          Resource with utilization to add
 330      * \param[in]     orig_rsc     Resource being assigned (for logging only)
 331      * \param[in]     all_rscs     List of all resources that will be summed
 332      * \param[in,out] utilization  Table of utilization values to add to
 333      */
 334     void (*add_utilization)(const pcmk_resource_t *rsc,
 335                             const pcmk_resource_t *orig_rsc, GList *all_rscs,
 336                             GHashTable *utilization);
 337 
 338     /*!
 339      * \internal
 340      * \brief Apply a shutdown lock for a resource, if appropriate
 341      *
 342      * \param[in,out] rsc       Resource to check for shutdown lock
 343      */
 344     void (*shutdown_lock)(pcmk_resource_t *rsc);
 345 };
 346 
 347 // Actions (pcmk_sched_actions.c)
 348 
 349 G_GNUC_INTERNAL
 350 void pcmk__update_action_for_orderings(pcmk_action_t *action,
 351                                        pcmk_scheduler_t *scheduler);
 352 
 353 G_GNUC_INTERNAL
 354 uint32_t pcmk__update_ordered_actions(pcmk_action_t *first, pcmk_action_t *then,
 355                                       const pcmk_node_t *node, uint32_t flags,
 356                                       uint32_t filter, uint32_t type,
 357                                       pcmk_scheduler_t *scheduler);
 358 
 359 G_GNUC_INTERNAL
 360 void pcmk__log_action(const char *pre_text, const pcmk_action_t *action,
 361                       bool details);
 362 
 363 G_GNUC_INTERNAL
 364 pcmk_action_t *pcmk__new_cancel_action(pcmk_resource_t *rsc, const char *name,
 365                                        guint interval_ms,
 366                                        const pcmk_node_t *node);
 367 
 368 G_GNUC_INTERNAL
 369 pcmk_action_t *pcmk__new_shutdown_action(pcmk_node_t *node);
 370 
 371 G_GNUC_INTERNAL
 372 bool pcmk__action_locks_rsc_to_node(const pcmk_action_t *action);
 373 
 374 G_GNUC_INTERNAL
 375 void pcmk__deduplicate_action_inputs(pcmk_action_t *action);
 376 
 377 G_GNUC_INTERNAL
 378 void pcmk__output_actions(pcmk_scheduler_t *scheduler);
 379 
 380 G_GNUC_INTERNAL
 381 bool pcmk__check_action_config(pcmk_resource_t *rsc, pcmk_node_t *node,
 382                                const xmlNode *xml_op);
 383 
 384 G_GNUC_INTERNAL
 385 void pcmk__handle_rsc_config_changes(pcmk_scheduler_t *scheduler);
 386 
 387 
 388 // Recurring actions (pcmk_sched_recurring.c)
 389 
 390 G_GNUC_INTERNAL
 391 void pcmk__create_recurring_actions(pcmk_resource_t *rsc);
 392 
 393 G_GNUC_INTERNAL
 394 void pcmk__schedule_cancel(pcmk_resource_t *rsc, const char *call_id,
 395                            const char *task, guint interval_ms,
 396                            const pcmk_node_t *node, const char *reason);
 397 
 398 G_GNUC_INTERNAL
 399 void pcmk__reschedule_recurring(pcmk_resource_t *rsc, const char *task,
 400                                 guint interval_ms, pcmk_node_t *node);
 401 
 402 G_GNUC_INTERNAL
 403 bool pcmk__action_is_recurring(const pcmk_action_t *action);
 404 
 405 
 406 // Producing transition graphs (pcmk_graph_producer.c)
 407 
 408 G_GNUC_INTERNAL
 409 bool pcmk__graph_has_loop(const pcmk_action_t *init_action,
 410                           const pcmk_action_t *action,
 411                           pcmk__related_action_t *input);
 412 
 413 G_GNUC_INTERNAL
 414 void pcmk__add_rsc_actions_to_graph(pcmk_resource_t *rsc);
 415 
 416 G_GNUC_INTERNAL
 417 void pcmk__create_graph(pcmk_scheduler_t *scheduler);
 418 
 419 
 420 // Fencing (pcmk_sched_fencing.c)
 421 
 422 G_GNUC_INTERNAL
 423 void pcmk__order_vs_fence(pcmk_action_t *stonith_op,
 424                           pcmk_scheduler_t *scheduler);
 425 
 426 G_GNUC_INTERNAL
 427 void pcmk__order_vs_unfence(const pcmk_resource_t *rsc, pcmk_node_t *node,
 428                             pcmk_action_t *action,
 429                             enum pcmk__action_relation_flags order);
 430 
 431 G_GNUC_INTERNAL
 432 void pcmk__fence_guest(pcmk_node_t *node);
 433 
 434 G_GNUC_INTERNAL
 435 bool pcmk__node_unfenced(const pcmk_node_t *node);
 436 
 437 G_GNUC_INTERNAL
 438 void pcmk__order_restart_vs_unfence(gpointer data, gpointer user_data);
 439 
 440 
 441 // Injected scheduler inputs (pcmk_sched_injections.c)
 442 
 443 void pcmk__inject_scheduler_input(pcmk_scheduler_t *scheduler, cib_t *cib,
 444                                   const pcmk_injections_t *injections);
 445 
 446 
 447 // Constraints of any type (pcmk_sched_constraints.c)
 448 
 449 G_GNUC_INTERNAL
 450 pcmk_resource_t *pcmk__find_constraint_resource(GList *rsc_list,
 451                                                 const char *id);
 452 
 453 G_GNUC_INTERNAL
 454 xmlNode *pcmk__expand_tags_in_sets(xmlNode *xml_obj,
 455                                    const pcmk_scheduler_t *scheduler);
 456 
 457 G_GNUC_INTERNAL
 458 bool pcmk__valid_resource_or_tag(const pcmk_scheduler_t *scheduler,
 459                                  const char *id, pcmk_resource_t **rsc,
 460                                  pcmk_tag_t **tag);
 461 
 462 G_GNUC_INTERNAL
 463 bool pcmk__tag_to_set(xmlNode *xml_obj, xmlNode **rsc_set, const char *attr,
 464                       bool convert_rsc, const pcmk_scheduler_t *scheduler);
 465 
 466 G_GNUC_INTERNAL
 467 void pcmk__create_internal_constraints(pcmk_scheduler_t *scheduler);
 468 
 469 
 470 // Location constraints
 471 
 472 G_GNUC_INTERNAL
 473 void pcmk__unpack_location(xmlNode *xml_obj, pcmk_scheduler_t *scheduler);
 474 
 475 G_GNUC_INTERNAL
 476 pcmk__location_t *pcmk__new_location(const char *id, pcmk_resource_t *rsc,
 477                                      int node_score, const char *discover_mode,
 478                                      pcmk_node_t *foo_node);
 479 
 480 G_GNUC_INTERNAL
 481 void pcmk__apply_locations(pcmk_scheduler_t *scheduler);
 482 
 483 G_GNUC_INTERNAL
 484 void pcmk__apply_location(pcmk_resource_t *rsc, pcmk__location_t *constraint);
 485 
 486 
 487 // Colocation constraints (pcmk_sched_colocation.c)
 488 
 489 enum pcmk__coloc_affects {
 490     pcmk__coloc_affects_nothing = 0,
 491     pcmk__coloc_affects_location,
 492     pcmk__coloc_affects_role,
 493 };
 494 
 495 /*!
 496  * \internal
 497  * \brief Get the value of a colocation's node attribute
 498  *
 499  * \param[in] node  Node on which to look up the attribute
 500  * \param[in] attr  Name of attribute to look up
 501  * \param[in] rsc   Resource on whose behalf to look up the attribute
 502  *
 503  * \return Value of \p attr on \p node or on the host of \p node, as appropriate
 504  */
 505 static inline const char *
 506 pcmk__colocation_node_attr(const pcmk_node_t *node, const char *attr,
     /*  */
 507                            const pcmk_resource_t *rsc)
 508 {
 509     const char *target = NULL;
 510 
 511     /* A resource colocated with a bundle or its primitive can't run on the
 512      * bundle node itself (where only the primitive, if any, can run). Instead,
 513      * we treat it as a colocation with the bundle's containers, so always look
 514      * up colocation node attributes on the container host.
 515      */
 516     if (pcmk__is_bundle_node(node) && pcmk__is_bundled(rsc)
 517         && (pe__const_top_resource(rsc, false) == pe__bundled_resource(rsc))) {
 518         target = PCMK_VALUE_HOST;
 519 
 520     } else if (rsc != NULL) {
 521         target = g_hash_table_lookup(rsc->meta,
 522                                      PCMK_META_CONTAINER_ATTRIBUTE_TARGET);
 523     }
 524 
 525     return pcmk__node_attr(node, attr, target, pcmk__rsc_node_assigned);
 526 }
 527 
 528 G_GNUC_INTERNAL
 529 enum pcmk__coloc_affects pcmk__colocation_affects(const pcmk_resource_t
 530                                                     *dependent,
 531                                                   const pcmk_resource_t
 532                                                     *primary,
 533                                                   const pcmk__colocation_t
 534                                                     *colocation,
 535                                                   bool preview);
 536 
 537 G_GNUC_INTERNAL
 538 void pcmk__apply_coloc_to_scores(pcmk_resource_t *dependent,
 539                                  const pcmk_resource_t *primary,
 540                                  const pcmk__colocation_t *colocation);
 541 
 542 G_GNUC_INTERNAL
 543 int pcmk__apply_coloc_to_priority(pcmk_resource_t *dependent,
 544                                   const pcmk_resource_t *primary,
 545                                   const pcmk__colocation_t *colocation);
 546 
 547 G_GNUC_INTERNAL
 548 void pcmk__add_colocated_node_scores(pcmk_resource_t *source_rsc,
 549                                      const pcmk_resource_t *target_rsc,
 550                                      const char *log_id, GHashTable **nodes,
 551                                      const pcmk__colocation_t *colocation,
 552                                      float factor, uint32_t flags);
 553 
 554 G_GNUC_INTERNAL
 555 void pcmk__add_dependent_scores(gpointer data, gpointer user_data);
 556 
 557 G_GNUC_INTERNAL
 558 void pcmk__colocation_intersect_nodes(pcmk_resource_t *dependent,
 559                                       const pcmk_resource_t *primary,
 560                                       const pcmk__colocation_t *colocation,
 561                                       const GList *primary_nodes,
 562                                       bool merge_scores);
 563 
 564 G_GNUC_INTERNAL
 565 void pcmk__unpack_colocation(xmlNode *xml_obj, pcmk_scheduler_t *scheduler);
 566 
 567 G_GNUC_INTERNAL
 568 void pcmk__add_this_with(GList **list, const pcmk__colocation_t *colocation,
 569                          const pcmk_resource_t *rsc);
 570 
 571 G_GNUC_INTERNAL
 572 void pcmk__add_this_with_list(GList **list, GList *addition,
 573                               const pcmk_resource_t *rsc);
 574 
 575 G_GNUC_INTERNAL
 576 void pcmk__add_with_this(GList **list, const pcmk__colocation_t *colocation,
 577                          const pcmk_resource_t *rsc);
 578 
 579 G_GNUC_INTERNAL
 580 void pcmk__add_with_this_list(GList **list, GList *addition,
 581                               const pcmk_resource_t *rsc);
 582 
 583 G_GNUC_INTERNAL
 584 GList *pcmk__with_this_colocations(const pcmk_resource_t *rsc);
 585 
 586 G_GNUC_INTERNAL
 587 GList *pcmk__this_with_colocations(const pcmk_resource_t *rsc);
 588 
 589 G_GNUC_INTERNAL
 590 void pcmk__new_colocation(const char *id, const char *node_attr, int score,
 591                           pcmk_resource_t *dependent, pcmk_resource_t *primary,
 592                           const char *dependent_role, const char *primary_role,
 593                           uint32_t flags);
 594 
 595 G_GNUC_INTERNAL
 596 void pcmk__block_colocation_dependents(pcmk_action_t *action);
 597 
 598 G_GNUC_INTERNAL
 599 bool pcmk__colocation_has_influence(const pcmk__colocation_t *colocation,
 600                                     const pcmk_resource_t *rsc);
 601 
 602 
 603 // Ordering constraints (pcmk_sched_ordering.c)
 604 
 605 G_GNUC_INTERNAL
 606 void pcmk__new_ordering(pcmk_resource_t *first_rsc, char *first_task,
 607                         pcmk_action_t *first_action, pcmk_resource_t *then_rsc,
 608                         char *then_task, pcmk_action_t *then_action,
 609                         uint32_t flags, pcmk_scheduler_t *sched);
 610 
 611 G_GNUC_INTERNAL
 612 void pcmk__unpack_ordering(xmlNode *xml_obj, pcmk_scheduler_t *scheduler);
 613 
 614 G_GNUC_INTERNAL
 615 void pcmk__disable_invalid_orderings(pcmk_scheduler_t *scheduler);
 616 
 617 G_GNUC_INTERNAL
 618 void pcmk__order_stops_before_shutdown(pcmk_node_t *node,
 619                                        pcmk_action_t *shutdown_op);
 620 
 621 G_GNUC_INTERNAL
 622 void pcmk__apply_orderings(pcmk_scheduler_t *sched);
 623 
 624 G_GNUC_INTERNAL
 625 void pcmk__order_after_each(pcmk_action_t *after, GList *list);
 626 
 627 
 628 /*!
 629  * \internal
 630  * \brief Create a new ordering between two resource actions
 631  *
 632  * \param[in,out] first_rsc   Resource for 'first' action
 633  * \param[in,out] first_task  Action key for 'first' action
 634  * \param[in]     then_rsc    Resource for 'then' action
 635  * \param[in,out] then_task   Action key for 'then' action
 636  * \param[in]     flags       Group of enum pcmk__action_relation_flags
 637  */
 638 #define pcmk__order_resource_actions(first_rsc, first_task,                 \
 639                                      then_rsc, then_task, flags)            \
 640     pcmk__new_ordering((first_rsc),                                         \
 641                        pcmk__op_key((first_rsc)->id, (first_task), 0),      \
 642                        NULL,                                                \
 643                        (then_rsc),                                          \
 644                        pcmk__op_key((then_rsc)->id, (then_task), 0),        \
 645                        NULL, (flags), (first_rsc)->cluster)
 646 
 647 #define pcmk__order_starts(rsc1, rsc2, flags)                \
 648     pcmk__order_resource_actions((rsc1), PCMK_ACTION_START,  \
 649                                  (rsc2), PCMK_ACTION_START, (flags))
 650 
 651 #define pcmk__order_stops(rsc1, rsc2, flags)                 \
 652     pcmk__order_resource_actions((rsc1), PCMK_ACTION_STOP,   \
 653                                  (rsc2), PCMK_ACTION_STOP, (flags))
 654 
 655 
 656 // Ticket constraints (pcmk_sched_tickets.c)
 657 
 658 G_GNUC_INTERNAL
 659 void pcmk__unpack_rsc_ticket(xmlNode *xml_obj, pcmk_scheduler_t *scheduler);
 660 
 661 
 662 // Promotable clone resources (pcmk_sched_promotable.c)
 663 
 664 G_GNUC_INTERNAL
 665 void pcmk__add_promotion_scores(pcmk_resource_t *rsc);
 666 
 667 G_GNUC_INTERNAL
 668 void pcmk__require_promotion_tickets(pcmk_resource_t *rsc);
 669 
 670 G_GNUC_INTERNAL
 671 void pcmk__set_instance_roles(pcmk_resource_t *rsc);
 672 
 673 G_GNUC_INTERNAL
 674 void pcmk__create_promotable_actions(pcmk_resource_t *clone);
 675 
 676 G_GNUC_INTERNAL
 677 void pcmk__promotable_restart_ordering(pcmk_resource_t *rsc);
 678 
 679 G_GNUC_INTERNAL
 680 void pcmk__order_promotable_instances(pcmk_resource_t *clone);
 681 
 682 G_GNUC_INTERNAL
 683 void pcmk__update_dependent_with_promotable(const pcmk_resource_t *primary,
 684                                             pcmk_resource_t *dependent,
 685                                             const pcmk__colocation_t
 686                                                 *colocation);
 687 
 688 G_GNUC_INTERNAL
 689 int pcmk__update_promotable_dependent_priority(const pcmk_resource_t *primary,
 690                                                pcmk_resource_t *dependent,
 691                                                const pcmk__colocation_t
 692                                                    *colocation);
 693 
 694 
 695 // Pacemaker Remote nodes (pcmk_sched_remote.c)
 696 
 697 G_GNUC_INTERNAL
 698 bool pcmk__is_failed_remote_node(const pcmk_node_t *node);
 699 
 700 G_GNUC_INTERNAL
 701 void pcmk__order_remote_connection_actions(pcmk_scheduler_t *scheduler);
 702 
 703 G_GNUC_INTERNAL
 704 bool pcmk__rsc_corresponds_to_guest(const pcmk_resource_t *rsc,
 705                                     const pcmk_node_t *node);
 706 
 707 G_GNUC_INTERNAL
 708 pcmk_node_t *pcmk__connection_host_for_action(const pcmk_action_t *action);
 709 
 710 G_GNUC_INTERNAL
 711 void pcmk__substitute_remote_addr(pcmk_resource_t *rsc, GHashTable *params);
 712 
 713 G_GNUC_INTERNAL
 714 void pcmk__add_guest_meta_to_xml(xmlNode *args_xml,
 715                                  const pcmk_action_t *action);
 716 
 717 
 718 // Primitives (pcmk_sched_primitive.c)
 719 
 720 G_GNUC_INTERNAL
 721 pcmk_node_t *pcmk__primitive_assign(pcmk_resource_t *rsc,
 722                                     const pcmk_node_t *prefer,
 723                                     bool stop_if_fail);
 724 
 725 G_GNUC_INTERNAL
 726 void pcmk__primitive_create_actions(pcmk_resource_t *rsc);
 727 
 728 G_GNUC_INTERNAL
 729 void pcmk__primitive_internal_constraints(pcmk_resource_t *rsc);
 730 
 731 G_GNUC_INTERNAL
 732 uint32_t pcmk__primitive_action_flags(pcmk_action_t *action,
 733                                       const pcmk_node_t *node);
 734 
 735 G_GNUC_INTERNAL
 736 int pcmk__primitive_apply_coloc_score(pcmk_resource_t *dependent,
 737                                       const pcmk_resource_t *primary,
 738                                       const pcmk__colocation_t *colocation,
 739                                       bool for_dependent);
 740 
 741 G_GNUC_INTERNAL
 742 void pcmk__with_primitive_colocations(const pcmk_resource_t *rsc,
 743                                       const pcmk_resource_t *orig_rsc,
 744                                       GList **list);
 745 
 746 G_GNUC_INTERNAL
 747 void pcmk__primitive_with_colocations(const pcmk_resource_t *rsc,
 748                                       const pcmk_resource_t *orig_rsc,
 749                                       GList **list);
 750 
 751 G_GNUC_INTERNAL
 752 void pcmk__schedule_cleanup(pcmk_resource_t *rsc, const pcmk_node_t *node,
 753                             bool optional);
 754 
 755 G_GNUC_INTERNAL
 756 void pcmk__primitive_add_graph_meta(const pcmk_resource_t *rsc, xmlNode *xml);
 757 
 758 G_GNUC_INTERNAL
 759 void pcmk__primitive_add_utilization(const pcmk_resource_t *rsc,
 760                                      const pcmk_resource_t *orig_rsc,
 761                                      GList *all_rscs, GHashTable *utilization);
 762 
 763 G_GNUC_INTERNAL
 764 void pcmk__primitive_shutdown_lock(pcmk_resource_t *rsc);
 765 
 766 
 767 // Groups (pcmk_sched_group.c)
 768 
 769 G_GNUC_INTERNAL
 770 pcmk_node_t *pcmk__group_assign(pcmk_resource_t *rsc, const pcmk_node_t *prefer,
 771                                 bool stop_if_fail);
 772 
 773 G_GNUC_INTERNAL
 774 void pcmk__group_create_actions(pcmk_resource_t *rsc);
 775 
 776 G_GNUC_INTERNAL
 777 void pcmk__group_internal_constraints(pcmk_resource_t *rsc);
 778 
 779 G_GNUC_INTERNAL
 780 int pcmk__group_apply_coloc_score(pcmk_resource_t *dependent,
 781                                   const pcmk_resource_t *primary,
 782                                   const pcmk__colocation_t *colocation,
 783                                   bool for_dependent);
 784 
 785 G_GNUC_INTERNAL
 786 void pcmk__with_group_colocations(const pcmk_resource_t *rsc,
 787                                   const pcmk_resource_t *orig_rsc,
 788                                   GList **list);
 789 
 790 G_GNUC_INTERNAL
 791 void pcmk__group_with_colocations(const pcmk_resource_t *rsc,
 792                                   const pcmk_resource_t *orig_rsc,
 793                                   GList **list);
 794 
 795 G_GNUC_INTERNAL
 796 void pcmk__group_add_colocated_node_scores(pcmk_resource_t *source_rsc,
 797                                            const pcmk_resource_t *target_rsc,
 798                                            const char *log_id,
 799                                            GHashTable **nodes,
 800                                            const pcmk__colocation_t *colocation,
 801                                            float factor, uint32_t flags);
 802 
 803 G_GNUC_INTERNAL
 804 void pcmk__group_apply_location(pcmk_resource_t *rsc,
 805                                 pcmk__location_t *location);
 806 
 807 G_GNUC_INTERNAL
 808 uint32_t pcmk__group_action_flags(pcmk_action_t *action,
 809                                   const pcmk_node_t *node);
 810 
 811 G_GNUC_INTERNAL
 812 uint32_t pcmk__group_update_ordered_actions(pcmk_action_t *first,
 813                                             pcmk_action_t *then,
 814                                             const pcmk_node_t *node,
 815                                             uint32_t flags, uint32_t filter,
 816                                             uint32_t type,
 817                                             pcmk_scheduler_t *scheduler);
 818 
 819 G_GNUC_INTERNAL
 820 GList *pcmk__group_colocated_resources(const pcmk_resource_t *rsc,
 821                                        const pcmk_resource_t *orig_rsc,
 822                                        GList *colocated_rscs);
 823 
 824 G_GNUC_INTERNAL
 825 void pcmk__group_add_utilization(const pcmk_resource_t *rsc,
 826                                  const pcmk_resource_t *orig_rsc,
 827                                  GList *all_rscs, GHashTable *utilization);
 828 
 829 G_GNUC_INTERNAL
 830 void pcmk__group_shutdown_lock(pcmk_resource_t *rsc);
 831 
 832 
 833 // Clones (pcmk_sched_clone.c)
 834 
 835 G_GNUC_INTERNAL
 836 pcmk_node_t *pcmk__clone_assign(pcmk_resource_t *rsc, const pcmk_node_t *prefer,
 837                                 bool stop_if_fail);
 838 
 839 G_GNUC_INTERNAL
 840 void pcmk__clone_create_actions(pcmk_resource_t *rsc);
 841 
 842 G_GNUC_INTERNAL
 843 bool pcmk__clone_create_probe(pcmk_resource_t *rsc, pcmk_node_t *node);
 844 
 845 G_GNUC_INTERNAL
 846 void pcmk__clone_internal_constraints(pcmk_resource_t *rsc);
 847 
 848 G_GNUC_INTERNAL
 849 int pcmk__clone_apply_coloc_score(pcmk_resource_t *dependent,
 850                                   const pcmk_resource_t *primary,
 851                                   const pcmk__colocation_t *colocation,
 852                                   bool for_dependent);
 853 
 854 G_GNUC_INTERNAL
 855 void pcmk__with_clone_colocations(const pcmk_resource_t *rsc,
 856                                   const pcmk_resource_t *orig_rsc,
 857                                   GList **list);
 858 
 859 G_GNUC_INTERNAL
 860 void pcmk__clone_with_colocations(const pcmk_resource_t *rsc,
 861                                   const pcmk_resource_t *orig_rsc,
 862                                   GList **list);
 863 
 864 G_GNUC_INTERNAL
 865 void pcmk__clone_apply_location(pcmk_resource_t *rsc,
 866                                 pcmk__location_t *constraint);
 867 
 868 G_GNUC_INTERNAL
 869 uint32_t pcmk__clone_action_flags(pcmk_action_t *action,
 870                                   const pcmk_node_t *node);
 871 
 872 G_GNUC_INTERNAL
 873 void pcmk__clone_add_actions_to_graph(pcmk_resource_t *rsc);
 874 
 875 G_GNUC_INTERNAL
 876 void pcmk__clone_add_graph_meta(const pcmk_resource_t *rsc, xmlNode *xml);
 877 
 878 G_GNUC_INTERNAL
 879 void pcmk__clone_add_utilization(const pcmk_resource_t *rsc,
 880                                  const pcmk_resource_t *orig_rsc,
 881                                  GList *all_rscs, GHashTable *utilization);
 882 
 883 G_GNUC_INTERNAL
 884 void pcmk__clone_shutdown_lock(pcmk_resource_t *rsc);
 885 
 886 // Bundles (pcmk_sched_bundle.c)
 887 
 888 G_GNUC_INTERNAL
 889 pcmk_node_t *pcmk__bundle_assign(pcmk_resource_t *rsc,
 890                                  const pcmk_node_t *prefer, bool stop_if_fail);
 891 
 892 G_GNUC_INTERNAL
 893 void pcmk__bundle_create_actions(pcmk_resource_t *rsc);
 894 
 895 G_GNUC_INTERNAL
 896 bool pcmk__bundle_create_probe(pcmk_resource_t *rsc, pcmk_node_t *node);
 897 
 898 G_GNUC_INTERNAL
 899 void pcmk__bundle_internal_constraints(pcmk_resource_t *rsc);
 900 
 901 G_GNUC_INTERNAL
 902 int pcmk__bundle_apply_coloc_score(pcmk_resource_t *dependent,
 903                                    const pcmk_resource_t *primary,
 904                                    const pcmk__colocation_t *colocation,
 905                                    bool for_dependent);
 906 
 907 G_GNUC_INTERNAL
 908 void pcmk__with_bundle_colocations(const pcmk_resource_t *rsc,
 909                                    const pcmk_resource_t *orig_rsc,
 910                                    GList **list);
 911 
 912 G_GNUC_INTERNAL
 913 void pcmk__bundle_with_colocations(const pcmk_resource_t *rsc,
 914                                    const pcmk_resource_t *orig_rsc,
 915                                    GList **list);
 916 
 917 G_GNUC_INTERNAL
 918 void pcmk__bundle_apply_location(pcmk_resource_t *rsc,
 919                                  pcmk__location_t *constraint);
 920 
 921 G_GNUC_INTERNAL
 922 uint32_t pcmk__bundle_action_flags(pcmk_action_t *action,
 923                                    const pcmk_node_t *node);
 924 
 925 G_GNUC_INTERNAL
 926 void pcmk__output_bundle_actions(pcmk_resource_t *rsc);
 927 
 928 G_GNUC_INTERNAL
 929 void pcmk__bundle_add_actions_to_graph(pcmk_resource_t *rsc);
 930 
 931 G_GNUC_INTERNAL
 932 void pcmk__bundle_add_utilization(const pcmk_resource_t *rsc,
 933                                   const pcmk_resource_t *orig_rsc,
 934                                   GList *all_rscs, GHashTable *utilization);
 935 
 936 G_GNUC_INTERNAL
 937 void pcmk__bundle_shutdown_lock(pcmk_resource_t *rsc);
 938 
 939 
 940 // Clone instances or bundle replica containers (pcmk_sched_instances.c)
 941 
 942 G_GNUC_INTERNAL
 943 void pcmk__assign_instances(pcmk_resource_t *collective, GList *instances,
 944                             int max_total, int max_per_node);
 945 
 946 G_GNUC_INTERNAL
 947 void pcmk__create_instance_actions(pcmk_resource_t *rsc, GList *instances);
 948 
 949 G_GNUC_INTERNAL
 950 bool pcmk__instance_matches(const pcmk_resource_t *instance,
 951                             const pcmk_node_t *node, enum rsc_role_e role,
 952                             bool current);
 953 
 954 G_GNUC_INTERNAL
 955 pcmk_resource_t *pcmk__find_compatible_instance(const pcmk_resource_t *match_rsc,
 956                                                 const pcmk_resource_t *rsc,
 957                                                 enum rsc_role_e role,
 958                                                 bool current);
 959 
 960 G_GNUC_INTERNAL
 961 uint32_t pcmk__instance_update_ordered_actions(pcmk_action_t *first,
 962                                                pcmk_action_t *then,
 963                                                const pcmk_node_t *node,
 964                                                uint32_t flags, uint32_t filter,
 965                                                uint32_t type,
 966                                                pcmk_scheduler_t *scheduler);
 967 
 968 G_GNUC_INTERNAL
 969 uint32_t pcmk__collective_action_flags(pcmk_action_t *action,
 970                                        const GList *instances,
 971                                        const pcmk_node_t *node);
 972 
 973 
 974 // Injections (pcmk_injections.c)
 975 
 976 G_GNUC_INTERNAL
 977 xmlNode *pcmk__inject_node(cib_t *cib_conn, const char *node, const char *uuid);
 978 
 979 G_GNUC_INTERNAL
 980 xmlNode *pcmk__inject_node_state_change(cib_t *cib_conn, const char *node,
 981                                         bool up);
 982 
 983 G_GNUC_INTERNAL
 984 xmlNode *pcmk__inject_resource_history(pcmk__output_t *out, xmlNode *cib_node,
 985                                        const char *resource,
 986                                        const char *lrm_name,
 987                                        const char *rclass,
 988                                        const char *rtype,
 989                                        const char *rprovider);
 990 
 991 G_GNUC_INTERNAL
 992 void pcmk__inject_failcount(pcmk__output_t *out, cib_t *cib_conn,
 993                             xmlNode *cib_node, const char *resource,
 994                             const char *task, guint interval_ms, int rc);
 995 
 996 G_GNUC_INTERNAL
 997 xmlNode *pcmk__inject_action_result(xmlNode *cib_resource,
 998                                     lrmd_event_data_t *op, int target_rc);
 999 
1000 
1001 // Nodes (pcmk_sched_nodes.c)
1002 
1003 G_GNUC_INTERNAL
1004 bool pcmk__node_available(const pcmk_node_t *node, bool consider_score,
1005                           bool consider_guest);
1006 
1007 G_GNUC_INTERNAL
1008 bool pcmk__any_node_available(GHashTable *nodes);
1009 
1010 G_GNUC_INTERNAL
1011 GHashTable *pcmk__copy_node_table(GHashTable *nodes);
1012 
1013 G_GNUC_INTERNAL
1014 void pcmk__copy_node_tables(const pcmk_resource_t *rsc, GHashTable **copy);
1015 
1016 G_GNUC_INTERNAL
1017 void pcmk__restore_node_tables(pcmk_resource_t *rsc, GHashTable *backup);
1018 
1019 G_GNUC_INTERNAL
1020 GList *pcmk__sort_nodes(GList *nodes, pcmk_node_t *active_node);
1021 
1022 G_GNUC_INTERNAL
1023 void pcmk__apply_node_health(pcmk_scheduler_t *scheduler);
1024 
1025 G_GNUC_INTERNAL
1026 pcmk_node_t *pcmk__top_allowed_node(const pcmk_resource_t *rsc,
1027                                     const pcmk_node_t *node);
1028 
1029 
1030 // Functions applying to more than one variant (pcmk_sched_resource.c)
1031 
1032 G_GNUC_INTERNAL
1033 void pcmk__set_assignment_methods(pcmk_scheduler_t *scheduler);
1034 
1035 G_GNUC_INTERNAL
1036 bool pcmk__rsc_agent_changed(pcmk_resource_t *rsc, pcmk_node_t *node,
1037                              const xmlNode *rsc_entry, bool active_on_node);
1038 
1039 G_GNUC_INTERNAL
1040 GList *pcmk__rscs_matching_id(const char *id,
1041                               const pcmk_scheduler_t *scheduler);
1042 
1043 G_GNUC_INTERNAL
1044 GList *pcmk__colocated_resources(const pcmk_resource_t *rsc,
1045                                  const pcmk_resource_t *orig_rsc,
1046                                  GList *colocated_rscs);
1047 
1048 G_GNUC_INTERNAL
1049 void pcmk__noop_add_graph_meta(const pcmk_resource_t *rsc, xmlNode *xml);
1050 
1051 G_GNUC_INTERNAL
1052 void pcmk__output_resource_actions(pcmk_resource_t *rsc);
1053 
1054 G_GNUC_INTERNAL
1055 bool pcmk__assign_resource(pcmk_resource_t *rsc, pcmk_node_t *node, bool force,
1056                            bool stop_if_fail);
1057 
1058 G_GNUC_INTERNAL
1059 void pcmk__unassign_resource(pcmk_resource_t *rsc);
1060 
1061 G_GNUC_INTERNAL
1062 bool pcmk__threshold_reached(pcmk_resource_t *rsc, const pcmk_node_t *node,
1063                              pcmk_resource_t **failed);
1064 
1065 G_GNUC_INTERNAL
1066 void pcmk__sort_resources(pcmk_scheduler_t *scheduler);
1067 
1068 G_GNUC_INTERNAL
1069 gint pcmk__cmp_instance(gconstpointer a, gconstpointer b);
1070 
1071 G_GNUC_INTERNAL
1072 gint pcmk__cmp_instance_number(gconstpointer a, gconstpointer b);
1073 
1074 
1075 // Functions related to probes (pcmk_sched_probes.c)
1076 
1077 G_GNUC_INTERNAL
1078 bool pcmk__probe_rsc_on_node(pcmk_resource_t *rsc, pcmk_node_t *node);
1079 
1080 G_GNUC_INTERNAL
1081 void pcmk__order_probes(pcmk_scheduler_t *scheduler);
1082 
1083 G_GNUC_INTERNAL
1084 bool pcmk__probe_resource_list(GList *rscs, pcmk_node_t *node);
1085 
1086 G_GNUC_INTERNAL
1087 void pcmk__schedule_probes(pcmk_scheduler_t *scheduler);
1088 
1089 
1090 // Functions related to live migration (pcmk_sched_migration.c)
1091 
1092 void pcmk__create_migration_actions(pcmk_resource_t *rsc,
1093                                     const pcmk_node_t *current);
1094 
1095 void pcmk__abort_dangling_migration(void *data, void *user_data);
1096 
1097 bool pcmk__rsc_can_migrate(const pcmk_resource_t *rsc,
1098                            const pcmk_node_t *current);
1099 
1100 void pcmk__order_migration_equivalents(pcmk__action_relation_t *order);
1101 
1102 
1103 // Functions related to node utilization (pcmk_sched_utilization.c)
1104 
1105 G_GNUC_INTERNAL
1106 int pcmk__compare_node_capacities(const pcmk_node_t *node1,
1107                                   const pcmk_node_t *node2);
1108 
1109 G_GNUC_INTERNAL
1110 void pcmk__consume_node_capacity(GHashTable *current_utilization,
1111                                  const pcmk_resource_t *rsc);
1112 
1113 G_GNUC_INTERNAL
1114 void pcmk__release_node_capacity(GHashTable *current_utilization,
1115                                  const pcmk_resource_t *rsc);
1116 
1117 G_GNUC_INTERNAL
1118 const pcmk_node_t *pcmk__ban_insufficient_capacity(pcmk_resource_t *rsc);
1119 
1120 G_GNUC_INTERNAL
1121 void pcmk__create_utilization_constraints(pcmk_resource_t *rsc,
1122                                           const GList *allowed_nodes);
1123 
1124 G_GNUC_INTERNAL
1125 void pcmk__show_node_capacities(const char *desc, pcmk_scheduler_t *scheduler);
1126 
1127 
1128 // Functions related to the scheduler (pcmk_scheduler.c)
1129 
1130 G_GNUC_INTERNAL
1131 int pcmk__init_scheduler(pcmk__output_t *out, xmlNodePtr input, const crm_time_t *date,
1132                          pcmk_scheduler_t **scheduler);
1133 
1134 
1135 // General setup functions (pcmk_setup.c)
1136 
1137 G_GNUC_INTERNAL
1138 int pcmk__setup_output_cib_sched(pcmk__output_t **out, cib_t **cib,
1139                                  pcmk_scheduler_t **scheduler, xmlNode **xml);
1140 
1141 #endif // PCMK__LIBPACEMAKER_PRIVATE__H

/* */