diff --git a/agents/ocf/HealthCPU.in b/agents/ocf/HealthCPU.in
index 4bd6e3672a..14e4b0741f 100755
--- a/agents/ocf/HealthCPU.in
+++ b/agents/ocf/HealthCPU.in
@@ -1,224 +1,223 @@
 #!/bin/sh
 #
 # ocf:pacemaker:HealthCPU resource agent
 #
 # Copyright 2004-2023 the Pacemaker project contributors
 #
 # The version control history for this file may have further details.
 #
 # This source code is licensed under the GNU General Public License version 2
 # (GPLv2) WITHOUT ANY WARRANTY.
 #
 
 #
 # Measures CPUs idling and writes #health-cpu status into the CIB
 #
 ################################
 #
 # TODO: Enter default values
 #       Error handling in getting uptime
 #
 ##################################
 
 #######################################################################
 # Initialization:
 
 : ${OCF_FUNCTIONS:="${OCF_ROOT}/resource.d/heartbeat/.ocf-shellfuncs"}
 . "${OCF_FUNCTIONS}"
 : ${__OCF_ACTION:="$1"}
 
 #######################################################################
 
 meta_data() {
     cat <<END
 <?xml version="1.0"?>
 <resource-agent name="HealthCPU" version="@VERSION@">
 <version>1.1</version>
 
 <longdesc lang="en">
 System health agent that measures the CPU idling and updates the #health-cpu attribute.
 </longdesc>
 <shortdesc lang="en">System health CPU usage</shortdesc>
 
 <parameters>
 <parameter name="state" unique-group="state">
 <longdesc lang="en">
 Location to store the resource state in.
 </longdesc>
 <shortdesc lang="en">State file</shortdesc>
 <content type="string" default="${HA_VARRUN%%/}/health-cpu-${OCF_RESOURCE_INSTANCE}.state" />
 </parameter>
 
 <parameter name="yellow_limit" reloadable="1">
 <longdesc lang="en">
 Lower (!) limit of idle percentage to switch the health attribute to yellow. I.e.
 the #health-cpu will go yellow if the %idle of the CPU falls below 50%.
 </longdesc>
 <shortdesc lang="en">Lower limit for yellow health attribute</shortdesc>
 <content type="string" default="50"/>
 </parameter>
 
 <parameter name="red_limit" reloadable="1">
 <longdesc lang="en">
 Lower (!) limit of idle percentage to switch the health attribute to red. I.e.
 the #health-cpu will go red if the %idle of the CPU falls below 10%.
 </longdesc>
 <shortdesc lang="en">Lower limit for red health attribute</shortdesc>
 <content type="string" default="10"/>
 </parameter>
 
 <parameter name="dampening" reloadable="1">
 <longdesc lang="en">
 The time to wait (dampening) in seconds for further changes before writing
 </longdesc>
 <shortdesc lang="en">The time to wait (dampening) in seconds for further changes 
 before writing</shortdesc>
 <content type="string" default="30s"/>
 </parameter>
 
 </parameters>
 
 <actions>
 <action name="start"        timeout="10s" />
 <action name="stop"         timeout="10s" />
 <action name="monitor"      timeout="10s" interval="10s" start-delay="0s" />
 <action name="reload-agent" timeout="20s" />
 <action name="meta-data"    timeout="5s" />
 <action name="validate-all"   timeout="10s" depth="0" />
 </actions>
 </resource-agent>
 END
 }
 
 #######################################################################
 
 healthcpu_usage() {
     cat <<END
 usage: $0 {start|stop|monitor|reload-agent|validate-all|meta-data}
 
 Expects to have a fully populated OCF RA-compliant environment set.
 END
 }
 
 healthcpu_start() {
     healthcpu_monitor
     if [ $? -eq $OCF_SUCCESS ]; then
         return $OCF_SUCCESS
     fi
     touch "${OCF_RESKEY_state}"
 }
 
 healthcpu_stop() {
     healthcpu_monitor
     if [ $? -eq $OCF_SUCCESS ]; then
         rm "${OCF_RESKEY_state}"
     fi
     return $OCF_SUCCESS
 }
 
 healthcpu_monitor() {
     if [ -f "${OCF_RESKEY_state}" ]; then
 
         IDLE=$(top -b -n2 | grep Cpu | tail -1 | awk -F",|.[0-9][ %]id" '{ print $4 }')
         # echo "System idle: " $IDLE
         # echo "$OCF_RESKEY_red_limit"
         # echo $OCF_RESKEY_yellow_limit
 
         if [ $IDLE -lt ${OCF_RESKEY_red_limit} ] ; then
             # echo "System state RED!"
-            attrd_updater -n "#health-cpu" -B "red" -d ${OCF_RESKEY_dampening}
+            attrd_updater -n "#health-cpu" -B "red" -d "${OCF_RESKEY_dampening}"
             return $OCF_SUCCESS
         fi
 
         if [ $IDLE -lt ${OCF_RESKEY_yellow_limit} ] ; then
             # echo "System state yellow."
-            attrd_updater -n "#health-cpu" -B "yellow" -d ${OCF_RESKEY_dampening}
+            attrd_updater -n "#health-cpu" -B "yellow" -d "${OCF_RESKEY_dampening}"
         else
             # echo "System state green."
-            attrd_updater -n "#health-cpu" -B "green" -d ${OCF_RESKEY_dampening}
+            attrd_updater -n "#health-cpu" -B "green" -d "${OCF_RESKEY_dampening}"
         fi
 
         return $OCF_SUCCESS
     fi
 
     return $OCF_NOT_RUNNING
 }
 
 healthcpu_reload_agent() {
-    # No action required
-    :;
+    return $OCF_SUCCESS
 }
 
 healthcpu_validate() {
     # If specified, is yellow_limit a non-negative integer?
     case "$OCF_RESKEY_yellow_limit" in
         0|[1-9]|[1-9][0-9]|100) ;;
         *) return $OCF_ERR_CONFIGURED ;;
     esac
 
     # If specified, is red_limit a non-negative integer?
     case "$OCF_RESKEY_red_limit" in
         0|[1-9]|[1-9][0-9]|100) ;;
         *) return $OCF_ERR_CONFIGURED ;;
     esac
 
     # Host-specific checks
     if [ "$OCF_CHECK_LEVEL" = "10" ]; then
 
         # Is the state directory writable?
         state_dir=$(dirname "$OCF_RESKEY_state")
         [ -d "$state_dir" ] && [ -w "$state_dir" ] && [ -x "$state_dir" ]
         if [ $? -ne 0 ]; then
             ocf_log err "Invalid location for 'state': $state_dir is not writable"
             return $OCF_ERR_ARGS
         fi
     fi
 
     return $OCF_SUCCESS
 }
 
 : ${OCF_RESKEY_CRM_meta_interval:=0}
 : ${OCF_RESKEY_CRM_meta_globally_unique:="false"}
 
 if [ -z "$OCF_RESKEY_state" ]; then
     state="${HA_VARRUN%%/}/HealthCPU-${OCF_RESOURCE_INSTANCE}.state"
     if [ "${OCF_RESKEY_CRM_meta_globally_unique}" = "false" ]; then
         # Strip off the trailing clone marker
         OCF_RESKEY_state=$(echo $state | sed s/:[0-9][0-9]*\.state/.state/)
     else
         OCF_RESKEY_state="$state"
     fi
 fi
 
 if [ -z "${OCF_RESKEY_red_limit}" ] ; then
     OCF_RESKEY_red_limit=10
 fi
 
 if [ -z "${OCF_RESKEY_yellow_limit}" ] ; then
     OCF_RESKEY_yellow_limit=50
 fi
 if [ -z "${OCF_RESKEY_dampening}" ]; then
     OCF_RESKEY_dampening="30s"
 fi
 
 case "$__OCF_ACTION" in
 meta-data)      meta_data
                 exit $OCF_SUCCESS
                 ;;
 start)          healthcpu_start;;
 stop)           healthcpu_stop;;
 monitor)        healthcpu_validate && healthcpu_monitor;;
 reload-agent)   healthcpu_reload_agent;;
 validate-all)   healthcpu_validate;;
 usage|help)     healthcpu_usage
                 exit $OCF_SUCCESS
                 ;;
 *)              healthcpu_usage
                 exit $OCF_ERR_UNIMPLEMENTED
                 ;;
 esac
 rc=$?
 ocf_log debug "${OCF_RESOURCE_INSTANCE} $__OCF_ACTION : $rc"
 exit $rc
 
 # vim: set filetype=sh expandtab tabstop=4 softtabstop=4 shiftwidth=4 textwidth=80:
diff --git a/agents/ocf/HealthSMART.in b/agents/ocf/HealthSMART.in
index b6edac229e..b2f37dee59 100755
--- a/agents/ocf/HealthSMART.in
+++ b/agents/ocf/HealthSMART.in
@@ -1,372 +1,372 @@
 #!@BASH_PATH@
 #
 # ocf:pacemaker:HealthSMART resource agent
 #
 # Copyright 2009-2023 the Pacemaker project contributors
 #
 # The version control history for this file may have further details.
 #
 # This source code is licensed under the GNU General Public License version 2
 # (GPLv2) WITHOUT ANY WARRANTY.
 #
 
 #
 # Checks the S.M.A.R.T. status of all given drives and writes the #health-smart
 # status into the CIB
 #
 #######################################################################
 
 #######################################################################
 # Initialization:
 
 : ${OCF_FUNCTIONS:="${OCF_ROOT}/resource.d/heartbeat/.ocf-shellfuncs"}
 . "${OCF_FUNCTIONS}"
 : ${__OCF_ACTION:="$1"}
 
 # Explicitly list all environment variables used, to make static analysis happy
 : ${OCF_RESKEY_CRM_meta_interval:=0}
 : ${OCF_RESKEY_CRM_meta_globally_unique:="true"}
 : ${OCF_RESKEY_temp_warning:=""}
 : ${OCF_RESKEY_temp_lower_limit:=""}
 : ${OCF_RESKEY_temp_upper_limit:=""}
 : ${OCF_RESKEY_drives:="/dev/sda"}
 : ${OCF_RESKEY_devices:=""}
 : ${OCF_RESKEY_state:=""}
 : ${OCF_RESKEY_smartctl:="/usr/sbin/smartctl"}
 : ${OCF_RESKEY_dampen:="5s"}
 
 # Turn these into arrays so we can iterate them later.
 DRIVES=(${OCF_RESKEY_drives})
 DEVICES=(${OCF_RESKEY_devices})
 
 #######################################################################
 
 meta_data() {
     cat <<END
 <?xml version="1.0"?>
 <resource-agent name="HealthSMART" version="@VERSION@">
 <version>1.1</version>
 
 <longdesc lang="en">
 System health agent that checks the S.M.A.R.T. status of the given drives and
 updates the #health-smart attribute.
 </longdesc>
 <shortdesc lang="en">SMART health status</shortdesc>
 
 <parameters>
 <parameter name="state" unique-group="state">
 <longdesc lang="en">
 Location to store the resource state in.
 </longdesc>
 <shortdesc lang="en">State file</shortdesc>
 <content type="string" default="${HA_VARRUN%%/}/HealthSMART-${OCF_RESOURCE_INSTANCE}.state" />
 </parameter>
 
 <parameter name="drives" reloadable="1">
 <longdesc lang="en">
 The drive(s) to check as a SPACE separated list. Enter the full path to the device, e.g. "/dev/sda".
 </longdesc>
 <shortdesc lang="en">Drives to check</shortdesc>
 <content type="string" default="/dev/sda" />
 </parameter>
 
 <parameter name="devices" reloadable="1">
 <longdesc lang="en">
 The device type(s) to assume for the drive(s) being tested as a SPACE separated list.
 </longdesc>
 <shortdesc lang="en">Device types</shortdesc>
 <content type="string" />
 </parameter>
 
 <parameter name="temp_lower_limit" reloadable="1">
 <longdesc lang="en">
 Lower limit of the temperature in deg C of the drive(s). Below this limit the status will be red.
 </longdesc>
 <shortdesc lang="en">Lower limit for the red smart attribute</shortdesc>
 <content type="string" default="0"/>
 </parameter>
 
 <parameter name="temp_upper_limit" reloadable="1">
 <longdesc lang="en">
 Upper limit of the temperature if deg C of the drives(s). If the drive reports
 a temperature higher than this value the status of #health-smart will be red.
 </longdesc>
 <shortdesc lang="en">Upper limit for red smart attribute</shortdesc>
 <content type="string" default="60"/>
 </parameter>
 
 <parameter name="temp_warning" reloadable="1">
 <longdesc lang="en">
 Number of deg C below/above the upper/lower temp limits at which point the status of #health-smart will change to yellow.
 </longdesc>
 <shortdesc lang="en">Deg C below/above the upper limits for yellow smart attribute</shortdesc>
 <content type="string" default="5"/>
 </parameter>
 
 <parameter name="smartctl" reloadable="1">
 <longdesc lang="en">
 The path to the smartctl program, used for querying device health.
 </longdesc>
 <shortdesc lang="en">The path to the smartctl program</shortdesc>
 <content type="string" default="/usr/sbin/smartctl"/>
 </parameter>
 
 <parameter name="dampen" reloadable="1">
 <longdesc lang="en">
 The time to wait (dampening) for further changes to occur
 </longdesc>
 <shortdesc lang="en">Dampening interval</shortdesc>
 <content type="integer" default="5s"/>
 </parameter>
 
 </parameters>
 
 <actions>
 <action name="start"        timeout="10s" />
 <action name="stop"         timeout="10s" />
 <action name="monitor"      timeout="10s" interval="10s" start-delay="0s" />
 <action name="meta-data"    timeout="5s" />
 <action name="validate-all"   timeout="10s" depth="0" />
 <action name="reload-agent"   timeout="20s" />
 </actions>
 </resource-agent>
 END
 }
 
 #######################################################################
 
 check_temperature() {
 
     if [ $1 -lt ${lower_red_limit} ] ; then
         ocf_log info "Drive ${DRIVE} ${DEVICE} too cold: ${1} C"
-        attrd_updater -n "#health-smart" -U "red" -d "${OCF_RESKEY_dampen}"
+        attrd_updater -n "#health-smart" -B "red" -d "${OCF_RESKEY_dampen}"
         return 1
     fi
 
     if [ $1 -gt ${upper_red_limit} ] ; then
         ocf_log info "Drive ${DRIVE} ${DEVICE} too hot: ${1} C"
-        attrd_updater -n "#health-smart" -U "red" -d "${OCF_RESKEY_dampen}"
+        attrd_updater -n "#health-smart" -B "red" -d "${OCF_RESKEY_dampen}"
         return 1
     fi
 
     if [ $1 -lt ${lower_yellow_limit} ] ; then
         ocf_log info "Drive ${DRIVE} ${DEVICE} quite cold: ${1} C"
-        attrd_updater -n "#health-smart" -U "yellow" -d "${OCF_RESKEY_dampen}"
+        attrd_updater -n "#health-smart" -B "yellow" -d "${OCF_RESKEY_dampen}"
         return 1
     fi
 
     if [ $1 -gt ${upper_yellow_limit} ] ; then
         ocf_log info "Drive ${DRIVE} ${DEVICE} quite hot: ${1} C"
-        attrd_updater -n "#health-smart" -U "yellow" -d "${OCF_RESKEY_dampen}"
+        attrd_updater -n "#health-smart" -B "yellow" -d "${OCF_RESKEY_dampen}"
         return 1
     fi
 }
 
 common_checks() {
     # Each item in $OCF_RESKEY_drives must have a corresponding item in
     # $OCF_RESKEY_devices with the device type.  Alternately,
     # $OCF_RESKEY_devices can be empty.
     drives_len=${#DRIVES[@]}
     devices_len=${#DEVICES[@]}
 
     if [ "${drives_len}" -ne "${devices_len}" ] && [ "${devices_len}" -gt 0 ]; then
         ocf_log err "OCF_RESKEY_devices must be empty or the same length as OCF_RESKEY_drives."
         exit $OCF_ERR_ARGS
     fi
 
     # Each item in $OCF_RESKEY_drives must look like a device node.
     for d in "${DRIVES[@]}"; do
         if [[ "$d" != /dev/* ]]; then
             ocf_log err "Device in OCF_RESKEY_devices does not look like a device node: $d"
             exit $OCF_ERR_ARGS
         fi
     done
 }
 
 
 init_smart() {
     #Set temperature defaults
     if [ -z "${OCF_RESKEY_temp_warning}" ]; then
         yellow_threshold=5
     else
         yellow_threshold=${OCF_RESKEY_temp_warning}
     fi
 
     if [ -z "${OCF_RESKEY_temp_lower_limit}" ] ; then
         lower_red_limit=0
     else
         lower_red_limit=${OCF_RESKEY_temp_lower_limit}
     fi
     lower_yellow_limit=$((${lower_red_limit}+${yellow_threshold}))
 
     if [ -z "${OCF_RESKEY_temp_upper_limit}" ] ; then
         upper_red_limit=60
     else
         upper_red_limit=${OCF_RESKEY_temp_upper_limit}
     fi
     upper_yellow_limit=$((${upper_red_limit}-${yellow_threshold}))
 
     for ndx in ${!DRIVES[*]}; do
         DRIVE=${DRIVES[$ndx]}
 
         if [ -n "${OCF_RESKEY_devices}" ]; then
             DEVICE=${DEVICES[$ndx]}
 
             "${OCF_RESKEY_smartctl}" -d "${DEVICE}" -i "${DRIVE}" | grep -q "SMART support is: Enabled"
             if [ $? -ne 0 ] ; then
                 ocf_log err "S.M.A.R.T. not enabled for drive "${DRIVE}
                 exit $OCF_ERR_INSTALLED
             fi
         else
             "${OCF_RESKEY_smartctl}" -i "${DRIVE}" | grep -q "SMART support is: Enabled"
             if [ $? -ne 0 ] ; then
                 ocf_log err "S.M.A.R.T. not enabled for drive "${DRIVE}
                 exit $OCF_ERR_INSTALLED
             fi
         fi
     done
 }
 
 HealthSMART_usage() {
     cat <<END
 usage: $0 {start|stop|monitor|validate-all|meta-data|reload-agent}
 
 Expects to have a fully populated OCF RA-compliant environment set.
 END
 }
 
 HealthSMART_start() {
     HealthSMART_monitor
     if [ $? -eq $OCF_SUCCESS ]; then
         return $OCF_SUCCESS
     fi
     touch "${OCF_RESKEY_state}"
 }
 
 HealthSMART_stop() {
-    attrd_updater -D -n "#health-smart" -d "${OCF_RESKEY_dampen}"
+    attrd_updater -D -n "#health-smart"
 
     rm "${OCF_RESKEY_state}"
 
     if [ $? -eq 0 ]; then
         return $OCF_SUCCESS
     else
         return $OCF_ERR_GENERIC
     fi
 }
 
 HealthSMART_monitor() {
     common_checks
 
     # Test for presence of smartctl
     check_binary smartctl
 
     init_smart
 
     # Monitor _MUST!_ differentiate correctly between running
     # (SUCCESS), failed (ERROR) or _cleanly_ stopped (NOT RUNNING).
     # That is THREE states, not just yes/no.
 
     if [ -f "${OCF_RESKEY_state}" ]; then
 
         for ndx in ${!DRIVES[*]}; do
             DRIVE=${DRIVES[$ndx]}
 
             if [ -n "${OCF_RESKEY_devices}" ]; then
                 DEVICE=${DEVICES[$ndx]}
 
                 # Check overall S.M.A.R.T. status
                 "${OCF_RESKEY_smartctl}" -d "${DEVICE}" -H ${DRIVE} | grep -q "SMART overall-health self-assessment test result: PASSED"
                 if [ $? -ne 0 ]; then
-                    attrd_updater -n "#health-smart" -U "red" -d "${OCF_RESKEY_dampen}"
+                    attrd_updater -n "#health-smart" -B "red" -d "${OCF_RESKEY_dampen}"
                     return $OCF_SUCCESS
                 fi
 
                 # Check drive temperature(s)
                 check_temperature "$("${OCF_RESKEY_smartctl}" -d "${DEVICE}" -A "${DRIVE}" | awk '/^194/ { print $10 }')"
                 if [ $? -ne 0 ]; then
                     return $OCF_SUCCESS
                 fi
             else
                 "${OCF_RESKEY_smartctl}" -H "${DRIVE}" | grep -q "SMART overall-health self-assessment test result: PASSED"
                 if [ $? -ne 0 ]; then
-                    attrd_updater -n "#health-smart" -U "red" -d "${OCF_RESKEY_dampen}"
+                    attrd_updater -n "#health-smart" -B "red" -d "${OCF_RESKEY_dampen}"
                     return $OCF_SUCCESS
                 fi
 
                 check_temperature "$("${OCF_RESKEY_smartctl}" -A "${DRIVE}" | awk '/^194/ { print $10 }')"
                 if [ $? -ne 0 ]; then
                     return $OCF_SUCCESS
                 fi
             fi
         done
 
-        attrd_updater -n "#health-smart" -U "green" -d "${OCF_RESKEY_dampen}"
+        attrd_updater -n "#health-smart" -B "green" -d "${OCF_RESKEY_dampen}"
         return $OCF_SUCCESS
     fi
 
     return $OCF_NOT_RUNNING
 
 }
 
 HealthSMART_validate() {
     common_checks
 
     # Host-specific checks
     if [ "$OCF_CHECK_LEVEL" = "10" ]; then
         # Test for presence of smartctl
         check_binary smartctl
 
         init_smart
 
         # Is the state directory writable?
         state_dir=$(dirname "$OCF_RESKEY_state")
         touch "$state_dir/$$"
         if [ $? -ne 0 ]; then
             return $OCF_ERR_ARGS
         fi
         rm "$state_dir/$$"
     fi
 
     return $OCF_SUCCESS
 }
 
 HealthSMART_reload_agent() {
     return $OCF_SUCCESS
 }
 
 
 if [ -z "$OCF_RESKEY_state" ]; then
     if [ "${OCF_RESKEY_CRM_meta_globally_unique}" = "false" ]; then
         state="${HA_VARRUN%%/}/HealthSMART-${OCF_RESOURCE_INSTANCE}.state"
 
         # Strip off the trailing clone marker
         OCF_RESKEY_state=$(echo $state | sed s/:[0-9][0-9]*\.state/.state/)
     else
         OCF_RESKEY_state="${HA_VARRUN%%/}/HealthSMART-${OCF_RESOURCE_INSTANCE}.state"
     fi
 fi
 
 case "$__OCF_ACTION" in
     start)        HealthSMART_start;;
     stop)         HealthSMART_stop;;
     monitor)      HealthSMART_monitor;;
     validate-all) HealthSMART_validate;;
     reload-agent) HealthSMART_reload_agent;;
     meta-data)
         meta_data
         exit $OCF_SUCCESS
         ;;
     usage|help)
         HealthSMART_usage
         exit $OCF_SUCCESS
         ;;
     *)  HealthSMART_usage
         exit $OCF_ERR_UNIMPLEMENTED
         ;;
 esac
 rc=$?
 ocf_log debug "${OCF_RESOURCE_INSTANCE} $__OCF_ACTION : $rc"
 exit $rc
 
 # vim: set filetype=sh expandtab tabstop=4 softtabstop=4 shiftwidth=4 textwidth=80:
diff --git a/agents/ocf/ifspeed.in b/agents/ocf/ifspeed.in
index 5fbaf893d1..8c07c3d7ba 100755
--- a/agents/ocf/ifspeed.in
+++ b/agents/ocf/ifspeed.in
@@ -1,553 +1,557 @@
 #!@BASH_PATH@
 #
 # ocf:pacemaker:ifspeed resource agent
 #
 # Copyright 2011-2023 the Pacemaker project contributors
 #
 # The version control history for this file may have further details.
 #
 # This source code is licensed under the GNU General Public License version 2
 # or later (GPLv2+) WITHOUT ANY WARRANTY.
 #
 
 #
 # Record speed of a network interface as a node attribute, based on the sum of
 # speeds of its active (up, link detected, not blocked) underlying interfaces.
 #
 # Originally based on ocf:pacemaker:ping agent
 #
 
 : ${OCF_FUNCTIONS:="${OCF_ROOT}/resource.d/heartbeat/.ocf-shellfuncs"}
 
 # If these aren't available, we can still show help,
 # which is all that is needed to build the man pages.
 [ -r "${OCF_FUNCTIONS}" ] && . "${OCF_FUNCTIONS}"
 [ -r "${OCF_FUNCTIONS_DIR}/findif.sh" ] && . "${OCF_FUNCTIONS_DIR}/findif.sh"
 : ${OCF_SUCCESS:=0}
 
 : ${__OCF_ACTION:=$1}
 
 FINDIF=findif
 
 # Defaults
 OCF_RESKEY_name_default="ifspeed"
 OCF_RESKEY_bridge_ports_default="detect"
 OCF_RESKEY_weight_base_default=1000
 OCF_RESKEY_dampen_default=5
 
 # Explicitly list all environment variables used, to make static analysis happy
 : ${OCF_RESKEY_name:=${OCF_RESKEY_name_default}}
 : ${OCF_RESKEY_bridge_ports:=${OCF_RESKEY_bridge_ports_default}}
 : ${OCF_RESKEY_weight_base:=${OCF_RESKEY_weight_base_default}}
 : ${OCF_RESKEY_dampen:=${OCF_RESKEY_dampen_default}}
 : ${OCF_RESKEY_iface:=""}
 : ${OCF_RESKEY_ip:=""}
 : ${OCF_RESKEY_debug:="false"}
 
 meta_data() {
         cat <<END
 <?xml version="1.0"?>
 <resource-agent name="ifspeed" version="@VERSION@">
 <version>1.1</version>
 
 <longdesc lang="en">
 This agent's monitor action records the speed of a specified network interface
 as a node attribute. The attribute can be used in rules to prefer nodes based
 on network speeds.
 
 This agent can monitor physical interfaces, bonded interfaces, bridges, VLANs,
 or any combination thereof. For example:
 
 *) Bridge on top of one 10Gbps interface (eth2) and 802.3ad bonding (bond0) built
    on two 1Gbps interfaces (eth0 and eth1).
 *) Active-backup bonding built on top of one physical interface and one VLAN on
    another interface.
 
 For STP-enabled bridges, this agent tries to determine the network topology, and
 by default looks only on ports which are connected to an upstream switch. This
 can be overridden by 'bridge_ports' parameter. Active interfaces in this case
 are those in "forwarding" state.
 
 For balancing bonded interfaces, this agent uses 80% of the sum of the speeds of
 underlying "up" ports.
 
 For non-balancing bonded interfaces ("active-backup" and probably "broadcast"),
 only the speed of the currently active port is considered.
 </longdesc>
 <shortdesc lang="en">Network interface speed monitor</shortdesc>
 
 <parameters>
 
 <parameter name="name" unique-group="name">
 <longdesc lang="en">
 Name of the node attribute to set
 </longdesc>
 <shortdesc lang="en">Attribute name</shortdesc>
 <content type="string" default="${OCF_RESKEY_name_default}"/>
 </parameter>
 
 <parameter name="iface" unique-group="iface">
 <longdesc lang="en">
 If this is set, monitor this network interface. One of iface or ip must be set.
 </longdesc>
 <shortdesc lang="en">Network interface</shortdesc>
 <content type="string" default=""/>
 </parameter>
 
 <parameter name="ip" unique-group="ip">
 <longdesc lang="en">
 If this is set instead of iface, monitor the interface that holds this IP
 address. The address may be specified in dotted-quad notation for IPv4 (for
 example, 192.168.1.1) or hexadecimal notation for IPv6 (for example,
 2001:db8:DC28:0:0:FC57:D4C8:1FFF). One of iface or ip must be set.
 </longdesc>
 <shortdesc lang="en">IPv4 or IPv6 address</shortdesc>
 <content type="string" default="" />
 </parameter>
 
 <parameter name="bridge_ports" unique-group="iface">
 <longdesc lang="en">
 If set and iface is a bridge, consider these bridge ports (by default, all ports
 which have designated_bridge=root_id)
 </longdesc>
 <shortdesc lang="en">Bridge ports</shortdesc>
 <content type="string" default="${OCF_RESKEY_bridge_ports_default}"/>
 </parameter>
 
 <parameter name="weight_base">
 <longdesc lang="en">
 Relative weight of 1Gbps in interface speed.
 Can be used to tune how big attribute value will be.
 </longdesc>
 <shortdesc lang="en">Weight of 1Gbps</shortdesc>
 <content type="integer" default="${OCF_RESKEY_weight_base_default}"/>
 </parameter>
 
-<parameter name="dampen">
+<parameter name="dampen" reloadable="1">
 <longdesc lang="en">
 The time to wait (dampening) for further changes to occur.
 </longdesc>
 <shortdesc lang="en">Dampening interval</shortdesc>
 <content type="integer" default="${OCF_RESKEY_dampen_default}"/>
 </parameter>
 
 <parameter name="debug">
 <longdesc lang="en">
 Log more verbosely.
 </longdesc>
 <shortdesc lang="en">Verbose logging</shortdesc>
 <content type="string" default="false"/>
 </parameter>
 
 </parameters>
 
 <actions>
 <action name="start"   timeout="30s" />
 <action name="stop"    timeout="30s" />
 <action name="monitor" depth="0"  timeout="30s" interval="10s"/>
 <action name="meta-data"  timeout="5s" />
 <action name="validate-all"  timeout="30s" depth="0" />
+<action name="reload-agent"  timeout="20s" />
 </actions>
 </resource-agent>
 END
 }
 
 usage() {
     cat <<END
-Usage: $0 {start|stop|monitor|validate-all|meta-data}
+Usage: $0 {start|stop|monitor|validate-all|meta-data|reload-agent}
 
 Expects to have a fully populated OCF RA-compliant environment set.
 END
 }
 
 start() {
     monitor
     if [ $? -eq $OCF_SUCCESS ]; then
         return $OCF_SUCCESS
     fi
     ha_pseudo_resource ${ha_pseudo_resource_name} start
     update
     return $?
 }
 
 stop() {
     ha_pseudo_resource "${ha_pseudo_resource_name}" stop
-    attrd_updater -D -n "${OCF_RESKEY_name}" -d "${OCF_RESKEY_dampen}" ${attrd_options}
+    attrd_updater -D -n "${OCF_RESKEY_name}" ${attrd_options}
     return $OCF_SUCCESS
 }
 
 monitor() {
     local ret
 
     ha_pseudo_resource "${ha_pseudo_resource_name}" monitor
     ret=$?
     if [ ${ret} -eq $OCF_SUCCESS ] ; then
         update
     fi
     return ${ret}
 }
 
 get_nic_name_by_ip() {
     # $FINDIF takes its parameters from the environment.
     # Its output is as follows:
     # [NIC_NAME] netmask [NETMASK] broadcast [BROADCAST}
     NICINFO=$( "${FINDIF}" )
     rc=$?
     if [ $rc -eq 0 ];then
         # Get NIC_NAME part of findif function output.
         echo "${NICINFO%% *}"
     else
         echo ""
     fi
 }
 
 validate() {
     if [ -z "${OCF_RESKEY_iface}" ]; then
         if [ -z "${OCF_RESKEY_ip}" ]; then
             ocf_log err "Must specify either an interface name or valid IP address"
             ocf_exit_reason "no interface or IP address specified"
             exit $OCF_ERR_CONFIGURED
         else
             ipcheck_ipv4 "${OCF_RESKEY_ip}"
             if [ $? -eq 1 ] ; then
                 ipcheck_ipv6 "${OCF_RESKEY_ip}"
                 if [ $? -eq 1 ] ; then
                   ocf_exit_reason "'${OCF_RESKEY_ip}' is not a valid IP"
                   exit $OCF_ERR_CONFIGURED
                 fi
             fi
         fi
     fi
 
     # Host-specific checks
     if [ "$1" = "10" ]; then
         if [ "$(uname)" != "Linux" ] ; then
             ocf_log err "This resource agent works only on Linux"
             ocf_exit_reason "not Linux"
             exit $OCF_ERR_INSTALLED
         fi
     fi
     return $OCF_SUCCESS
 }
 
 iface_get_speed() {
     local iface="$1"
     local operstate
     local carrier
     local speed
 
     if [ ! -e "/sys/class/net/${iface}" ] ; then
         echo "0"
     elif iface_is_bridge "${iface}" ; then # bridges do not have operstate
         read carrier < "/sys/class/net/${iface}/carrier"
 
         if [ "${carrier}" != "1" ] ; then
             echo "0"
         else
             bridge_get_speed "${iface}"
         fi
     else
         read operstate < "/sys/class/net/${iface}/operstate"
         read carrier < "/sys/class/net/${iface}/carrier"
 
         if [ "${operstate}" != "up" ] || [ "${carrier}" != "1" ] ; then
             echo "0"
         elif iface_is_bond "${iface}" ; then
             bond_get_speed "${iface}"
         elif iface_is_vlan "${iface}" ; then
             iface_get_speed "$(vlan_get_phy "${iface}")"
         elif iface_is_hfi1 "${iface}" ; then
             hfi1_get_speed "${iface}"
         else
             read speed < "/sys/class/net/${iface}/speed"
             echo "${speed}"
         fi
     fi
 }
 
 iface_is_vlan() {
     local iface="$1"
 
     [ -e "/proc/net/vlan/${iface}" ] && return 0 || return 1
 }
 
 iface_is_bridge() {
     local iface="$1"
 
     [ -e "/sys/class/net/${iface}/bridge" ] && return 0 || return 1
 }
 
 iface_is_bond() {
     local iface="$1"
 
     [ -e "/sys/class/net/${iface}/bonding" ] && return 0 || return 1
 }
 
 iface_is_hfi1() {
     local iface="$1"
 
     driver=$(readlink "/sys/class/net/${iface}/device/driver")
     [[ $(basename "${driver}") =~ "hfi1" ]] && return 0 || return 1
 }
 
 vlan_get_phy() {
     local iface="$1"
 
     sed -ne "s/^${iface} .*| *//p" < /proc/net/vlan/config
 }
 
 bridge_is_stp_enabled() {
     local iface="$1"
     local stp
 
     read stp < "/sys/class/net/${iface}/bridge/stp_state"
     [ "${stp}" = "1" ] && return 0 || return 1
 }
 
 bridge_get_root_ports() {
     local bridge="$1"
     local root_id
     local root_ports=""
     local bridge_id
 
     read root_id < "/sys/class/net/${bridge}/bridge/root_id"
 
     for port in /sys/class/net/${bridge}/brif/* ; do
         read bridge_id < "${port}/designated_bridge"
         if [ "${bridge_id}" = "${root_id}" ] ; then
             root_ports="${root_ports} ${port##*/}"
         fi
     done
 
     root_ports=${root_ports# }
 
     if [ -n "$2" ] ; then # Record value in specified var. This expects we were called not in a sub-shell.
         eval "$2=\${root_ports}"
     else # Expect sub-shell
         echo ${root_ports}
     fi
 }
 
 # From /usr/include/linux/if_bridge.h:
 #define BR_STATE_DISABLED 0
 #define BR_STATE_LISTENING 1
 #define BR_STATE_LEARNING 2
 #define BR_STATE_FORWARDING 3
 #define BR_STATE_BLOCKING 4
 
 bridge_get_active_ports() {
     local bridge="$1"
     shift 1
     local ports="$*"
     local active_ports=""
     local port_state
     local stp_state
     local warn=0
 
     bridge_is_stp_enabled "${bridge}"
     stp_state=$?
 
     if [ -z "${ports}" ] || [ "${ports}" = "detect" ] ; then
         bridge_get_root_ports "${bridge}" ports
     fi
 
     for port in $ports ; do
         if [ ! -e "/sys/class/net/${bridge}/brif/${port}" ] ; then
             ocf_log warning "Port ${port} doesn't belong to bridge ${bridge}"
             continue
         fi
         read port_state < "/sys/class/net/${bridge}/brif/${port}/state"
         if [ "${port_state}" = "3" ] ; then
             if [ -n "${active_ports}" ] && ${stp_state} ; then
                 warn=1
             fi
             active_ports="${active_ports} ${port}"
         fi
     done
     if [ ${warn} -eq 1 ] ; then
         ocf_log warning "More then one upstream port in bridge '${bridge}' is in forwarding state while STP is enabled: ${active_ports}"
     fi
     echo "${active_ports# }"
 }
 
 bridge_get_speed() {
     local iface="$1"
     local aggregate_speed=0
 
     if ! iface_is_bridge "${iface}" ; then
         echo 0
         return
     fi
 
     BGS_PORTS=$( bridge_get_active_ports "${iface}" "${OCF_RESKEY_bridge_ports}" )
     for port in ${BGS_PORTS} ; do
         : $(( aggregate_speed += $( iface_get_speed "${port}" ) ))
     done
     if [ -n "$2" ] ; then # Record value in specified var. This expects we were called not in a sub-shell.
         eval "$2=\${aggregate_speed}"
     else # Expect sub-shell
         echo ${aggregate_speed}
     fi
 }
 
 hfi1_get_speed() {
     local iface="$1"
     local hfi1_speed
     local hfi1_value
     local hfi1_desc
 
     # At least as of 9/14/2017 Intel Omni Path v10.5.0.0.155, Intel doesn't have
     # dual- or multiple-port Host Channel Adapters, and it's safe to use this
     # method to get the speed. Example output:
     # [root@es-host0 ~]# cat /sys/class/net/ib0/device/infiniband/*/ports/*/rate
     # 100 Gb/sec (4X EDR)
     read hfi1_speed hfi1_value hfi1_desc < "/sys/class/net/${iface}/device/infiniband"/*/ports/*/rate
     ocf_is_true "${OCF_RESKEY_debug}" && ocf_log debug "Detected speed $hfi1_speed $hfi1_value $hfi1_desc"
 
     # hfi1_value always in Gb/sec, so we need to convert hfi1_speed in Mb/sec
     echo $(( hfi1_speed * 1000 ))
 }
 
 bond_get_ports() {
     local iface="$1"
     local ports
 
     read ports < "/sys/class/net/${iface}/bonding/slaves"
     if [ -n "$2" ] ; then # Record value in specified var. This expects we were called not in a sub-shell.
         eval "$2=\${ports}"
     else # Expect sub-shell
         echo ${ports}
     fi
 }
 
 bond_get_active_iface() {
     local iface="$1"
     local active
 
     read active < "/sys/class/net/${iface}/bonding/active_slave"
     if [ -n "$2" ] ; then # Record value in specified var. This expects we were called not in a sub-shell.
         eval "$2=\${active}"
     else # Expect sub-shell
         echo ${active}
     fi
 }
 
 bond_is_balancing() {
     local iface="$1"
     read mode mode_index < "/sys/class/net/${iface}/bonding/mode"
     ocf_is_true "${OCF_RESKEY_debug}" && ocf_log debug "Detected balancing $mode $mode_index"
     case "${mode}" in
         "balance-rr"|"balance-xor"|"802.3ad"|"balance-tlb"|"balance-alb")
             return 0
             ;;
         *)
             return 1
             ;;
     esac
 }
 
 bond_get_speed() {
     local iface="$1"
     local aggregate_speed=0
     local active_iface
     local bond_ports
 
     if ! iface_is_bond "${iface}" ; then
         echo 0
         return
     fi
 
     bond_get_ports "${iface}" bond_ports
 
     if bond_is_balancing "${iface}" ; then
         for port in ${bond_ports} ; do
             : $(( aggregate_speed += $( iface_get_speed "${port}" ) ))
         done
         # Bonding is unable to get speed*n
         : $(( aggregate_speed = aggregate_speed * 8 / 10 ))
     else
         bond_get_active_iface "${iface}" "active_iface"
         aggregate_speed=$( iface_get_speed "$active_iface" )
     fi
     if [ -n "$2" ] ; then # Record value in specified var. This expects we were called not in a sub-shell.
         eval "$2=\${aggregate_speed}"
     else # Expect sub-shell
         echo ${aggregate_speed}
     fi
 }
 
 update() {
     local speed;
     local nic="${OCF_RESKEY_iface}";
 
     if [ -z "${OCF_RESKEY_iface}" ]; then
         nic=$( get_nic_name_by_ip )
         if [ -z "${nic}" ];then
             ocf_log err "Could not determine network interface name from IP address (${OCF_RESKEY_ip})"
             ocf_exit_reason "unable to determine interface name"
             exit $OCF_ERR_GENERIC
         fi
     fi
     speed=$( iface_get_speed "${nic}" )
 
     : $(( score = speed * ${OCF_RESKEY_weight_base} / 1000 ))
-    if [ "$__OCF_ACTION" = "start" ] ; then
-        attrd_updater -n "${OCF_RESKEY_name}" -B "${score}" -d "${OCF_RESKEY_dampen}" ${attrd_options}
-    else
-        attrd_updater -n "${OCF_RESKEY_name}" -v "${score}" -d "${OCF_RESKEY_dampen}" ${attrd_options}
-    fi
+    attrd_updater -n "${OCF_RESKEY_name}" -B "${score}" -d "${OCF_RESKEY_dampen}" ${attrd_options}
     rc=$?
     case ${rc} in
         0)
             ocf_is_true "${OCF_RESKEY_debug}" && ocf_log debug "Updated ${OCF_RESKEY_name} = ${score}"
             ;;
         *)
             ocf_log warn "Could not update ${OCF_RESKEY_name} = ${score}: rc=${rc}"
             ;;
     esac
     return ${rc}
 }
 
+reload_agent() {
+    return $OCF_SUCCESS
+}
+
 case $__OCF_ACTION in
     meta-data)
         meta_data
         exit $OCF_SUCCESS
         ;;
     usage|help)
         usage
         exit $OCF_SUCCESS
         ;;
 esac
 
 : ${ha_pseudo_resource_name:="ifspeed-${OCF_RESOURCE_INSTANCE}"}
 
 attrd_options=''
 if ocf_is_true "${OCF_RESKEY_debug}" ; then
     attrd_options='-VV'
 fi
 
 case "$__OCF_ACTION" in
     start)
         validate 10
         start
         ;;
     stop)
         validate 10
         stop
         ;;
     monitor)
         validate 10
         monitor
         ;;
     validate-all)
         validate "$OCF_CHECK_LEVEL"
         ;;
+    reload-agent)
+        reload_agent
+        ;;
     *)
         usage
         exit $OCF_ERR_UNIMPLEMENTED
         ;;
 esac
 
 exit $?
 
 # vim: set filetype=sh expandtab tabstop=4 softtabstop=4 shiftwidth=4 textwidth=80:
diff --git a/agents/ocf/ping.in b/agents/ocf/ping.in
index 810a765f80..73a3677c0a 100755
--- a/agents/ocf/ping.in
+++ b/agents/ocf/ping.in
@@ -1,436 +1,431 @@
 #!/bin/sh
 #
 # ocf:pacemaker:ping resource agent
 #
 # Copyright 2009-2023 the Pacemaker project contributors
 #
 # The version control history for this file may have further details.
 #
 # This source code is licensed under the GNU General Public License version 2
 # or later (GPLv2+) WITHOUT ANY WARRANTY.
 #
 
 #######################################################################
 # Initialization:
 
 : ${OCF_FUNCTIONS:="${OCF_ROOT}/resource.d/heartbeat/.ocf-shellfuncs"}
 . "${OCF_FUNCTIONS}"
 : ${__OCF_ACTION:="$1"}
 
 # Explicitly list all environment variables used, to make static analysis happy
 : ${OCF_RESKEY_CRM_meta_timeout:="20000"}
 : ${OCF_RESKEY_CRM_meta_globally_unique:="false"}
 : ${OCF_RESKEY_name:="pingd"}
 : ${OCF_RESKEY_dampen:="5s"}
 : ${OCF_RESKEY_attempts:="3"}
 : ${OCF_RESKEY_multiplier:="1"}
 : ${OCF_RESKEY_debug:="0"}
 : ${OCF_RESKEY_failure_score:="0"}
 : ${OCF_RESKEY_use_fping:="1"}
 : ${OCF_RESKEY_host_list:=""}
 : ${OCF_RESKEY_options:=""}
 : ${OCF_RESKEY_timeout:=""}
 
 #######################################################################
 
 meta_data() {
      cat <<END
 <?xml version="1.0"?>
 <resource-agent name="ping" version="@VERSION@">
 <version>1.1</version>
 
 <longdesc lang="en">
 Every time the monitor action is run, this resource agent records (in the CIB) the current number of nodes the host can connect to using the system fping (preferred) or ping tool.
 </longdesc>
 <shortdesc lang="en">node connectivity</shortdesc>
 
 <parameters>
 
 <parameter name="pidfile" unique-group="pidfile">
 <longdesc lang="en">PID file</longdesc>
 <shortdesc lang="en">PID file</shortdesc>
 <content type="string" default="${HA_VARRUN%%/}/ping-${OCF_RESOURCE_INSTANCE}" />
 </parameter>
 
 <parameter name="dampen" reloadable="1">
 <longdesc lang="en">
 The time to wait (dampening) further changes occur
 </longdesc>
 <shortdesc lang="en">Dampening interval</shortdesc>
 <content type="integer" default="5s"/>
 </parameter>
 
 <parameter name="name" unique-group="name">
 <longdesc lang="en">
 The name of the attributes to set.  This is the name to be used in the constraints.
 </longdesc>
 <shortdesc lang="en">Attribute name</shortdesc>
 <content type="string" default="pingd"/>
 </parameter>
 
 <parameter name="multiplier">
 <longdesc lang="en">
 The number by which to multiply the number of connected ping nodes by
 </longdesc>
 <shortdesc lang="en">Value multiplier</shortdesc>
 <content type="integer" default="1"/>
 </parameter>
 
 <parameter name="host_list" required="1">
 <longdesc lang="en">
 A space separated list of ping nodes to count.
 </longdesc>
 <shortdesc lang="en">Host list</shortdesc>
 <content type="string" default=""/>
 </parameter>
 
 <parameter name="attempts" reloadable="1">
 <longdesc lang="en">
 Number of ping attempts, per host, before declaring it dead
 </longdesc>
 <shortdesc lang="en">no. of ping attempts</shortdesc>
 <content type="integer" default="3"/>
 </parameter>
 
 <parameter name="timeout" reloadable="1">
 <longdesc lang="en">
 How long, in seconds, to wait before declaring a ping lost
 </longdesc>
 <shortdesc lang="en">ping timeout in seconds</shortdesc>
 <content type="integer" default="2"/>
 </parameter>
 
 <parameter name="options">
 <longdesc lang="en">
 A catch all for any other options that need to be passed to ping.
 </longdesc>
 <shortdesc lang="en">Extra Options</shortdesc>
 <content type="string" default=""/>
 </parameter>
 
 <parameter name="failure_score">
 <longdesc lang="en">
 Resource is failed if the score is less than failure_score.
 Default never fails.
 </longdesc>
 <shortdesc lang="en">failure_score</shortdesc>
 <content type="integer" default=""/>
 </parameter>
 
 <parameter name="use_fping">
 <longdesc lang="en">
 Use fping rather than ping, if found. If set to 0, fping
 will not be used even if present.
 </longdesc>
 <shortdesc lang="en">Use fping if available</shortdesc>
 <content type="boolean" default="1"/>
 </parameter>
 
 <parameter name="debug" reloadable="1">
 <longdesc lang="en">
 Enables to use default attrd_updater verbose logging on every call.
 </longdesc>
 <shortdesc lang="en">Verbose logging</shortdesc>
 <content type="string" default="false"/>
 </parameter>
 
 </parameters>
 
 <actions>
 <action name="start"   timeout="60s" />
 <action name="stop"    timeout="20s" />
 <action name="monitor" depth="0"  timeout="60s" interval="10s"/>
 <action name="meta-data"  timeout="5s" />
 <action name="validate-all"  timeout="30s" />
 <action name="reload-agent"  timeout="20s" />
 </actions>
 </resource-agent>
 END
 }
 
 #######################################################################
 
 ping_conditional_log() {
     level="$1"; shift
     if [ $OCF_RESKEY_debug -gt 0 ]; then
         ocf_log "$level" "$*"
     fi
 }
 
 ping_usage() {
     cat <<END
 usage: $0 {start|stop|monitor|validate-all|reload-agent|meta-data}
 
 Expects to have a fully populated OCF RA-compliant environment set.
 END
 }
 
 ping_start() {
     ping_monitor
     if [ $? -eq $OCF_SUCCESS ]; then
         return $OCF_SUCCESS
     fi
     touch "${OCF_RESKEY_pidfile}"
     ping_update
 }
 
 ping_stop() {
 
     rm -f "${OCF_RESKEY_pidfile}"
 
-    attrd_updater -D -n "$OCF_RESKEY_name" -d "$OCF_RESKEY_dampen"
+    attrd_updater -D -n "$OCF_RESKEY_name"
 
     return $OCF_SUCCESS
 }
 
 ping_monitor() {
     if [ -f "${OCF_RESKEY_pidfile}" ]; then
         ping_update
         if [ $? -eq 0 ]; then
             return $OCF_SUCCESS
         fi
         return $OCF_ERR_GENERIC
     fi
     return $OCF_NOT_RUNNING
 }
 
 ping_validate() {
     # Host-specific checks
     if [ "$OCF_CHECK_LEVEL" = "10" ]; then
         
         # Is the state directory writable?
         state_dir=$(dirname "$OCF_RESKEY_pidfile")
         touch "$state_dir/$$"
         if [ $? -ne 0 ]; then
             ocf_log err "Invalid location for 'state': $state_dir is not writable"
             return $OCF_ERR_ARGS
         fi
         rm "$state_dir/$$"
 
         # Does the ping binary exist?
         check_binary ping
 
     fi
 
 # Pidfile better be an absolute path
     case "$OCF_RESKEY_pidfile" in
         /*) ;;
         *) ocf_log warn "You should use an absolute path for pidfile not: $OCF_RESKEY_pidfile" ;;
     esac
 
 # Check the host list
     if [ -z "$OCF_RESKEY_host_list" ]; then
         ocf_log err "Empty host_list.  Please specify some nodes to ping"
         exit $OCF_ERR_CONFIGURED
     fi
 
     # For fping allow only same IP versions or hostnames
     if use_fping; then
         hosts_family
         if [ $? -eq 99 ]; then
             ocf_log err "host_list can contain only host with same IP versions for fping"
             exit $OCF_ERR_CONFIGURED
         fi
     fi
 
     return $OCF_SUCCESS
 }
 
 ping_reload_agent() {
-    # No action required
-    :;
+    return $OCF_SUCCESS
 }
 
 fping_check() {
     p_exe=fping
     hosts_family
     case $? in
         6) p_exe=fping6 ;;
         99) ocf_log err "Ambiguous IP versions in host_list: '$OCF_RESKEY_host_list'"; exit $OCF_ERR_CONFIGURED;;
     esac
 
     active=0
 
     timeout=$(expr $OCF_RESKEY_timeout \* 1000 / $OCF_RESKEY_attempts)
 
     cmd="$p_exe -r $OCF_RESKEY_attempts -t $timeout -B 1.0 $OCF_RESKEY_options $OCF_RESKEY_host_list"
     fping_output=$($cmd 2>&1); rc=$?
     active=$(echo "$fping_output" | grep "is alive" | wc -l)
 
     case $rc in
         0)
             if [ $OCF_RESKEY_debug -gt 1 ]; then
                 ping_conditional_log info "$fping_output"
             fi
             ;;
         1)
             for h in $(echo "$fping_output" | grep "is unreachable" | awk '{print $1}'); do
                 ping_conditional_log warn "$h is inactive: $fping_output"
             done
             ;;
         *)
             ocf_log err "Unexpected result for '$cmd' $rc: $(echo "$fping_output" | tr '\n' ';')"
             ;;
     esac
 
     return $active
 }
 
 ping_check() {
     active=0
     for host in $OCF_RESKEY_host_list; do
         p_exe=ping
 
         case $(uname) in
             Linux) p_args="-n -q -W $OCF_RESKEY_timeout -c $OCF_RESKEY_attempts";;
             Darwin) p_args="-n -q -t $OCF_RESKEY_timeout -c $OCF_RESKEY_attempts -o";;
             FreeBSD) p_args="-n -q -t $OCF_RESKEY_timeout -c $OCF_RESKEY_attempts -o";;
             *) ocf_log err "Unknown host type: $(uname)"; exit $OCF_ERR_INSTALLED;;
         esac
 
         case "$host" in
             *:*) p_exe=ping6
         esac
 
         ping_output=$($p_exe $p_args $OCF_RESKEY_options $host 2>&1); rc=$?
 
         case $rc in
             0)
                 active=$(expr $active + 1)
                 if [ $OCF_RESKEY_debug -gt 1 ]; then
                     ping_conditional_log info "$ping_output"
                 fi
                 ;;
             1) ping_conditional_log warn "$host is inactive: $ping_output";;
             *) ocf_log err "Unexpected result for '$p_exe $p_args $OCF_RESKEY_options $host' $rc: $ping_output";;
         esac
     done
     return $active
 }
 
 ping_update() {
 
     if use_fping; then
         fping_check
         active=$?
     else
         ping_check
         active=$?
     fi
 
     score=$(expr $active \* $OCF_RESKEY_multiplier)
-    if [ "$__OCF_ACTION" = "start" ] ; then
-        attrd_updater -n "$OCF_RESKEY_name" -B "$score" -d "$OCF_RESKEY_dampen"
-    else
-        attrd_updater -n "$OCF_RESKEY_name" -U "$score" -d "$OCF_RESKEY_dampen"
-    fi
+    attrd_updater -n "$OCF_RESKEY_name" -B "$score" -d "$OCF_RESKEY_dampen"
     rc=$?
     case $rc in
         0) ping_conditional_log debug "Updated $OCF_RESKEY_name = $score" ;;
         *) ocf_log warn "Could not update $OCF_RESKEY_name = $score: rc=$rc";;
     esac
     if [ $rc -ne 0 ]; then
         return $rc
     fi
 
     if [ -n "$OCF_RESKEY_failure_score" ] && [ "$score" -lt "$OCF_RESKEY_failure_score" ]; then
         ocf_log warn "$OCF_RESKEY_name is less than failure_score($OCF_RESKEY_failure_score)"
         return 1
     fi
     return 0
 }
 
 use_fping() {
     ocf_is_true "$OCF_RESKEY_use_fping" && have_binary fping;
 }
 
 # return values:
 #     4 IPv4
 #     6 IPv6
 #     0 indefinite (i.e. hostname)
 host_family() {
     case $1 in
         *[0-9].*[0-9].*[0-9].*[0-9]) return 4 ;;
         *:*) return 6 ;;
         *) return 0 ;;
     esac
 }
 
 # return values same as host_family plus
 #     99 ambiguous families
 hosts_family() {
     # For fping allow only same IP versions or hostnames
     family=0
     for host in $OCF_RESKEY_host_list; do
         host_family "$host"
         f=$?
         if [ $family -ne 0 ] && [ $f -ne 0 ] && [ $f -ne $family ] ; then
             family=99
             break
         fi
         [ $f -ne 0 ] && family=$f
     done
     return $family
 }
 
 integer=$(echo ${OCF_RESKEY_timeout} | egrep -o '[0-9]*')
 case "${OCF_RESKEY_timeout}" in
     *[0-9]ms|*[0-9]msec) OCF_RESKEY_timeout=$(expr $integer / 1000);;
     *[0-9]m|*[0-9]min) OCF_RESKEY_timeout=$(expr $integer \* 60);;
     *[0-9]h|*[0-9]hr)  OCF_RESKEY_timeout=$(expr $integer \* 60 \* 60);;
     *) OCF_RESKEY_timeout=$integer;;
 esac
 
 if [ -z "${OCF_RESKEY_timeout}" ]; then
     if [ -n "$OCF_RESKEY_host_list" ]; then
         host_count=$(echo $OCF_RESKEY_host_list | awk '{print NF}')
         OCF_RESKEY_timeout=$(expr $OCF_RESKEY_CRM_meta_timeout / $host_count / $OCF_RESKEY_attempts)
         OCF_RESKEY_timeout=$(expr $OCF_RESKEY_timeout / 1100) # Convert to seconds and finish 10% early
     else
         OCF_RESKEY_timeout=5
     fi
 fi
 
 if [ ${OCF_RESKEY_timeout} -lt 1 ]; then
     OCF_RESKEY_timeout=5
 elif [ ${OCF_RESKEY_timeout} -gt 1000 ]; then
     # ping actually complains if this value is too high, 5 minutes is plenty
     OCF_RESKEY_timeout=300
 fi
 
 if [ "${OCF_RESKEY_CRM_meta_globally_unique}" = "false" ]; then
     : ${OCF_RESKEY_pidfile:="${HA_VARRUN%%/}/ping-${OCF_RESKEY_name}"}
 else
     : ${OCF_RESKEY_pidfile:="${HA_VARRUN%%/}/ping-${OCF_RESOURCE_INSTANCE}"}
 fi
 
 # Check the debug option
 case "${OCF_RESKEY_debug}" in
     true|True|TRUE|1)    OCF_RESKEY_debug=1;;
     false|False|FALSE|0) OCF_RESKEY_debug=0;;
     verbose|Verbose|VERBOSE|2) OCF_RESKEY_debug=2;;
     *)
         ocf_log warn "Value for 'debug' is incorrect. Please specify 'true', 'false', or 'verbose', not: ${OCF_RESKEY_debug}"
         OCF_RESKEY_debug=false
         ;;
 esac
 
 case "$__OCF_ACTION" in
 meta-data)      meta_data
                 exit $OCF_SUCCESS
                 ;;
 start)          ping_start;;
 stop)           ping_stop;;
 monitor)        ping_monitor;;
 validate-all)   ping_validate;;
-reload-agent)         ping_reload_agent;;
+reload-agent)   ping_reload_agent;;
 usage|help)     ping_usage
                 exit $OCF_SUCCESS
                 ;;
 *)              ping_usage
                 exit $OCF_ERR_UNIMPLEMENTED
                 ;;
 esac
 exit $?
 
 # vim: set filetype=sh expandtab tabstop=4 softtabstop=4 shiftwidth=4 textwidth=80: