elos-common.h

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#ifndef __ELOS_COMMON_H__
#define __ELOS_COMMON_H__
 
#include <pthread.h>
#include <safu/common.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
 
#include "logio.h"
#include "thrpool.h"
 
#ifndef LIBELOS_SO_FILENAME
#define LIBELOS_SO_FILENAME "libelos.so.1"  
#endif
 
#define CRINIT_ELOS_CONNECTION_RETRIES 10uL
#define CRINIT_ELOS_CONNECTION_RETRY_INTERVAL_US 500000
 
#define ELOS_ID_INVALID 0  
 
#define ELOS_CLASSIFICATION_ELOS_MASK 0x00000000FFFFFFFFuLL
#define ELOS_CLASSIFICATION_USER_MASK 0x000000FF00000000uLL
#define ELOS_CLASSIFICATION_RESERVED_MASK 0xFFFFFF0000000000uLL
#define ELOS_CLASSIFICATION_UNDEFINED 0x0000000000000000uLL
#define ELOS_CLASSIFICATION_KERNEL 0x0000000000000001uLL
#define ELOS_CLASSIFICATION_NETWORK 0x0000000000000002uLL
#define ELOS_CLASSIFICATION_SECURITY 0x0000000000000004uLL
#define ELOS_CLASSIFICATION_POWER 0x0000000000000008uLL
#define ELOS_CLASSIFICATION_STORAGE 0x0000000000000010uLL
#define ELOS_CLASSIFICATION_PROCESS 0x0000000000000020uLL
#define ELOS_CLASSIFICATION_IPC 0x0000000000000040uLL
#define ELOS_CLASSIFICATION_HARDWARE 0x0000000000000080uLL
#define ELOS_CLASSIFICATION_ELOS 0x0000000000000100uLL
#define ELOS_CLASSIFICATION_PROCESS_ERRORS 0x0000000000000200uLL
#define ELOS_CLASSIFICATION_USER_0 0x0000000100000000uLL
#define ELOS_CLASSIFICATION_USER_1 0x0000000200000000uLL
#define ELOS_CLASSIFICATION_USER_2 0x0000000400000000uLL
#define ELOS_CLASSIFICATION_USER_3 0x0000000800000000uLL
#define ELOS_CLASSIFICATION_USER_4 0x0000001000000000uLL
#define ELOS_CLASSIFICATION_USER_5 0x0000002000000000uLL
#define ELOS_CLASSIFICATION_USER_6 0x0000004000000000uLL
#define ELOS_CLASSIFICATION_USER_7 0x0000008000000000uLL
 
typedef uint32_t crinitElosEventQueueId_t;
 
typedef struct crinitElosSession {
    int fd;          
    bool connected;  
} crinitElosSession_t;
 
typedef struct crinitElosEventSource {
    char *appName;   
    char *fileName;  
    pid_t pid;       
} crinitElosEventSource_t;
 
typedef enum crinitElosSeverityE_t {
    ELOS_SEVERITY_OFF = 0,
    ELOS_SEVERITY_FATAL,
    ELOS_SEVERITY_ERROR,
    ELOS_SEVERITY_WARN,
    ELOS_SEVERITY_INFO,
    ELOS_SEVERITY_DEBUG,
    ELOS_SEVERITY_VERBOSE,
} crinitElosSeverityE_t;
 
typedef enum crinitElosEventMessageCodeE_t {
    ELOS_MSG_CODE_INFO_LOG = 1102,            
    ELOS_MSG_CODE_PROCESS_CREATED = 2001,     
    ELOS_MSG_CODE_PROCESS_EXITED = 2002,      
    ELOS_MSG_CODE_FILE_OPENED = 2003,         
    ELOS_MSG_CODE_IPC_NOT_AUTHORIZED = 4001,  
    ELOS_MSG_CODE_EXIT_FAILURE = 5006,        
} crinitElosEventMessageCodeE_t;
 
typedef struct crinitElosEvent {
    struct timespec date;            
    crinitElosEventSource_t source;  
    crinitElosSeverityE_t
        severity;      
    char *hardwareid;  
    uint64_t classification;  
    crinitElosEventMessageCodeE_t messageCode;  
    char *payload;                              
} crinitElosEvent_t;
 
typedef struct crinitElosEventVector {
    size_t memorySize;      
    size_t elementSize;     
    uint32_t elementCount;  
    void *data;             
} crinitElosEventVector_t;
 
typedef struct crinitElosVirtualTable {
    char *elosServer;  
    int elosPort;      
 
    safuResultE_t (*connect)(const char *, uint16_t,
                             crinitElosSession_t **);  
    safuResultE_t (*getVersion)(crinitElosSession_t *,
                                const char **);  
    safuResultE_t (*eventSubscribe)(
        crinitElosSession_t *, const char *[], size_t,
        crinitElosEventQueueId_t *);  
    safuResultE_t (*eventUnsubscribe)(
        crinitElosSession_t *, crinitElosEventQueueId_t);  
    safuResultE_t (*eventQueueRead)(
        crinitElosSession_t *, crinitElosEventQueueId_t,
        crinitElosEventVector_t **);                            
    void *(*eventVecGetLast)(const crinitElosEventVector_t *);  
    void (*eventVectorDelete)(crinitElosEventVector_t *);  
    safuResultE_t (*eventPublish)(crinitElosSession_t *,
                                  const crinitElosEvent_t *);  
    safuResultE_t (*disconnect)(crinitElosSession_t *);        
} crinitElosVirtualTable_t;
 
int crinitElosInit(void);
 
crinitElosVirtualTable_t *crinitElosGetVTable(void);
 
int crinitElosDisconnect(crinitElosSession_t *session, pthread_mutex_t *sessionLock);
 
#define crinitElosTryExec(session, sessionLock, func, err_msg, ...)                                                   \
    __extension__({                                                                                                   \
        int res = SAFU_RESULT_OK;                                                                                     \
                                                                                                                      \
        if ((errno = pthread_mutex_lock(sessionLock)) != 0) {                                                         \
            crinitErrnoPrint("Failed to lock elos session.");                                                         \
            res = -1;                                                                                                 \
        } else {                                                                                                      \
            if ((session) != NULL && !(session)->connected) {                                                         \
                free(session);                                                                                        \
                (session) = NULL;                                                                                     \
            }                                                                                                         \
            size_t retryCount = 0;                                                                                    \
            while ((session) == NULL) {                                                                               \
                if (crinitElosGetVTable()->elosServer == NULL) {                                                      \
                    crinitErrPrint("Elos server configuration missing or not loaded yet.");                           \
                    res = -1;                                                                                         \
                    break;                                                                                            \
                } else {                                                                                              \
                    res = crinitElosGetVTable()->connect(crinitElosGetVTable()->elosServer,                           \
                                                         crinitElosGetVTable()->elosPort,                             \
                                                         (crinitElosSession_t **)&(session));                         \
                    if (res != SAFU_RESULT_OK) {                                                                      \
                        crinitDbgInfoPrint("Failed to connect to elosd on %s:%d.", crinitElosGetVTable()->elosServer, \
                                           crinitElosGetVTable()->elosPort);                                          \
                        if (retryCount >= CRINIT_ELOS_CONNECTION_RETRIES) {                                           \
                            crinitErrPrint("Maximum connection retries with elosd on %s:%d exceeded.",                \
                                           crinitElosGetVTable()->elosServer, crinitElosGetVTable()->elosPort);       \
                            break;                                                                                    \
                        }                                                                                             \
                        usleep(CRINIT_ELOS_CONNECTION_RETRY_INTERVAL_US);                                             \
                        retryCount++;                                                                                 \
                    }                                                                                                 \
                }                                                                                                     \
            }                                                                                                         \
                                                                                                                      \
            if (res == SAFU_RESULT_OK) {                                                                              \
                res = func(__VA_ARGS__);                                                                              \
                if (res != SAFU_RESULT_OK) {                                                                          \
                    crinitErrPrint(err_msg);                                                                          \
                }                                                                                                     \
                                                                                                                      \
                if ((errno = pthread_mutex_unlock(sessionLock)) != 0) {                                               \
                    crinitErrnoPrint("Failed to unlock elos session.");                                               \
                    res = -1;                                                                                         \
                }                                                                                                     \
            }                                                                                                         \
        }                                                                                                             \
                                                                                                                      \
        res;                                                                                                          \
    })
 
#endif /* __ELOS_COMMON_H__ */