sol-memmap-storage.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <stddef.h>
#include <stdint.h>

#include "sol-buffer.h"
#include "sol-str-table.h"
#include "sol-types.h"

#ifdef __cplusplus
extern "C" {
#endif

#define SOL_MEMMAP_VERSION_ENTRY "_version"

#define SOL_MEMMAP_ENTRY_BIT_SIZE(_name, _offset, _size, _bit_offset, _bit_size) \
    static struct sol_memmap_entry _name = { .offset = (_offset), .size = (_size), .bit_size = (_bit_size), .bit_offset = (_bit_offset) }


#define SOL_MEMMAP_ENTRY(_name, _offset, _size) \
    SOL_MEMMAP_ENTRY_BIT_SIZE(_name, _offset, _size, 0, 0)

#define SOL_MEMMAP_BOOL_ENTRY(_name, _offset, _bit_offset) \
    SOL_MEMMAP_ENTRY_BIT_SIZE(_name, _offset, 1, _bit_offset, 1)

typedef struct sol_memmap_map {
    uint8_t version; 
    const char *path; 
    uint32_t timeout; 
    const struct sol_str_table_ptr *entries;  /* Memory trick in place, must be last on struct*/
} sol_memmap_map;

typedef struct sol_memmap_entry {
    size_t offset; 
    size_t size; 
    uint32_t bit_size; 
    uint8_t bit_offset; 
} sol_memmap_entry;

int sol_memmap_write_raw(const char *name, struct sol_blob *blob,
    void (*cb)(void *data, const char *name, struct sol_blob *blob, int status),
    const void *data);

int sol_memmap_read_raw(const char *name, struct sol_buffer *buffer);

int sol_memmap_add_map(const struct sol_memmap_map *map);

int sol_memmap_remove_map(const struct sol_memmap_map *map);

int sol_memmap_set_timeout(struct sol_memmap_map *map, uint32_t timeout);

uint32_t sol_memmap_get_timeout(const struct sol_memmap_map *map);

#define CREATE_BUFFER(_val) \
    struct sol_buffer buf = SOL_BUFFER_INIT_FLAGS(_val, \
    sizeof(*(_val)), SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED | SOL_BUFFER_FLAGS_NO_NUL_BYTE);

#define CREATE_BLOB(_val) \
    struct sol_blob *blob; \
    size_t _s = sizeof(*_val); \
    void *v = malloc(_s); \
    SOL_NULL_CHECK(v, -ENOMEM); \
    memcpy(v, _val, _s); \
    blob = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL, v, _s); \
    if (!blob) { \
        free(v); \
        return -EINVAL; \
    }

static inline int
sol_memmap_read_uint8(const char *name, uint8_t *value)
{
    CREATE_BUFFER(value);

    return sol_memmap_read_raw(name, &buf);
}

static inline int
sol_memmap_write_uint8(const char *name, uint8_t value,
    void (*cb)(void *data, const char *name, struct sol_blob *blob, int status),
    const void *data)
{
    int r;

    CREATE_BLOB(&value);

    r = sol_memmap_write_raw(name, blob, cb, data);
    sol_blob_unref(blob);
    return r;
}

static inline int
sol_memmap_read_bool(const char *name, bool *value)
{
    CREATE_BUFFER(value);

    return sol_memmap_read_raw(name, &buf);
}

static inline int
sol_memmap_write_bool(const char *name, bool value,
    void (*cb)(void *data, const char *name, struct sol_blob *blob, int status),
    const void *data)
{
    int r;

    CREATE_BLOB(&value);

    r = sol_memmap_write_raw(name, blob, cb, data);
    sol_blob_unref(blob);
    return r;
}

static inline int
sol_memmap_read_int32(const char *name, int32_t *value)
{
    CREATE_BUFFER(value);

    return sol_memmap_read_raw(name, &buf);
}

static inline int
sol_memmap_write_int32(const char *name, int32_t value,
    void (*cb)(void *data, const char *name, struct sol_blob *blob, int status),
    const void *data)
{
    int r;

    CREATE_BLOB(&value);

    r = sol_memmap_write_raw(name, blob, cb, data);
    sol_blob_unref(blob);
    return r;
}

static inline int
sol_memmap_read_irange(const char *name, struct sol_irange *value)
{
    CREATE_BUFFER(value);

    return sol_memmap_read_raw(name, &buf);
}

static inline int
sol_memmap_write_irange(const char *name, struct sol_irange *value,
    void (*cb)(void *data, const char *name, struct sol_blob *blob, int status),
    const void *data)
{
    int r;

    CREATE_BLOB(value);

    r = sol_memmap_write_raw(name, blob, cb, data);
    sol_blob_unref(blob);
    return r;
}

static inline int
sol_memmap_read_drange(const char *name, struct sol_drange *value)
{
    CREATE_BUFFER(value);

    return sol_memmap_read_raw(name, &buf);
}

static inline int
sol_memmap_write_drange(const char *name, struct sol_drange *value,
    void (*cb)(void *data, const char *name, struct sol_blob *blob, int status),
    const void *data)
{
    int r;

    CREATE_BLOB(value);

    r = sol_memmap_write_raw(name, blob, cb, data);
    sol_blob_unref(blob);
    return r;
}

static inline int
sol_memmap_read_double(const char *name, double *value)
{
    CREATE_BUFFER(value);

    return sol_memmap_read_raw(name, &buf);
}

static inline int
sol_memmap_write_double(const char *name, double value,
    void (*cb)(void *data, const char *name, struct sol_blob *blob, int status),
    const void *data)
{
    int r;

    CREATE_BLOB(&value);

    r = sol_memmap_write_raw(name, blob, cb, data);
    sol_blob_unref(blob);
    return r;
}

static inline int
sol_memmap_read_string(const char *name, char **value)
{
    struct sol_buffer buf = SOL_BUFFER_INIT_EMPTY;
    int r;

    r = sol_memmap_read_raw(name, &buf);
    if (r < 0) {
        sol_buffer_fini(&buf);
        return r;
    }

    *value = (char *)sol_buffer_steal(&buf, NULL);

    return 0;
}

static inline int
sol_memmap_write_string(const char *name, const char *value,
    void (*cb)(void *data, const char *name, struct sol_blob *blob, int status),
    const void *data)
{
    int r;
    struct sol_blob *blob;
    char *string;

    string = strdup(value);
    SOL_NULL_CHECK(string, -ENOMEM);

    blob = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL, string, strlen(value) + 1);
    SOL_NULL_CHECK_GOTO(blob, error);

    r = sol_memmap_write_raw(name, blob, cb, data);
    sol_blob_unref(blob);
    return r;

error:
    free(string);

    return -ENOMEM;
}

#undef CREATE_BUFFER

#undef CREATE_BLOB

#ifdef __cplusplus
}
#endif