ipc.h

Go to the documentation of this file.

/* Copyright (C) 2019 Actia Nordic AB. All rights reserved. */
#ifndef LIBS_ACTIA_INCLUDE_IPC_H_
#define LIBS_ACTIA_INCLUDE_IPC_H_
 
#include <malloc.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define A_IPC_MAGIC               0xA1FC600D
#define A_IPC_LEGACY_MSG_BUF_SIZE 512
 
struct a_ipc_buffers {
    /* Outbox storage buffer.
     * Contains messages from the user.
     *
     * The _outbox_buffer pointer must be 8 byte aligned
     */
    uint8_t *_outbox_buffer;
    size_t _outbox_size;
 
    /* Inbox storage buffer.
     * Contains messages to the user.
     *
     * The _inbox_buffer pointer must be 8 byte aligned
     */
    uint8_t *_inbox_buffer;
    size_t _inbox_size;
};
 
#define A_IPC_ALLOC_MSG_BUFFER(name, size, modifiers)                                   \
    modifiers union {                                                                   \
        a_ipc_msg msg;                                                                  \
        uint8_t buf[(size)]; /* NOLINT(runtime/arrays) */                               \
    } name##_buf __attribute__((aligned(8))) = { .msg = { .info = {                     \
                                                              ._magic = A_IPC_MAGIC,    \
                                                              .msg_alloc_size = (size), \
                                                          } } };                        \
    modifiers a_ipc_msg *name = &name##_buf.msg
 
#define A_IPC_MSG_ON_STACK(name, size) A_IPC_ALLOC_MSG_BUFFER(name, (size), )
 
#define A_IPC_STATIC_MSG(name, size)   A_IPC_ALLOC_MSG_BUFFER(name, (size), static)
 
#define A_IPC_STATIC_BUFFERS(name, inbox_size, outbox_size) \
    A_IPC_STATIC_BUFFERS_BYTES(                             \
        name, ((inbox_size)*A_IPC_LEGACY_MSG_BUF_SIZE), ((outbox_size)*A_IPC_LEGACY_MSG_BUF_SIZE))
 
#define A_IPC_STATIC_BUFFERS_BYTES(name, inbox_size, outbox_size)            \
    static uint8_t name##_outbox[(outbox_size)] __attribute__((aligned(8))); \
    static uint8_t name##_inbox[(inbox_size)] __attribute__((aligned(8)));   \
    static a_ipc_buffers name = { ._outbox_buffer = name##_outbox,           \
                                  ._outbox_size = (outbox_size),             \
                                  ._inbox_buffer = name##_inbox,             \
                                  ._inbox_size = (inbox_size) }
 
#define A_IPC_ALLOCATE_BUFFERS(name, inbox_size, outbox_size) \
    A_IPC_ALLOCATE_BUFFERS_BYTES(                             \
        name, ((inbox_size)*A_IPC_LEGACY_MSG_BUF_SIZE), ((outbox_size)*A_IPC_LEGACY_MSG_BUF_SIZE))
 
#define A_IPC_ALLOCATE_BUFFERS_BYTES(name, inbox_size, outbox_size)        \
    a_ipc_buffers *name = (a_ipc_buffers *)malloc(sizeof(a_ipc_buffers));  \
    if (name != NULL) {                                                    \
        name->_outbox_size = outbox_size;                                  \
        name->_inbox_size = inbox_size;                                    \
        name->_inbox_buffer = (uint8_t *)memalign(8, name->_inbox_size);   \
        name->_outbox_buffer = (uint8_t *)memalign(8, name->_outbox_size); \
    }
 
typedef enum {
    A_IPC_RET_OK = 0,
    A_IPC_RET_ERROR = -1,
    A_IPC_RET_BUFFER_TOO_SMALL = -2,
    A_IPC_RET_BAD_TYPE = -3,
    A_IPC_RET_NO_MSG = -4,
    A_IPC_RET_SEND_ERROR = -5,
    A_IPC_RET_TIMEOUT = -6,
    A_IPC_RET_MALFORMED_PACKET = -7,
    A_IPC_RET_NOT_IMPLEMENTED = -8,
    A_IPC_RET_OUT_OF_MEMORY = -9,
    A_IPC_RET_INVALID_ARGUMENT = -10,
    A_IPC_RET_OUTBOX_FULL = -11,
} A_IPC_RESULT;
 
#define A_IPC_MAX_ID       30000
/* Host IDs */
#define A_IPC_HOST_MIN_ID  0
#define A_IPC_HOST_MAX_ID  14500
/* Guest IDs */
#define A_IPC_GUEST_MIN_ID 14501
#define A_IPC_GUEST_MAX_ID 30000
 
typedef struct a_ipc_buffers a_ipc_buffers;
 
typedef struct a_ipc_handle a_ipc_handle;
 
typedef struct a_ipc_msg a_ipc_msg;
 
typedef struct {
    uint32_t _magic;
    int type;
    size_t msg_alloc_size;
    size_t msg_used_size;
} a_ipc_msg_info;
 
a_ipc_handle *a_ipc_init(int id, a_ipc_buffers *buffers);
 
a_ipc_handle *a_ipc_init_ex(int id, a_ipc_buffers *buffers, unsigned int outstanding_window);
 
void a_ipc_destroy(a_ipc_handle *handle);
 
void a_ipc_free_buffers(a_ipc_buffers *buffers);
 
int a_ipc_get_fd(a_ipc_handle *handle);
 
A_IPC_RESULT a_ipc_send(a_ipc_handle *handle, int to, a_ipc_msg *msg);
 
A_IPC_RESULT a_ipc_recv(a_ipc_handle *handle, int *from, a_ipc_msg *msg);
 
A_IPC_RESULT a_ipc_set_filter(a_ipc_handle *handle, int *from, int *msg_type, int *error_msg_type);
A_IPC_RESULT a_ipc_copy_message(a_ipc_msg *dst, const a_ipc_msg *src);
 
const char *a_ipc_msg_type_str(int msg_type);
 
const char *a_ipc_result_str(A_IPC_RESULT result);
 
int a_ipc_dump_stats(a_ipc_handle *handle);
 
#ifdef __cplusplus
}
#endif
 
#endif // LIBS_ACTIA_INCLUDE_IPC_H_