erasurecode_helpers.c

Go to the documentation of this file.

/*
 * Copyright 2014 Tushar Gohad, Kevin M Greenan, Eric Lambert
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice, this
 * list of conditions and the following disclaimer in the documentation and/or
 * other materials provided with the distribution.  THIS SOFTWARE IS PROVIDED BY
 * THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * liberasurecode API helpers implementation
 *
 * vi: set noai tw=79 ts=4 sw=4:
 */
#include <assert.h>
#include <stdio.h>
#include <stdarg.h>
#include <zlib.h>
#include "erasurecode_backend.h"
#include "erasurecode_helpers.h"
#include "erasurecode_helpers_ext.h"
#include "erasurecode_stdinc.h"
#include "erasurecode_version.h"
 
#include "alg_sig.h"
#include "erasurecode_log.h"
 
/* ==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~== */
 
static bool is_fragment(char *buf)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic == LIBERASURECODE_FRAG_HEADER_MAGIC) {
        return true;
    }
 
    return false;
}
 
__attribute__ ((visibility ("internal")))
void *get_aligned_buffer16(int size)
{
    void *buf;
 
    if (posix_memalign(&buf, 16, size) != 0) {
        return NULL;
    }
 
    memset(buf, 0, size);
 
    return buf;
}
 
__attribute__ ((visibility ("internal")))
void * alloc_zeroed_buffer(int size)
{
    return alloc_and_set_buffer(size, 0);
}
 
void * alloc_and_set_buffer(int size, int value) {
    void * buf = NULL;  /* buffer to allocate and return */
 
    /* Allocate and zero the buffer, or set the appropriate error */
    buf = malloc((size_t) size);
    if (buf) {
        buf = memset(buf, value, (size_t) size);
    }
    return buf;
}
 
__attribute__ ((visibility ("internal")))
void * check_and_free_buffer(void * buf)
{
    if (buf)
        free(buf);
    return NULL;
}
 
__attribute__ ((visibility ("internal")))
char *alloc_fragment_buffer(int size)
{
    char *buf;
    fragment_header_t *header = NULL;
 
    size += sizeof(fragment_header_t);
    buf = get_aligned_buffer16(size);
 
    if (buf) {
        header = (fragment_header_t *) buf;
        header->magic = LIBERASURECODE_FRAG_HEADER_MAGIC;
    }
 
    return buf;
}
 
__attribute__ ((visibility ("internal")))
int free_fragment_buffer(char *buf)
{
    fragment_header_t *header;
 
    if (NULL == buf) {
        return -1;
    }
 
    buf -= sizeof(fragment_header_t);
 
    header = (fragment_header_t *) buf;
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (free fragment)!");
        return -1;
    }
 
    free(buf);
    return 0;
}
 
/* ==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~== */
 
__attribute__ ((visibility ("internal")))
uint64_t get_fragment_size(char *buf)
{
 
    if (NULL == buf)
        return -1;
 
    return get_fragment_buffer_size(buf) + sizeof(fragment_header_t);
 }
 
__attribute__ ((visibility ("internal")))
int get_aligned_data_size(ec_backend_t instance, int data_len)
{
    int k = instance->args.uargs.k;
    int w = instance->args.uargs.w;
    int word_size = w / 8;
    int alignment_multiple;
    int aligned_size = 0;
 
    /*
     * For Cauchy reed-solomon align to k*word_size*packet_size
     * For Vandermonde reed-solomon and flat-XOR, align to k*word_size
     */
    if (EC_BACKEND_JERASURE_RS_CAUCHY == instance->common.id) {
        alignment_multiple = k * w * (sizeof(long) * 128);
    } else {
        alignment_multiple = k * word_size;
    }
 
    aligned_size = ((data_len + alignment_multiple - 1) / alignment_multiple)
    * alignment_multiple;
 
    return aligned_size;
}
 
/* ==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~== */
 
char *get_data_ptr_from_fragment(char *buf)
{
    buf += sizeof(fragment_header_t);
 
    return buf;
}
 
__attribute__ ((visibility ("internal")))
int get_data_ptr_array_from_fragments(char **data_array, char **fragments,
                                      int num_fragments)
{
    int i = 0, num = 0;
    for (i = 0; i < num_fragments; i++) {
        char *frag = fragments[i];
        if (frag == NULL) {
            data_array[i] = NULL;
            continue;
        }
        data_array[i] = get_data_ptr_from_fragment(frag);
        num++;
    }
    return num;
}
 
__attribute__ ((visibility ("internal")))
int get_fragment_ptr_array_from_data(char **frag_array, char **data,
                                     int num_data)
{
    int i = 0, num = 0;
    for (i = 0; i < num_data; i++) {
        char *data_ptr = frag_array[i];
        if (data_ptr == NULL) {
            data[i] = NULL;
            continue;
        }
        data[i] = get_fragment_ptr_from_data(data_ptr);
        num++;
    }
    return num;
}
 
__attribute__ ((visibility ("internal")))
char *get_fragment_ptr_from_data_novalidate(char *buf)
{
    buf -= sizeof(fragment_header_t);
 
    return buf;
}
 
__attribute__ ((visibility ("internal")))
char *get_fragment_ptr_from_data(char *buf)
{
    fragment_header_t *header;
 
    buf -= sizeof(fragment_header_t);
 
    header = (fragment_header_t *) buf;
 
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (get header ptr)!\n");
        return NULL;
    }
 
    return buf;
}
 
/* ==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~== */
 
__attribute__ ((visibility ("internal")))
int set_fragment_idx(char *buf, int idx)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (idx check)!\n");
        return -1;
    }
 
    header->meta.idx = idx;
 
    return 0;
}
 
__attribute__ ((visibility ("internal")))
int get_fragment_idx(char *buf)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (get idx)!");
        return -1;
    }
 
    return header->meta.idx;
}
 
__attribute__ ((visibility ("internal")))
int set_fragment_payload_size(char *buf, int size)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (size check)!");
        return -1;
    }
 
    header->meta.size = size;
 
    return 0;
}
 
__attribute__ ((visibility ("internal")))
int get_fragment_payload_size(char *buf)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (get size)!");
        return -1;
    }
 
    return header->meta.size;
}
 
__attribute__ ((visibility ("internal")))
int set_fragment_backend_metadata_size(char *buf, int size)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (set fragment backend metadata size)!");
        return -1;
    }
 
    header->meta.frag_backend_metadata_size = size;
 
    return 0;
}
 
__attribute__ ((visibility ("internal")))
int get_fragment_backend_metadata_size(char *buf)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (get fragment backend metadata size)!");
        return -1;
    }
 
    return header->meta.frag_backend_metadata_size;
}
 
__attribute__ ((visibility ("internal")))
int get_fragment_buffer_size(char *buf)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (get size)!");
        return -1;
    }
 
    return header->meta.size + header->meta.frag_backend_metadata_size;
}
 
__attribute__ ((visibility ("internal")))
int set_orig_data_size(char *buf, int orig_data_size)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (set orig data check)!");
        return -1;
    }
 
    header->meta.orig_data_size = orig_data_size;
 
    return 0;
}
 
__attribute__ ((visibility ("internal")))
int get_orig_data_size(char *buf)
{
    fragment_header_t *header = (fragment_header_t *) buf;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (get orig data check)!");
        return -1;
    }
 
    return header->meta.orig_data_size;
}
 
__attribute__ ((visibility ("internal")))
int set_libec_version(char *buf)
{
    if (!is_fragment(buf)) {
            return -1;
    }
    fragment_header_t *header = (fragment_header_t *) buf;
    header->libec_version = (uint32_t)LIBERASURECODE_VERSION;
    return 0;
}
 
int get_libec_version(char *buf, uint32_t *ver)
{
    if (!is_fragment(buf)) {
            return -1;
    }
    fragment_header_t *header = (fragment_header_t *) buf;
    *ver = header->libec_version;
    return 0;
}
 
__attribute__ ((visibility ("internal")))
int set_backend_id(char *buf, ec_backend_id_t id)
{
    if (!is_fragment(buf)) {
            return -1;
    }
    fragment_header_t *header = (fragment_header_t *) buf;
    header->meta.backend_id = (uint8_t)id;
    return 0;
}
 
int get_backend_id(char *buf, ec_backend_id_t *id)
{
    if (!is_fragment(buf)) {
            return -1;
    }
    fragment_header_t *header = (fragment_header_t *) buf;
    *id = header->meta.backend_id;
    return 0;
}
 
__attribute__ ((visibility ("internal")))
int set_backend_version(char *buf, uint32_t version)
{
    if (!is_fragment(buf)) {
            return -1;
    }
    fragment_header_t *header = (fragment_header_t *) buf;
    header->meta.backend_version = version;
    return 0;
}
 
int get_backend_version(char *buf, uint32_t *version)
{
    if (!is_fragment(buf)) {
            return -1;
    }
    fragment_header_t *header = (fragment_header_t *) buf;
    *version = header->meta.backend_version;
    return 0;
}
 
/* ==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~== */
 
__attribute__ ((visibility ("internal")))
inline int set_checksum(ec_checksum_type_t ct, char *buf, int blocksize)
{
    fragment_header_t* header = (fragment_header_t*) buf;
    char *data = get_data_ptr_from_fragment(buf);
    char *flag;
 
    assert(NULL != header);
    if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
        log_error("Invalid fragment header (set chksum)!\n");
        return -1;
    }
 
    header->meta.chksum_type = ct;
    header->meta.chksum_mismatch = 0;
 
    switch(header->meta.chksum_type) {
        case CHKSUM_CRC32:
            flag = getenv("LIBERASURECODE_WRITE_LEGACY_CRC");
            if (flag && !(flag[0] == '\0' || (flag[0] == '0' && flag[1] == '\0'))) {
                header->meta.chksum[0] = liberasurecode_crc32_alt(0, data, blocksize);
            } else {
                header->meta.chksum[0] = crc32(0, (unsigned char *) data, blocksize);
            }
            break;
        case CHKSUM_MD5:
            break;
        case CHKSUM_NONE:
        default:
            break;
    }
 
    return 0;
}
 
/* ==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~==~=*=~== */