cdi_os_api.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
// -------------------------------------------------------------------------------------------
 
// Page for CDI OS API
#ifndef CDI_OS_API_H__
#define CDI_OS_API_H__
 
//*********************************************************************************************************************
//***************************************** START OF DEFINITIONS AND TYPES ********************************************
//*********************************************************************************************************************
 
#if defined _WIN32
    // Windows specific #defs
    #ifndef _WIN32_WINNT
    #define _WIN32_WINNT 0x0502
    #endif  // _WIN32_WINNT 0x0502
 
    #ifndef WIN32_LEAN_AND_MEAN
    #define WIN32_LEAN_AND_MEAN
    #endif  // WIN32_LEAN_AND_MEAN
 
    #include <windows.h>
    #include <winsock2.h>
#elif defined (_LINUX)
    #include <netinet/in.h>
    #include <pthread.h>
    #include <semaphore.h>
    #include <signal.h>
    #include <string.h>
    #include <strings.h>
    #include <unistd.h>
#else
#error Either _WIN32 or _LINUX must be defined.
#endif
 
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <time.h>
 
#include "cdi_utility_api.h"
 
struct iovec;
 
#if defined _WIN32
    #define CDI_STDIN GetStdHandle(STD_INPUT_HANDLE)    
    #define CDI_STDOUT GetStdHandle(STD_OUTPUT_HANDLE)  
    #define CDI_STDERR GetStdHandle(STD_ERROR_HANDLE)   
 
    #define CDI_STDIN_FILENO _fileno(stdin)   
    #define CDI_STDOUT_FILENO _fileno(stdout) 
    #define CDI_STDERR_FILENO _fileno(stderr) 
 
    // Define portable thread Function.
    #define CdiThreadFuncName LPTHREAD_START_ROUTINE
    #define CDI_THREAD DWORD WINAPI
    #define CDI_THREAD_PARAM LPVOID
 
    typedef DWORD CdiThreadData;
 
    // Define portable semaphore. Don't use void* here, which prevents the compiler from type checking.
    typedef struct CdiSemID_* CdiSemID;
 
    // Define portable signal type.
    typedef HANDLE CdiSignalType;
 
    // Define portable critical section.
    typedef CRITICAL_SECTION* CdiCsID;
 
    // Define portable File ID type.
    typedef HANDLE CdiFileID;
 
    #define CDI_INFINITE INFINITE        // Infinity used as wait arguments, i.e "wait for infinity".
 
    // NOTE: These macros operate on 16-bit values.
    #define CdiOsAtomicInc16(x) InterlockedIncrement16(x)
    #define CdiOsAtomicDec16(x) InterlockedDecrement16(x)
    #define CdiOsAtomicRead16(x) InterlockedAdd16((x), 0)
    #define CdiOsAtomicAdd16(x, b) InterlockedAdd16((x), (b))
 
    // NOTE: These macros operate on 32-bit values.
    #define CdiOsAtomicInc32(x) InterlockedIncrement(x)
    #define CdiOsAtomicDec32(x) InterlockedDecrement(x)
    #define CdiOsAtomicRead32(x) InterlockedAdd((x), 0)
    #define CdiOsAtomicAdd32(x, b) InterlockedAdd((x), (b))
 
    // NOTE: These macros operate on 64-bit values.
    #define CdiOsAtomicInc64(x) InterlockedIncrement64(x)
    #define CdiOsAtomicDec64(x) InterlockedDecrement64(x)
    #define CdiOsAtomicRead64(x) InterlockedAdd64((x), 0)
    #define CdiOsAtomicAdd64(x, b) InterlockedAdd64((x), (b))
 
    // MSVC uses volatile to add necessary compiler/memory fence barriers as needed depending on CPU architecture. For
    // x86 platforms, recommend to use "/volatile:iso" for "C/C++"", "Command Line", "Additional Options" in MSVC
    // project configuration properties.
    #define CdiOsAtomicLoad16(x) *(volatile uint16_t*)(x)
    #define CdiOsAtomicStore16(x, v) *volatile (uint16_t*)(x) = (v)
    #define CdiOsAtomicLoad32(x) *(volatile uint32_t*)(x)
    #define CdiOsAtomicStore32(x, v) *(volatile uint32_t*)(x) = (v)
    #define CdiOsAtomicLoad64(x) *(volatile uint64_t*)(x)
    #define CdiOsAtomicStore64(x, v) *(volatile uint64_t*)(x) = (v)
    #define CdiOsAtomicLoadPointer(x) *(volatile void**)(x)
    #define CdiOsAtomicStorePointer(x, v) *(volatile void**)(x) = (v)
 
    #define CDI_INVALID_HANDLE_VALUE INVALID_HANDLE_VALUE
 
    typedef struct siginfo_t siginfo_t;
 
    struct siginfo_t {
        long si_pid;
        long si_uid;
    };
 
    struct sockaddr_in;
 
    typedef HANDLE CdiStaticMutexType;
    #define CDI_STATIC_MUTEX_INITIALIZER    NULL
    #define CdiOsStaticMutexLock(x) StaticMutexLockWin32(&(x))
    // If two threads enter the if-body, then only one succeeds in initializing the lock. When the application exists,
    // the mutex handle held in x will be freed by the windows OS.
    static inline void StaticMutexLockWin32(volatile HANDLE* x) {
        if (*x == NULL) {
            HANDLE tmp = CreateMutex(NULL, FALSE, NULL);
            if (InterlockedCompareExchangePointer((PVOID*)x, (PVOID)tmp, NULL) != NULL) {
                CloseHandle(tmp);
            }
        }
        WaitForSingleObject(*x, INFINITE);
    }
    #define CdiOsStaticMutexUnlock(x) (ReleaseMutex(x) == 0)
 
    // Huge pages not implemented in windows, so just use 1 byte for size.
    #define CDI_HUGE_PAGES_BYTE_SIZE    (1)
 
    // Windows generates a meaningful error that contains the specified message.
    #define CDI_STATIC_ASSERT(condition, message) static_assert(condition, message)
 
#elif defined _LINUX
    #define CDI_STDIN  stdin   
    #define CDI_STDOUT stdout  
    #define CDI_STDERR stderr  
 
    #define CDI_STDIN_FILENO STDIN_FILENO   
    #define CDI_STDOUT_FILENO STDOUT_FILENO 
    #define CDI_STDERR_FILENO STDERR_FILENO 
 
    #define CDI_THREAD_PARAM void*  
    #define CDI_THREAD int          
    typedef CDI_THREAD (*CdiThreadFuncName) (CDI_THREAD_PARAM); 
 
    typedef pthread_key_t CdiThreadData;
 
    typedef sem_t* CdiSemID;
 
    typedef struct CdiSignalType_t* CdiSignalType;
 
    typedef pthread_mutex_t* CdiCsID;
 
    typedef FILE* CdiFileID;
 
    #define CDI_INFINITE 0xFFFFFFFF  
 
    #define CdiOsAtomicInc16(x) __sync_add_and_fetch((x), 1)
    #define CdiOsAtomicDec16(x) __sync_sub_and_fetch((x), 1)
    #define CdiOsAtomicRead16(x) __sync_add_and_fetch((x), 0)
    #define CdiOsAtomicAdd16(x, b) __sync_add_and_fetch((x), (b))
 
    #define CdiOsAtomicInc32(x) __sync_add_and_fetch((x), 1)
    #define CdiOsAtomicDec32(x) __sync_sub_and_fetch((x), 1)
    #define CdiOsAtomicRead32(x) __sync_add_and_fetch((x), 0)
    #define CdiOsAtomicAdd32(x, b) __sync_add_and_fetch((x), (b))
 
    #define CdiOsAtomicInc64(x) __sync_add_and_fetch((x), 1)
    #define CdiOsAtomicDec64(x) __sync_sub_and_fetch((x), 1)
    #define CdiOsAtomicRead64(x) __sync_add_and_fetch((x), 0)
    #define CdiOsAtomicAdd64(x, b) __sync_add_and_fetch((x), (b))
 
 
    #define CdiOsAtomicLoad16(x) __atomic_load_n((x), __ATOMIC_CONSUME)
    #define CdiOsAtomicLoad32(x) __atomic_load_n((x), __ATOMIC_CONSUME)
    #define CdiOsAtomicLoad64(x) __atomic_load_n((x), __ATOMIC_CONSUME)
    #define CdiOsAtomicLoadPointer(x) __atomic_load_n((x), __ATOMIC_CONSUME)
 
 
    #define CdiOsAtomicStore16(x, v) __atomic_store_n((x), (v), __ATOMIC_RELEASE)
    #define CdiOsAtomicStore32(x, v) __atomic_store_n((x), (v), __ATOMIC_RELEASE)
    #define CdiOsAtomicStore64(x, v) __atomic_store_n((x), (v), __ATOMIC_RELEASE)
    #define CdiOsAtomicStorePointer(x, v) __atomic_store_n((x), (v), __ATOMIC_RELEASE)
 
    #define CDI_INVALID_HANDLE_VALUE -1
 
 
    typedef pthread_mutex_t CdiStaticMutexType;
    #define CDI_STATIC_MUTEX_INITIALIZER    PTHREAD_MUTEX_INITIALIZER
    #define CdiOsStaticMutexLock(x)         pthread_mutex_lock(&(x))
    #define CdiOsStaticMutexUnlock(x)       pthread_mutex_unlock(&(x))
 
    #define CDI_HUGE_PAGES_BYTE_SIZE    (2 * 1024 * 1024)
 
#define CDI_STATIC_ASSERT(condition, message) _Static_assert(condition, message) // NOTE: ACTUAL ERROR IS BELOW.
#endif // _LINUX
 
#define CDI_MAX_THREAD_NAME     (50)         
#define CDI_OS_SIG_TIMEOUT      (0xFFFFFFFF) 
 
#define CDI_MAX_WAIT_MULTIPLE   (64)
 
#define CDI_OS_SOCKET_MAX_IOVCNT (10)
 
typedef void (*CdiSignalHandlerFunction)(int sig, siginfo_t* siginfo, void* context);
 
typedef struct {
    int signal_num;  
    CdiSignalHandlerFunction func_ptr; 
} CdiSignalHandlerInfo;
 
typedef struct CdiThreadID_t* CdiThreadID;
 
typedef struct CdiSocket_t* CdiSocket;
 
#define CDI_MAX_SIGNAL_HANDLERS     (10)
 
#define CDI_MAX_FORMATTED_TIMEZONE_STRING_LENGTH   (128)
 
//*********************************************************************************************************************
//******************************************* START OF PUBLIC FUNCTIONS ***********************************************
//*********************************************************************************************************************
 
CDI_INTERFACE void CdiOsUseLogger(void);
 
// -- Threads --
 
CDI_INTERFACE bool CdiOsSignalHandlerSet(int signal_num, CdiSignalHandlerFunction func_ptr);
 
CDI_INTERFACE bool CdiOsThreadCreatePinned(CdiThreadFuncName thread_func, CdiThreadID* thread_id_out_ptr,
                                           const char* thread_name_str, void* thread_func_arg_ptr,
                                           CdiSignalType start_signal, int cpu_affinity);
 
static inline bool CdiOsThreadCreate(CdiThreadFuncName thread_func, CdiThreadID* thread_id_out_ptr,
                                     const char* thread_name_str, void* thread_func_arg_ptr, CdiSignalType start_signal)
{
    return CdiOsThreadCreatePinned(thread_func, thread_id_out_ptr, thread_name_str, thread_func_arg_ptr, start_signal,
                                   -1);
}
 
CDI_INTERFACE bool CdiOsThreadAllocData(CdiThreadData* handle_out_ptr);
 
CDI_INTERFACE bool CdiOsThreadFreeData(CdiThreadData handle);
 
CDI_INTERFACE bool CdiOsThreadSetData(CdiThreadData handle, void* content_ptr);
 
CDI_INTERFACE bool CdiOsThreadGetData(CdiThreadData handle, void** content_out_ptr);
 
CDI_INTERFACE const char* CdiOsThreadGetName(CdiThreadID thread_id);
 
CDI_INTERFACE bool CdiOsThreadJoin(CdiThreadID thread_id, uint32_t timeout_in_ms, bool* timed_out_ptr);
 
// -- Semaphores --
 
CDI_INTERFACE bool CdiOsSemaphoreCreate(CdiSemID* ret_sem_handle_ptr, int sem_count);
 
CDI_INTERFACE bool CdiOsSemaphoreDelete(CdiSemID sem_handle);
 
CDI_INTERFACE bool CdiOsSemaphoreRelease(CdiSemID sem_handle);
 
CDI_INTERFACE bool CdiOsSemaphoreReserve(CdiSemID sem_handle, int timeout_in_ms);
 
CDI_INTERFACE int CdiOsSemaphoreValueGet(CdiSemID sem_handle);
 
// -- Critical Sections --
 
CDI_INTERFACE bool CdiOsCritSectionCreate(CdiCsID* cs_handle_ptr);
 
CDI_INTERFACE void CdiOsCritSectionReserve(CdiCsID cs_handle);
 
CDI_INTERFACE void CdiOsCritSectionRelease(CdiCsID cs_handle);
 
CDI_INTERFACE bool CdiOsCritSectionDelete(CdiCsID cs_handle);
 
// -- String Functions ---
 
#if defined _WIN32
#define CdiOsStrTokR strtok_s
#else
#define CdiOsStrTokR strtok_r
#endif
 
// -- Signals --
 
CDI_INTERFACE bool CdiOsSignalCreate(CdiSignalType* signal_handle_ptr);
 
CDI_INTERFACE bool CdiOsSignalDelete(CdiSignalType signal_handle);
 
CDI_INTERFACE bool CdiOsSignalClear(CdiSignalType signal_handle);
 
CDI_INTERFACE bool CdiOsSignalSet(CdiSignalType signal_handle);
 
CDI_INTERFACE bool CdiOsSignalGet(CdiSignalType signal_handle);
 
CDI_INTERFACE bool CdiOsSignalReadState(CdiSignalType signal_handle);
 
CDI_INTERFACE bool CdiOsSignalWait(CdiSignalType signal_handle, uint32_t timeout_in_ms, bool* timed_out_ptr);
 
CDI_INTERFACE bool CdiOsSignalsWait(CdiSignalType* signal_array, uint8_t num_signals, bool wait_all,
                                    uint32_t timeout_in_ms, uint32_t* ret_signal_index_ptr);
 
// -- Memory --
 
CDI_INTERFACE void* CdiOsMemAlloc(int64_t mem_size);
 
CDI_INTERFACE void* CdiOsMemAllocZero(int64_t mem_size);
 
CDI_INTERFACE void CdiOsMemFree(void* mem_ptr);
 
CDI_INTERFACE void* CdiOsMemAllocHugePage(int64_t mem_size);
 
CDI_INTERFACE void CdiOsMemFreeHugePage(void* mem_ptr, int64_t mem_size);
 
// -- File --
 
CDI_INTERFACE bool CdiOsOpenForWrite(const char* file_name_str, CdiFileID* file_handle_ptr);
 
CDI_INTERFACE bool CdiOsOpenForRead(const char* file_name_str, CdiFileID* file_handle_ptr);
 
CDI_INTERFACE bool CdiOsClose(CdiFileID file_handle);
 
CDI_INTERFACE bool CdiOsRead(CdiFileID file_handle, void* buffer_ptr, uint32_t byte_count, uint32_t* bytes_read_ptr);
 
CDI_INTERFACE bool CdiOsWrite(CdiFileID file_handle, const void* data_ptr, uint32_t byte_count);
 
CDI_INTERFACE bool CdiOsFlush(CdiFileID file_handle);
 
CDI_INTERFACE bool CdiOsFTell(CdiFileID file_handle, uint64_t* current_position_ptr);
 
CDI_INTERFACE bool CdiOsFSeek(CdiFileID file_handle, int64_t offset, int position);
 
CDI_INTERFACE bool CdiOsSplitPath(const char* filepath_str, char* filename_str, int filename_buf_size,
                                  char* directory_str, int directory_buf_size);
 
CDI_INTERFACE bool CdiOsIsPathWriteable(const char* directory_str);
 
// -- Utilities - Strings, Sleep --
 
CDI_INTERFACE int CdiOsStrCpy(char* dest_str, uint32_t max_str_len, const char* src_str);
 
CDI_INTERFACE void CdiOsSleep(uint32_t milliseconds);
 
CDI_INTERFACE void CdiOsSleepMicroseconds(uint32_t microseconds);
 
#if defined _WIN32
#define CdiOsStrCaseCmp _stricmp
#define CdiOsStrNCaseCmp _strnicmp
#else
#define CdiOsStrNCaseCmp strncasecmp
#define CdiOsStrCaseCmp strcasecmp
#endif
 
#define CdiOsStrCmp strcmp
 
#define CdiOsStrNCmp strncmp
 
CDI_INTERFACE uint64_t CdiOsGetMicroseconds(void);
 
#define CdiOsGetMilliseconds() (CdiOsGetMicroseconds()/1000)
 
CDI_INTERFACE void CdiOsGetUtcTime(struct timespec* ret_time_ptr);
 
CDI_INTERFACE void CdiOsGetLocalTime(struct tm* local_time_ret_ptr);
 
CDI_INTERFACE int CdiOsGetLocalTimeString(char* time_str, int max_string_len);
 
CDI_INTERFACE bool CdiOsSocketOpen(const char* host_address_str, int port_number, const char* bind_address_str,
                                   CdiSocket* new_socket_ptr);
 
CDI_INTERFACE bool CdiOsSocketGetPort(CdiSocket socket_handle, int* port_number_ptr);
 
CDI_INTERFACE bool CdiOsSocketGetSockAddrIn(CdiSocket socket_handle, struct sockaddr_in* sockaddr_in_ptr);
 
CDI_INTERFACE bool CdiOsSocketClose(CdiSocket socket_handle);
 
CDI_INTERFACE bool CdiOsSocketRead(CdiSocket socket_handle, void* buffer_ptr, int* byte_count_ptr);
 
CDI_INTERFACE bool CdiOsSocketReadFrom(CdiSocket socket_handle, void* buffer_ptr, int* byte_count_ptr,
                                       struct sockaddr_in* source_address_ptr);
 
CDI_INTERFACE bool CdiOsSocketWrite(CdiSocket socket_handle, struct iovec* iov, int iovcnt, int* byte_count_ptr);
 
CDI_INTERFACE bool CdiOsSocketWriteTo(CdiSocket socket_handle, struct iovec* iov, int iovcnt,
                                      const struct sockaddr_in* destination_address_ptr, int* byte_count_ptr);
 
CDI_INTERFACE bool CdiOsEnvironmentVariableSet(const char* name_str, const char* value_str);
 
CDI_INTERFACE void CdiOsShutdown(void);
 
#endif // CDI_OS_API_H__