internal.h

Go to the documentation of this file.

// -------------------------------------------------------------------------------------------
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// This file is part of the AWS CDI-SDK, licensed under the BSD 2-Clause "Simplified" License.
// License details at: https://github.com/aws/aws-cdi-sdk/blob/mainline/LICENSE
// -------------------------------------------------------------------------------------------
 
#ifndef CDI_INTERNAL_H__
#define CDI_INTERNAL_H__
 
#include <assert.h>
 
// The configuration.h file must be included first since it can have defines which affect subsequent files.
#include "configuration.h"
 
#include "adapter_api.h"
#include "cdi_core_api.h"
#include "cdi_log_api.h"
#include "cdi_raw_api.h"
#include "internal_log.h"
 
//*********************************************************************************************************************
//***************************************** START OF DEFINITIONS AND TYPES ********************************************
//*********************************************************************************************************************
 
//*********************************************************************************************************************
//******************************************* START OF PUBLIC FUNCTIONS ***********************************************
//*********************************************************************************************************************
 
static inline bool IsValidTxHandle(const CdiConnectionHandle handle)
{
    return handle != NULL && handle->handle_type == kHandleTypeTx && handle->magic == kMagicConnection &&
           handle->adapter_state_ptr != NULL;
}
 
static inline bool IsValidRxHandle(const CdiConnectionHandle handle)
{
    return handle != NULL && handle->handle_type == kHandleTypeRx && handle->magic == kMagicConnection
           && handle->adapter_state_ptr != NULL;
}
 
static inline bool IsValidConnectionHandle(const CdiConnectionHandle handle)
{
    // with -O2 or higher, GCC optimizes to only a single check of magic
    return (IsValidTxHandle(handle) || IsValidRxHandle(handle));
}
 
static inline bool IsValidEndpointHandle(const CdiEndpointHandle handle)
{
    return handle != NULL && handle->magic == kMagicEndpoint;
}
 
static inline bool IsValidMemoryHandle(const CdiMemoryHandle handle)
{
    return handle != NULL && handle->magic == kMagicMemory;
}
 
static inline bool IsValidAdapterHandle(const CdiAdapterHandle handle)
{
    return handle != NULL && handle->magic == kMagicAdapter;
}
 
CdiReturnStatus CdiGlobalInitialization(const CdiCoreConfigData* core_config_ptr);
 
int CdiGatherInternal(const CdiSgList* sgl_ptr, int offset, void* dest_data_ptr, int byte_count);
 
CdiReturnStatus AdapterInitializeInternal(CdiAdapterData* adapter_data_ptr, CdiAdapterHandle* ret_handle_ptr);
 
CdiReturnStatus NetworkAdapterDestroyInternal(CdiAdapterHandle handle);
 
void ConnectionDestroyInternal(CdiConnectionHandle handle);
 
void EndpointDestroyInternal(CdiEndpointHandle handle);
 
CdiReturnStatus SdkShutdownInternal(void);
 
CdiReturnStatus ConnectionCommonResourcesCreate(CdiConnectionHandle handle, CdiCoreStatsCallback stats_cb_ptr,
                                                CdiUserCbParameter stats_user_cb_param,
                                                const CdiStatsConfigData* stats_config_ptr);
 
void ConnectionCommonResourcesDestroy(CdiConnectionHandle handle);
 
CdiReturnStatus ConnectionCommonPacketMessageThreadCreate(CdiConnectionHandle handle, char const* thread_name);
 
CdiReturnStatus CoreStatsConfigureInternal(CdiConnectionHandle handle, const CdiStatsConfigData* new_config_ptr,
                                           bool force_changes);
 
#define PAYLOAD_ERROR(con_state_ptr, app_cb_data_ptr, status_code, ...) { \
    PayloadErrorSet(con_state_ptr, app_cb_data_ptr, status_code, __VA_ARGS__); \
    CdiLogger(CdiLoggerThreadLogGet(), kLogComponentGeneric, kLogError, __FUNCTION__, __LINE__ , __VA_ARGS__); }
 
#define BACK_PRESSURE_ERROR(back_pressure_state, log_level, ...) \
    if (kCdiBackPressureNone == back_pressure_state) { \
        back_pressure_state = kCdiBackPressureActive; \
        CdiLogger(CdiLoggerThreadLogGet(), kLogComponentGeneric, log_level, __FUNCTION__, __LINE__, __VA_ARGS__); \
    }
 
void PayloadErrorSet(CdiConnectionState* con_state_ptr, AppPayloadCallbackData* app_cb_data_ptr,
                     CdiReturnStatus status_code, const char* format_str, ...);
 
void PayloadErrorFreeBuffer(CdiPoolHandle pool_handle, AppPayloadCallbackData* app_cb_data_ptr);
 
static inline void SglAppend(CdiSgList* sgl_list_ptr, CdiSglEntry* sgl_add_ptr)
{
    if (NULL == sgl_list_ptr->sgl_head_ptr) {
        sgl_list_ptr->sgl_head_ptr = sgl_add_ptr;
        sgl_list_ptr->sgl_tail_ptr = sgl_add_ptr;
    } else {
        if (NULL == sgl_list_ptr->sgl_tail_ptr) {
            sgl_list_ptr->sgl_tail_ptr = sgl_list_ptr->sgl_head_ptr;
        }
        sgl_list_ptr->sgl_tail_ptr->next_ptr = sgl_add_ptr;
        sgl_list_ptr->sgl_tail_ptr = sgl_add_ptr;
    }
    sgl_list_ptr->total_data_size += sgl_add_ptr->size_in_bytes; // Update size of the SGL list.
}
 
static inline void SglMoveEntries(CdiSgList* destination_sgl_ptr, CdiSgList* source_sgl_ptr)
{
    // If the SGL has a head, it should also have a tail. Validate both SGL lists.
    if (destination_sgl_ptr->sgl_head_ptr) {
        assert(destination_sgl_ptr->sgl_tail_ptr);
    }
    if (source_sgl_ptr->sgl_head_ptr) {
        assert(source_sgl_ptr->sgl_tail_ptr);
    }
 
    if (destination_sgl_ptr->sgl_tail_ptr != NULL) {
        destination_sgl_ptr->sgl_tail_ptr->next_ptr = source_sgl_ptr->sgl_head_ptr;
    } else {
        if (destination_sgl_ptr->sgl_head_ptr == NULL) {
            destination_sgl_ptr->sgl_head_ptr =  source_sgl_ptr->sgl_head_ptr;
        } else {
            destination_sgl_ptr->sgl_head_ptr->next_ptr = source_sgl_ptr->sgl_head_ptr;
        }
    }
    destination_sgl_ptr->sgl_tail_ptr = source_sgl_ptr->sgl_tail_ptr;
    destination_sgl_ptr->total_data_size += source_sgl_ptr->total_data_size; // Update size of the destination list.
    memset(source_sgl_ptr, 0, sizeof(*source_sgl_ptr));
}
 
static inline void SglSetEmptyForExternalUse(CdiSgList* sgl_ptr)
{
    sgl_ptr->total_data_size = 0;
    sgl_ptr->sgl_head_ptr = &cdi_global_context.empty_sgl_entry;
    sgl_ptr->sgl_tail_ptr = sgl_ptr->sgl_head_ptr;
    sgl_ptr->internal_data_ptr = NULL;
}
 
bool FreeSglEntries(CdiPoolHandle pool_handle, CdiSglEntry* sgl_entry_head_ptr);
 
void DumpPayloadConfiguration(const CdiCoreExtraData* core_extra_data_ptr, int extra_data_size,
                              const uint8_t* extra_data_array, CdiConnectionProtocolType protocol_type);
 
void BytesToHexString(const void* data_ptr, int data_byte_count, char* dest_buffer_str, int dest_buffer_size);
 
void DeviceGidToString(const uint8_t* device_gid_ptr, int gid_length, char* dest_buffer_str, int dest_buffer_size);
 
void SdkThreadJoin(CdiThreadID thread_id, CdiSignalType shutdown_signal);
 
CdiLogHandle CdiLogGlobalGetInternal(void);
 
#endif  // CDI_INTERNAL_H__