32#include "erasurecode_backend.h"
33#include "erasurecode_helpers.h"
34#include "erasurecode_helpers_ext.h"
35#include "erasurecode_stdinc.h"
36#include "erasurecode_version.h"
39#include "erasurecode_log.h"
45 fragment_header_t *header = (fragment_header_t *) buf;
47 assert(NULL != header);
48 if (header->magic == LIBERASURECODE_FRAG_HEADER_MAGIC) {
69 if (posix_memalign(&buf, 16, size) != 0) {
101 buf = malloc((
size_t) size);
103 buf = memset(buf, value, (
size_t) size);
126 fragment_header_t *header = NULL;
128 size +=
sizeof(fragment_header_t);
132 header = (fragment_header_t *) buf;
133 header->magic = LIBERASURECODE_FRAG_HEADER_MAGIC;
141 fragment_header_t *header;
147 buf -=
sizeof(fragment_header_t);
149 header = (fragment_header_t *) buf;
150 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
151 log_error(
"Invalid fragment header (free fragment)!");
187 int k = instance->args.uargs.k;
188 int w = instance->args.uargs.w;
189 int word_size = w / 8;
190 int alignment_multiple;
191 int aligned_size = 0;
197 if (EC_BACKEND_JERASURE_RS_CAUCHY == instance->common.id) {
198 alignment_multiple = k * w * (
sizeof(long) * 128);
200 alignment_multiple = k * word_size;
203 aligned_size = ((data_len + alignment_multiple - 1) / alignment_multiple)
204 * alignment_multiple;
213 buf +=
sizeof(fragment_header_t);
222 for (i = 0; i < num_fragments; i++) {
223 char *frag = fragments[i];
225 data_array[i] = NULL;
238 for (i = 0; i < num_data; i++) {
239 char *data_ptr = frag_array[i];
240 if (data_ptr == NULL) {
252 buf -=
sizeof(fragment_header_t);
259 fragment_header_t *header;
261 buf -=
sizeof(fragment_header_t);
263 header = (fragment_header_t *) buf;
265 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
266 log_error(
"Invalid fragment header (get header ptr)!\n");
277 fragment_header_t *header = (fragment_header_t *) buf;
279 assert(NULL != header);
280 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
281 log_error(
"Invalid fragment header (idx check)!\n");
285 header->meta.idx = idx;
292 fragment_header_t *header = (fragment_header_t *) buf;
294 assert(NULL != header);
295 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
296 log_error(
"Invalid fragment header (get idx)!");
300 return header->meta.idx;
305 fragment_header_t *header = (fragment_header_t *) buf;
307 assert(NULL != header);
308 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
309 log_error(
"Invalid fragment header (size check)!");
313 header->meta.size = size;
320 fragment_header_t *header = (fragment_header_t *) buf;
322 assert(NULL != header);
323 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
324 log_error(
"Invalid fragment header (get size)!");
328 return header->meta.size;
333 fragment_header_t *header = (fragment_header_t *) buf;
335 assert(NULL != header);
336 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
337 log_error(
"Invalid fragment header (set fragment backend metadata size)!");
341 header->meta.frag_backend_metadata_size = size;
348 fragment_header_t *header = (fragment_header_t *) buf;
350 assert(NULL != header);
351 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
352 log_error(
"Invalid fragment header (get fragment backend metadata size)!");
356 return header->meta.frag_backend_metadata_size;
361 fragment_header_t *header = (fragment_header_t *) buf;
363 assert(NULL != header);
364 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
365 log_error(
"Invalid fragment header (get size)!");
369 return header->meta.size + header->meta.frag_backend_metadata_size;
374 fragment_header_t *header = (fragment_header_t *) buf;
376 assert(NULL != header);
377 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
378 log_error(
"Invalid fragment header (set orig data check)!");
382 header->meta.orig_data_size = orig_data_size;
389 fragment_header_t *header = (fragment_header_t *) buf;
391 assert(NULL != header);
392 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
393 log_error(
"Invalid fragment header (get orig data check)!");
397 return header->meta.orig_data_size;
405 fragment_header_t *header = (fragment_header_t *) buf;
406 header->libec_version = (uint32_t)LIBERASURECODE_VERSION;
415 fragment_header_t *header = (fragment_header_t *) buf;
416 *ver = header->libec_version;
425 fragment_header_t *header = (fragment_header_t *) buf;
426 header->meta.backend_id = (uint8_t)
id;
435 fragment_header_t *header = (fragment_header_t *) buf;
436 *
id = header->meta.backend_id;
445 fragment_header_t *header = (fragment_header_t *) buf;
446 header->meta.backend_version = version;
455 fragment_header_t *header = (fragment_header_t *) buf;
456 *version = header->meta.backend_version;
462inline int set_checksum(ec_checksum_type_t ct,
char *buf,
int blocksize)
464 fragment_header_t* header = (fragment_header_t*) buf;
468 assert(NULL != header);
469 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
470 log_error(
"Invalid fragment header (set chksum)!\n");
474 header->meta.chksum_type = ct;
475 header->meta.chksum_mismatch = 0;
477 switch(header->meta.chksum_type) {
479 flag = getenv(
"LIBERASURECODE_WRITE_LEGACY_CRC");
480 if (flag && !(flag[0] ==
'\0' || (flag[0] ==
'0' && flag[1] ==
'\0'))) {
483 header->meta.chksum[0] = crc32(0, (
unsigned char *) data, blocksize);
int liberasurecode_crc32_alt(int crc, const void *buf, size_t size)
int get_fragment_idx(char *buf)
void * alloc_zeroed_buffer(int size)
Allocate a zero-ed buffer of a specific size.
int set_fragment_payload_size(char *buf, int size)
int get_fragment_backend_metadata_size(char *buf)
void * get_aligned_buffer16(int size)
Memory Management Methods.
int get_backend_version(char *buf, uint32_t *version)
void * alloc_and_set_buffer(int size, int value)
Allocate a buffer of a specific size and set its' contents to the specified value.
int get_fragment_buffer_size(char *buf)
int set_checksum(ec_checksum_type_t ct, char *buf, int blocksize)
int get_backend_id(char *buf, ec_backend_id_t *id)
char * get_fragment_ptr_from_data(char *buf)
int set_fragment_idx(char *buf, int idx)
char * alloc_fragment_buffer(int size)
int free_fragment_buffer(char *buf)
int get_aligned_data_size(ec_backend_t instance, int data_len)
Compute a size aligned to the number of data and the underlying wordsize of the EC algorithm.
int get_data_ptr_array_from_fragments(char **data_array, char **fragments, int num_fragments)
uint64_t get_fragment_size(char *buf)
Return total fragment length (on-disk, on-wire)
int get_fragment_ptr_array_from_data(char **frag_array, char **data, int num_data)
int set_fragment_backend_metadata_size(char *buf, int size)
int get_fragment_payload_size(char *buf)
void * check_and_free_buffer(void *buf)
Deallocate memory buffer if it's not NULL.
int set_libec_version(char *buf)
char * get_data_ptr_from_fragment(char *buf)
int set_backend_id(char *buf, ec_backend_id_t id)
int get_libec_version(char *buf, uint32_t *ver)
int set_orig_data_size(char *buf, int orig_data_size)
char * get_fragment_ptr_from_data_novalidate(char *buf)
int set_backend_version(char *buf, uint32_t version)
int get_orig_data_size(char *buf)
static bool is_fragment(char *buf)