rte_ipc_request_reply.c

Go to the documentation of this file.

 
#include "rte/oal/ipc/rte_ipc_request_reply.h"
#include "rte/utils/lifecycle/rte_lifecycle.h"
#include "rte/log.h"
 
/* Implementation stubs - actual implementation would use base IPC layer */





 

rte_status_t rte_ipc_rr_server_create(rte_ipc_rr_server_t *handle_out,
                                         const rte_ipc_rr_server_config_t *config)
{
    rte_status_t lifecycle_status;
 
    if (handle_out == NULL || config == NULL) {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    /* REQ-LIFECYCLE-001 (ADR-026): an RR server is a setup-only resource -
     * refuse once the application's setup phase has been locked. */
    lifecycle_status = rte_lifecycle_check_setup_allowed();
    if (lifecycle_status != RTE_STATUS_OK)
    {
        return lifecycle_status;
    }
 
    RTE_LOG_INFO("Creating RR server: %s (req_sz=%zu, reply_sz=%zu, depth=%zu)",
                  config->name, config->request_size, config->reply_size,
                  config->queue_depth);
 
    /* TODO: Implement using base IPC layer */
    return RTE_STATUS_OK;
}
 
rte_status_t rte_ipc_rr_receive_request(rte_ipc_rr_server_t server,
                                           rte_ipc_rr_request_t *request_out,
                                           rte_duration_ms_t timeout_ms)
{
    if (server == NULL || request_out == NULL) {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    /* TODO: Implement request receiving with timeout */
    return RTE_STATUS_TIMEOUT;
}
 
rte_status_t rte_ipc_rr_send_reply(rte_ipc_rr_server_t server,
                                      uint32_t request_id,
                                      const void *reply_data,
                                      size_t reply_size)
{
    if (server == NULL || reply_data == NULL) {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    RTE_LOG_DEBUG("Sending reply to request %u (%zu bytes)", request_id, reply_size);
 
    /* TODO: Implement reply sending */
    return RTE_STATUS_OK;
}
 
rte_status_t rte_ipc_rr_server_destroy(rte_ipc_rr_server_t server)
{
    if (server == NULL) {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    RTE_LOG_INFO("Destroying RR server");
    return RTE_STATUS_OK;
}
 
rte_status_t rte_ipc_rr_client_create(rte_ipc_rr_client_t *handle_out,
                                         const rte_ipc_rr_client_config_t *config)
{
    rte_status_t lifecycle_status;
 
    if (handle_out == NULL || config == NULL) {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    /* REQ-LIFECYCLE-001 (ADR-026): an RR client is a setup-only resource -
     * refuse once the application's setup phase has been locked. */
    lifecycle_status = rte_lifecycle_check_setup_allowed();
    if (lifecycle_status != RTE_STATUS_OK)
    {
        return lifecycle_status;
    }
 
    RTE_LOG_INFO("Creating RR client for server: %s", config->server_name);
 
    /* TODO: Implement client connection to server */
    return RTE_STATUS_OK;
}
 
rte_status_t rte_ipc_rr_request(rte_ipc_rr_client_t client,
                                   const void *request_data,
                                   size_t request_size,
                                   void *reply_out,
                                   size_t reply_size,
                                   rte_duration_ms_t timeout_ms)
{
    if (client == NULL || request_data == NULL || reply_out == NULL) {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    RTE_LOG_DEBUG("Sending RPC request (%zu bytes), waiting for reply (timeout=%u ms)",
                   request_size, timeout_ms);
 
    /* TODO: Implement request send + reply receive with timeout */
    return RTE_STATUS_TIMEOUT;
}
 
rte_status_t rte_ipc_rr_client_destroy(rte_ipc_rr_client_t client)
{
    if (client == NULL) {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    RTE_LOG_INFO("Destroying RR client");
    return RTE_STATUS_OK;
}