pre_execute.c

Go to the documentation of this file.

 
#include "ab_gp_channel_cycle_hooks.h"
 
#include <stdio.h>
#include <string.h>
 
#include "rte/oal/log/rte_log.h"
#include "rte/oal/memory/rte_mem_util.h"
#include "rte/utils/safestate/rte_safestate.h"
#include "rte/oal/timer/rte_timer.h"
#include "rte/redundancy/watchdog/rte_watchdog.h"
 
#include "../../common/common_config.h"
#include "../../common/site_config.h"
#include "../com/ab_gp_channel.h"
#include "../com/ab_gp_channel_crosscompare.h"
#include "../com/ab_gp_channel_stage.h"
#include "../com/ab_gp_channel_dual.h"
#include "../com/ab_gp_channel_negotiate.h"
#include "../com/ab_gp_channel_payload.h"
#include "../com/ab_gp_channel_types.h"
#include "../com/ab_gp_km114_client.h"
#include "../com/ab_gp_saf_train.h"
#include "../com/ab_gp_sibling_state.h"
#include "../train/ab_gp_train.h"
#include "../ertms_procedures/ab_gp_proc_dispatch.h"
#include "ab_gp_ga_hooks.h" /* ab_gp_dispatch_il_envelope() - see that file's own doc */
 
typedef struct
{
    ab_gp_channel_context_t *ctx;
    bool have_channel_data;
} relay_poll_context_t;
 
typedef struct
{
    ab_gp_channel_context_t *ctx;
    uint8_t peer_bytes[AB_SAMPLE_WIRE_SIZE];
    bool have_peer_data;
} peer_poll_context_t;

static uint32_t saf_now_ms(const ab_gp_channel_context_t *ctx)
{
    return ctx->cyc_cycle * ctx->config.timers.cycle_period_ms;
}

static void saf_stage_to_train(ab_gp_channel_context_t *ctx, uint8_t train_id, const uint8_t *frame, size_t len)
{
    uint8_t env[RBC_TRAIN_ENVELOPE_WIRE_SIZE];
 
    if (!ab_gp_saf_envelope_encode(train_id, frame, len, env) ||
        (ab_gp_channel_stage_relay((ab_gp_channel_handle_t)ctx, RTE_EXAMPLE_RELAY_KIND_TRAIN, 0U, env, sizeof(env)) !=
         RTE_STATUS_OK))
    {
        rte_log_write_event(RTE_LOG_LEVEL_ERROR, site_config_name(ctx->site), ctx->cyc_cycle, ctx->role_tag, "Train",
                              "SAF", "could not stage a SaF frame for the train", NULL);
    }
}

static void saf_apply_result(ab_gp_channel_context_t *ctx, relay_poll_context_t *poll_ctx, uint8_t train_id,
                             const ab_gp_saf_result_t *res)
{
    char info[48];
 
    switch (res->action)
    {
        case AB_GP_SAF_ACTION_REPLY:
            saf_stage_to_train(ctx, train_id, res->frame, res->frame_len);
            if (res->share_rb)
            {
                uint8_t peer_frame[PEER_WIRE_FRAME_SIZE] = { 0 };
 
                peer_frame[0] = PEER_MSG_KIND_SAF_RB;
                rte_mem_copy(&peer_frame[1], res->rb_share, sizeof(res->rb_share));
                (void)ab_gp_channel_send_peer((ab_gp_channel_handle_t)ctx, peer_frame, sizeof(peer_frame));
            }
            break;
        case AB_GP_SAF_ACTION_APP:
            if ((poll_ctx != NULL) &&
                ab_gp_proc_dispatch_train_inbound((ab_gp_channel_handle_t)ctx, ctx->sessions, &ctx->db, train_id,
                                                  res->app, res->app_len, ctx->cyc_cycle, saf_now_ms(ctx)))
            {
                poll_ctx->have_channel_data = true;
            }
            break;
        case AB_GP_SAF_ACTION_REJECTED:
            (void)snprintf(info, sizeof(info), "train=%u status=%d", (unsigned int)train_id, (int)res->status);
            rte_log_write_event(RTE_LOG_LEVEL_WARNING, site_config_name(ctx->site), ctx->cyc_cycle, "Train",
                                  ctx->role_tag, "SAF", "frame rejected", info);
            break;
        case AB_GP_SAF_ACTION_DISCONNECTED:
            (void)snprintf(info, sizeof(info), "train=%u", (unsigned int)train_id);
            rte_log_write_event(RTE_LOG_LEVEL_INFO, site_config_name(ctx->site), ctx->cyc_cycle, "Train",
                                  ctx->role_tag, "SAF", "train released the safe connection", info);
            break;
        default:
            break;
    }
}
 
static void on_saf_envelope(relay_poll_context_t *poll_ctx, const uint8_t *bytes)
{
    ab_gp_channel_context_t *ctx = poll_ctx->ctx;
    uint8_t train_id = 0U;
    const uint8_t *frame = NULL;
    size_t len = 0U;
    ab_gp_saf_result_t res;
 
    if (!ctx->saf_train.enabled || !ab_gp_saf_envelope_decode(bytes, &train_id, &frame, &len))
    {
        rte_log_write_event(RTE_LOG_LEVEL_WARNING, site_config_name(ctx->site), ctx->cyc_cycle, "Train",
                              ctx->role_tag, "SAF", "SaF envelope dropped (protection off or malformed)", NULL);
        return;
    }
    ab_gp_saf_train_on_frame(&ctx->saf_train, train_id, frame, len, saf_now_ms(ctx), &res);
    saf_apply_result(ctx, poll_ctx, train_id, &res);
}
 
static void on_relay_envelope_received(void *user_ctx, rte_example_relay_kind_t kind, uint8_t index,
                                      const uint8_t *bytes)
{
    relay_poll_context_t *poll_ctx = (relay_poll_context_t *)user_ctx;
    ab_gp_channel_context_t *ctx = poll_ctx->ctx;
 
    (void)index; /* ADR-036: one link per kind - routing is by env->train_id */
 
    if (!ctx->is_online)
    {
        return;
    }
 
    if (kind == RTE_EXAMPLE_RELAY_KIND_TRAIN)
    {
        /* ADR-036: C keepalives the multiplexed Train relay every idle
         * cycle (gateway_c_train_handler.c) - recognise and drop it here,
         * before ab_gp_train_apply_envelope() would reject it as a
         * malformed train envelope. Same guard the IL branch below has. */
        if (rbc_envelope_is_keepalive(bytes))
        {
            /* dropped */
        }
        else if (bytes[0] == (uint8_t)RBC_MSG_SAF_ENVELOPE)
        {
            on_saf_envelope(poll_ctx, bytes);
        }
        else if ((bytes[0] == (uint8_t)RBC_MSG_ERTMS_ENVELOPE) && ctx->saf_train.enabled)
        {
            /* REQ-SC-004: with the train link protected, an unprotected ERTMS frame never reaches the procedures. */
            rte_log_write_event(RTE_LOG_LEVEL_WARNING, site_config_name(ctx->site), ctx->cyc_cycle, "Train",
                                  ctx->role_tag, "SAF", "unprotected ERTMS frame dropped", NULL);
        }
        else if (bytes[0] == (uint8_t)RBC_MSG_ERTMS_ENVELOPE)
        {
            /* Real Subset-026 traffic on top of an already P0-connected
             * session slot - see rbc_wire_types.h's own doc for this
             * kind's 2-byte kind+train_id prefix, which ab_gp_train.c's
             * own flat-scheme switch never sees. */
            if (ab_gp_proc_dispatch_train_inbound((ab_gp_channel_handle_t)ctx, ctx->sessions, &ctx->db, bytes[1],
                                                  &bytes[2], RBC_TRAIN_ENVELOPE_WIRE_SIZE - 2U, ctx->cyc_cycle,
                                                  ctx->cyc_cycle * ctx->config.timers.cycle_period_ms))
            {
                poll_ctx->have_channel_data = true;
            }
            else
            {
                RTE_EXAMPLE_LOG("[%s] cycle %u: rejected malformed/unknown RBC_MSG_ERTMS_ENVELOPE frame (train %u)\n",
                                     ctx->role_tag, ctx->cyc_cycle, (unsigned int)bytes[1]);
                rte_log_write_event(RTE_LOG_LEVEL_WARNING, site_config_name(ctx->site), ctx->cyc_cycle, "Train",
                                      ctx->role_tag, "ERTMS_ENVELOPE", "rejected malformed/unknown frame", NULL);
            }
        }
        else if (ab_gp_train_apply_envelope(ctx->sessions, &ctx->db, bytes, ctx->cyc_cycle, ctx->is_role_a,
                                          ctx->site, ctx->role_tag, ctx->cyc_msg_type_due,
                                          ctx->cyc_position_reply_due))
        {
            poll_ctx->have_channel_data = true;
        }
    }
    else if (kind == RTE_EXAMPLE_RELAY_KIND_IL)
    {
        uint8_t req_level = 0U;
 
        if (rbc_envelope_is_set_log_level(bytes, &req_level))
        {
            /* Diagnostic control frame fanned out by C's gateway_c_logctl.c
             * (rte_log is non-safety, ADR-001 4) - apply it and stop, do
             * NOT run the IL domain decode on it. rte_log_set_level()
             * itself ignores an out-of-range value. */
            rte_log_set_level((rte_log_level_t)req_level);
            /* Logged AT the just-set level so the confirmation is never
             * self-suppressed (a raise to WARNING would otherwise hide
             * its own "now at WARNING" line). */
            rte_log_write_event((rte_log_level_t)req_level, site_config_name(ctx->site), ctx->cyc_cycle,
                                  ctx->role_tag, "C", "LOG_LEVEL", "applied from C",
                                  rte_log_level_to_string((rte_log_level_t)req_level));
        }
        else if (!rbc_envelope_is_keepalive(bytes))
        {
            if (ab_gp_dispatch_il_envelope(ctx->sessions, &ctx->db, bytes, ctx->cyc_cycle, ctx->site, ctx->role_tag))
            {
                poll_ctx->have_channel_data = true;
            }
        }
        else
        {
            /* IL keepalive drained without action */
        }
    }
    else
    {
        /* CTC keepalives drained without action */
    }
}
 
static void on_crosscompare_frame_received(void *user_ctx, uint8_t kind, const uint8_t *payload, size_t size)
{
    peer_poll_context_t *poll_ctx = (peer_poll_context_t *)user_ctx;
    ab_gp_channel_context_t *ctx = poll_ctx->ctx;
 
    if (kind == PEER_MSG_KIND_AB_SAMPLE)
    {
        if (size >= AB_SAMPLE_WIRE_SIZE)
        {
            rte_mem_copy(poll_ctx->peer_bytes, payload, AB_SAMPLE_WIRE_SIZE);
            poll_ctx->have_peer_data = true;
            ctx->last_peer_sample_cycle = ctx->cyc_cycle;
        }
    }
}
 
static void on_peer_frame_received(void *user_ctx, uint8_t kind, const uint8_t *payload, size_t size)
{
    peer_poll_context_t *poll_ctx = (peer_poll_context_t *)user_ctx;
    ab_gp_channel_context_t *ctx = poll_ctx->ctx;
 
    if (kind == PEER_MSG_KIND_SITE_STATE)
    {
        /* No cycle stamp here: rte_site_role stamps the cycle of the execute that takes the frame (REQ-SITEROLE-016). */
        (void)ab_gp_sibling_state_store(&ctx->peer_site_state, payload, size);
    }
    else if (kind == PEER_MSG_KIND_CHECKPOINT_REQUEST)
    {
        uint8_t reply_frame[PEER_WIRE_FRAME_SIZE] = { 0 };
        reply_frame[0] = PEER_MSG_KIND_CHECKPOINT_REPLY;
        /* Peer ran its own checkpoint stage this recently - feeds the
         * lookback check in ab_gp_channel_checkpoint_backend_recv(). */
        ctx->last_peer_checkpoint_cycle = ctx->cyc_cycle;
        if (size >= sizeof(rte_vital_message_t))
        {
            rte_mem_copy(&reply_frame[1], payload, sizeof(rte_vital_message_t));
            /* Retain the peer's own arrival too (see ab_gp_channel_types.h):
             * on an active cycle it carries this cycle's id and can
             * confirm this side's rendezvous when the retained reply
             * (older id) cannot. */
            rte_mem_copy(ctx->cached_checkpoint_request, payload, sizeof(rte_vital_message_t));
            ctx->has_cached_checkpoint_request = true;
        }
        (void)ab_gp_channel_send_peer((ab_gp_channel_handle_t)ctx, reply_frame, sizeof(reply_frame));
    }
    else if (kind == PEER_MSG_KIND_CHECKPOINT_REPLY)
    {
        /* Reply to a CHECKPOINT_REQUEST this side sent from a prior
         * cycle's post_execute(), arriving after that rendezvous
         * attempt's short receive window already closed. Retain it (it
         * was previously dropped here) so this cycle's rendezvous
         * consumes it instead of timing out - see ab_gp_channel_types.h. */
        ctx->last_peer_checkpoint_cycle = ctx->cyc_cycle;
        if (size >= sizeof(rte_vital_message_t))
        {
            rte_mem_copy(ctx->cached_checkpoint_reply, payload, sizeof(rte_vital_message_t));
            ctx->has_cached_checkpoint_reply = true;
        }
    }
    else if (kind == PEER_MSG_KIND_SAF_RB)
    {
        /* B: the responder random A drew for a train's AU1 - see ab_gp_saf_train.h. */
        ab_gp_saf_result_t res;
 
        ab_gp_saf_train_on_peer_rb(&ctx->saf_train, payload, size, saf_now_ms(ctx), &res);
        if (size >= (size_t)AB_GP_SAF_PEER_RB_SIZE)
        {
            saf_apply_result(ctx, NULL, payload[0], &res);
        }
    }
    else if (kind == PEER_MSG_KIND_KM114_DIGEST)
    {
        /* Platform_Protocol_KM114 step 3: cross-check this side's own decoded KMAC against the
         * A/B sibling's - see ab_gp_km114_client.c's own doc. */
        (void)ab_gp_km114_client_on_peer_digest(payload, size, ctx->role_tag, ctx->site);
    }
    else if (kind == PEER_MSG_KIND_STARTUP_TS)
    {
        /* The sibling restarted and asks for the site's startup timestamp (ADR-040 step 5a); a reply is cached only. */
        ab_gp_channel_negotiate_on_startup_ts_frame(ctx, payload, size);
    }
    else
    {
        /* Unrecognized peer message kind ignored */
    }
}

static void log_role_transition(ab_gp_channel_context_t *ctx, uint32_t cycle)
{
    if (ctx->is_online && !ctx->was_online)
    {
        RTE_EXAMPLE_LOG("[%s] promoted to ONLINE\n", ctx->role_tag);
        rte_log_write_event(RTE_LOG_LEVEL_INFO, site_config_name(ctx->site), cycle, ctx->role_tag, "-", "ROLE",
                              "promoted to ONLINE", NULL);
    }
    else if (!ctx->is_online && ctx->was_online)
    {
        RTE_EXAMPLE_LOG("[%s] demoted to STANDBY\n", ctx->role_tag);
        rte_log_write_event(RTE_LOG_LEVEL_INFO, site_config_name(ctx->site), cycle, ctx->role_tag, "-", "ROLE",
                              "demoted to STANDBY", NULL);
    }
    ctx->was_online = ctx->is_online;
}

static void decode_and_apply_peer_sample(ab_gp_channel_context_t *ctx, peer_poll_context_t *peer_poll)
{
    rte_status_t status;
    uint8_t i;
    uint32_t peer_cycle = 0U;
    ab_gp_train_session_t peer_sessions[RTE_EXAMPLE_MAX_TRAINS];
 
    ctx->cyc_crc_ok = false;
    if (peer_poll->have_peer_data)
    {
        void *dests[AB_GP_CHANNEL_PAYLOAD_MAX_COLLECTORS] = { NULL };
 
        dests[ab_gp_train_payload_collector_id()] = peer_sessions;
        status = ab_gp_channel_payload_decode_ab_sample(peer_poll->peer_bytes, &peer_cycle, dests);
        if (status == RTE_STATUS_DATA_CORRUPTION)
        {
            RTE_EXAMPLE_LOG("[%s] cycle %u: CRC-64 mismatch on peer link - data cannot be trusted, entering SAFE state\n",
                   ctx->role_tag, ctx->cyc_cycle);
            rte_log_write_event(RTE_LOG_LEVEL_ERROR, site_config_name(ctx->site), ctx->cyc_cycle, ctx->is_role_a ? "B" : "A", ctx->role_tag,
                                  "AB_SAMPLE", "CRC-64 mismatch - entering SAFE state", NULL);
            RTE_SAFESTATE(RTE_SAFESTATE_LEVEL_SAFE, RTE_EXAMPLE_REASON_AB_CRC_MISMATCH);
        }
        else if (status != RTE_STATUS_OK)
        {
            RTE_EXAMPLE_LOG("[%s] cycle %u: malformed peer message (%s)\n", ctx->role_tag, ctx->cyc_cycle,
                   rte_status_to_string(status));
            rte_log_write_event(RTE_LOG_LEVEL_ERROR, site_config_name(ctx->site), ctx->cyc_cycle, ctx->is_role_a ? "B" : "A", ctx->role_tag,
                                  "AB_SAMPLE", rte_status_to_string(status), NULL);
        }
        else
        {
            ctx->cyc_crc_ok = true;
            for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
            {
                ctx->cyc_peer_sessions[i] = peer_sessions[i];
            }
            RTE_EXAMPLE_LOG("[%s] cycle %u: dual transfer received sample from peer (peer_cycle=%u, CRC=OK)\n",
                                ctx->role_tag, ctx->cyc_cycle, (unsigned int)peer_cycle);
            rte_log_write_event(RTE_LOG_LEVEL_DEBUG, site_config_name(ctx->site), ctx->cyc_cycle,
                                  ctx->is_role_a ? "B" : "A", ctx->role_tag, "DUAL_TRANSFER",
                                  "received sample from peer (CRC=OK)", NULL);
        }
    }
 
    ctx->cyc_have_peer_data = peer_poll->have_peer_data;
    ctx->cyc_peer_cycle = peer_cycle;
    ctx->cyc_agree = false;
}

static void check_dual_transfer_timeout(ab_gp_channel_context_t *ctx, uint32_t cycle)
{
    if (ctx->is_online && !ctx->single_mode && (ctx->last_peer_sample_cycle > 0U))
    {
        uint32_t timeout_cycles = (ctx->config.timers.dual_transfer_timeout_ms + (ctx->config.timers.cycle_period_ms - 1U)) /
                                  ctx->config.timers.cycle_period_ms;
        if (timeout_cycles == 0U)
        {
            timeout_cycles = 1U;
        }
        if ((cycle > ctx->last_peer_sample_cycle) && ((cycle - ctx->last_peer_sample_cycle) >= timeout_cycles))
        {
            ab_gp_channel_dual_on_transfer_lost(ctx);
        }
    }
}
 
rte_status_t ab_gp_channel_pre_execute(void *context)
{
    ab_gp_channel_context_t *ctx = (ab_gp_channel_context_t *)context;
    rte_status_t status;
    uint8_t own_role_byte;
    uint32_t cycle;
    uint32_t drained_count;
    uint8_t i;
    relay_poll_context_t relay_poll;
    peer_poll_context_t peer_poll;
 
    if (ctx == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    /* ADR-034: clear last cycle's staged-output queue before this cycle
     * (post_execute()) can stage anything new into it - see
     * ab_gp_channel_stage.h. Any prior cycle's queue is always already
     * empty by now (on_checkpoint_result() flushes or discards it every
     * cycle), so this is defensive, not load-bearing - but cheap and
     * unconditional, matching this function's own role as the per-cycle
     * reset point ahead of this cycle's own work. */
    ab_gp_channel_stage_reset((ab_gp_channel_handle_t)ctx);
 
    status = ab_gp_channel_wait_cycle_tick((ab_gp_channel_handle_t)ctx);
    if (status != RTE_STATUS_OK)
    {
        return status;
    }
 
    cycle = ctx->cyc_cycle;
 
    if (ctx->watchdog != NULL)
    {
        rte_watchdog_timer_tick();
    }
 
    /* The A/B peer link is drained BEFORE this cycle's site-role step (G1 step 5b-2 review fix): rte_site_role takes
     * the sibling's site-state frame through the sibling source inside ab_gp_channel_negotiate_execute(), so the
     * frame this cycle's poll delivers must already be stored for the role decision and the A/B agreement check of
     * the same cycle (the check then compares role(N) with the frame received in N, as the old GP-side check did;
     * polling after the step would add one cycle of check lag and a fourth cycle to the reachability window).
     * Everything else these frames do is independent of the site-role step and of the relay poll below: checkpoint
     * request/reply caching and the reply send, SAF_RB (the SAF module accepts AU1 and the peer RB in either order),
     * KM114_DIGEST (compared in whichever order the two installs and the frame arrive) and STARTUP_TS (answered from
     * the fixed startup timestamp). The deferred frames are those the checkpoint rendezvous read last cycle. */
    peer_poll.ctx = ctx;
    rte_mem_set(peer_poll.peer_bytes, 0, sizeof(peer_poll.peer_bytes));
    peer_poll.have_peer_data = false;
 
    for (i = 0U; i < ctx->deferred_peer_count; i++)
    {
        on_peer_frame_received(&peer_poll, ctx->deferred_peer_frames[i][0], &ctx->deferred_peer_frames[i][1],
                               (size_t)PEER_WIRE_FRAME_SIZE - 1U);
    }
    ctx->deferred_peer_count = 0U;
    ab_gp_channel_poll_peer((ab_gp_channel_handle_t)ctx, on_peer_frame_received, &peer_poll);
 
    ab_gp_channel_negotiate_execute(ctx, cycle);
 
    own_role_byte = ctx->own_faulted ? (uint8_t)RTE_EXAMPLE_SITE_ROLE_FAULTED
                                      : (ctx->is_online ? (uint8_t)RTE_EXAMPLE_SITE_ROLE_ONLINE
                                                         : (uint8_t)RTE_EXAMPLE_SITE_ROLE_STANDBY);
 
    log_role_transition(ctx, cycle);
 
    for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
    {
        ctx->cyc_position_reply_due[i] = false;
    }
 
    relay_poll.ctx = ctx;
    relay_poll.have_channel_data = false;
 
    if (ctx->saf_train.enabled)
    {
        /* REQ-SC-004: a protected link silent for longer than the supervision time is declared lost; the train's
         * ERTMS session then times out exactly as it does on any other lost link. */
        uint32_t lost = ab_gp_saf_train_supervise(&ctx->saf_train, saf_now_ms(ctx));
 
        for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
        {
            if ((lost & ((uint32_t)1U << i)) != 0U)
            {
                char info[16];
 
                (void)snprintf(info, sizeof(info), "train=%u", (unsigned int)(i + 1U));
                rte_log_write_event(RTE_LOG_LEVEL_WARNING, site_config_name(ctx->site), cycle, "Train",
                                      ctx->role_tag, "SAF", "safe connection supervision expired - link lost", info);
            }
        }
    }
 
    drained_count = ab_gp_channel_poll_relays((ab_gp_channel_handle_t)ctx, on_relay_envelope_received, &relay_poll);
    ctx->cyc_have_channel_data = relay_poll.have_channel_data;
    if (drained_count > 0U)
    {
        ctx->last_relay_rx_cycle = cycle;
    }
 
    if (drained_count == 0U)
    {
        RTE_EXAMPLE_LOG("[%s] cycle %u: no envelopes from C yet - skipping this cycle's decision\n",
                             ctx->role_tag, cycle);
        rte_log_write_event(RTE_LOG_LEVEL_DEBUG, site_config_name(ctx->site), cycle, "C", ctx->role_tag,
                              "ENVELOPE", "none received", NULL);
    }
    else if (!ctx->is_online)
    {
        RTE_EXAMPLE_LOG("[%s] cycle %u: [%s] %u envelope(s) received - standby, not processed\n",
                             ctx->role_tag, cycle, ab_gp_channel_dual_role_byte_to_string(own_role_byte),
                             (unsigned int)drained_count);
        rte_log_write_event(RTE_LOG_LEVEL_DEBUG, site_config_name(ctx->site), cycle, "C", ctx->role_tag,
                              "ENVELOPE", "received - standby, not processed", NULL);
    }
 
    ab_gp_channel_poll_crosscompare((ab_gp_channel_handle_t)ctx, on_crosscompare_frame_received, &peer_poll);
    /* The verdict of this cycle's rte_site_role_execute() (the peer poll above the site-role step fed it). */
    ab_gp_channel_crosscompare_check_site_state(ctx);
 
    decode_and_apply_peer_sample(ctx, &peer_poll);
 
    check_dual_transfer_timeout(ctx, cycle);
 
    return RTE_STATUS_OK;
}