31 #include "erasurecode_backend.h"
32 #include "erasurecode_helpers.h"
33 #include "erasurecode_helpers_ext.h"
34 #include "erasurecode_stdinc.h"
35 #include "erasurecode_version.h"
38 #include "erasurecode_log.h"
44 fragment_header_t *header = (fragment_header_t *) buf;
46 assert(NULL != header);
47 if (header->magic == LIBERASURECODE_FRAG_HEADER_MAGIC) {
68 if (posix_memalign(&buf, 16, size) != 0) {
100 buf = malloc((
size_t) size);
102 buf = memset(buf, value, (
size_t) size);
125 fragment_header_t *header = NULL;
127 size +=
sizeof(fragment_header_t);
131 header = (fragment_header_t *) buf;
132 header->magic = LIBERASURECODE_FRAG_HEADER_MAGIC;
140 fragment_header_t *header;
146 buf -=
sizeof(fragment_header_t);
148 header = (fragment_header_t *) buf;
149 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
150 log_error(
"Invalid fragment header (free fragment)!");
186 int k = instance->args.uargs.k;
187 int w = instance->args.uargs.w;
188 int word_size = w / 8;
189 int alignment_multiple;
190 int aligned_size = 0;
196 if (EC_BACKEND_JERASURE_RS_CAUCHY == instance->common.id) {
197 alignment_multiple = k * w * (
sizeof(long) * 128);
199 alignment_multiple = k * word_size;
202 aligned_size = ((data_len + alignment_multiple - 1) / alignment_multiple)
203 * alignment_multiple;
212 buf +=
sizeof(fragment_header_t);
221 for (i = 0; i < num_fragments; i++) {
222 char *frag = fragments[i];
224 data_array[i] = NULL;
237 for (i = 0; i < num_data; i++) {
238 char *data_ptr = frag_array[i];
239 if (data_ptr == NULL) {
251 buf -=
sizeof(fragment_header_t);
258 fragment_header_t *header;
260 buf -=
sizeof(fragment_header_t);
262 header = (fragment_header_t *) buf;
264 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
265 log_error(
"Invalid fragment header (get header ptr)!\n");
276 fragment_header_t *header = (fragment_header_t *) buf;
278 assert(NULL != header);
279 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
280 log_error(
"Invalid fragment header (idx check)!\n");
284 header->meta.idx = idx;
291 fragment_header_t *header = (fragment_header_t *) buf;
293 assert(NULL != header);
294 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
295 log_error(
"Invalid fragment header (get idx)!");
299 return header->meta.idx;
304 fragment_header_t *header = (fragment_header_t *) buf;
306 assert(NULL != header);
307 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
308 log_error(
"Invalid fragment header (size check)!");
312 header->meta.size = size;
319 fragment_header_t *header = (fragment_header_t *) buf;
321 assert(NULL != header);
322 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
323 log_error(
"Invalid fragment header (get size)!");
327 return header->meta.size;
332 fragment_header_t *header = (fragment_header_t *) buf;
334 assert(NULL != header);
335 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
336 log_error(
"Invalid fragment header (set fragment backend metadata size)!");
340 header->meta.frag_backend_metadata_size = size;
347 fragment_header_t *header = (fragment_header_t *) buf;
349 assert(NULL != header);
350 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
351 log_error(
"Invalid fragment header (get fragment backend metadata size)!");
355 return header->meta.frag_backend_metadata_size;
360 fragment_header_t *header = (fragment_header_t *) buf;
362 assert(NULL != header);
363 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
364 log_error(
"Invalid fragment header (get size)!");
368 return header->meta.size + header->meta.frag_backend_metadata_size;
373 fragment_header_t *header = (fragment_header_t *) buf;
375 assert(NULL != header);
376 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
377 log_error(
"Invalid fragment header (set orig data check)!");
381 header->meta.orig_data_size = orig_data_size;
388 fragment_header_t *header = (fragment_header_t *) buf;
390 assert(NULL != header);
391 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
392 log_error(
"Invalid fragment header (get orig data check)!");
396 return header->meta.orig_data_size;
404 fragment_header_t *header = (fragment_header_t *) buf;
405 header->libec_version = (uint32_t)LIBERASURECODE_VERSION;
414 fragment_header_t *header = (fragment_header_t *) buf;
415 *ver = header->libec_version;
424 fragment_header_t *header = (fragment_header_t *) buf;
425 header->meta.backend_id = (uint8_t)
id;
434 fragment_header_t *header = (fragment_header_t *) buf;
435 *
id = header->meta.backend_id;
444 fragment_header_t *header = (fragment_header_t *) buf;
445 header->meta.backend_version = version;
454 fragment_header_t *header = (fragment_header_t *) buf;
455 *version = header->meta.backend_version;
461 inline int set_checksum(ec_checksum_type_t ct,
char *buf,
int blocksize)
463 fragment_header_t* header = (fragment_header_t*) buf;
466 assert(NULL != header);
467 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
468 log_error(
"Invalid fragment header (set chksum)!\n");
472 header->meta.chksum_type = ct;
473 header->meta.chksum_mismatch = 0;
475 switch(header->meta.chksum_type) {
477 header->meta.chksum[0] =
crc32(0, data, blocksize);
491 fragment_header_t* header = (fragment_header_t*) buf;
493 assert(NULL != header);
494 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
495 log_error(
"Invalid fragment header (get chksum)!");
499 return (uint32_t *) header->meta.chksum;
504 #if LIBERASURECODE_VERSION >= _VERSION(1,2,0)
507 fragment_header_t* header = (fragment_header_t*) buf;
509 assert(NULL != header);
510 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
511 log_error(
"Invalid fragment header (set meta chksum)!\n");
515 header->metadata_chksum =
crc32(0, &header->meta,
516 sizeof(fragment_metadata_t));
522 fragment_header_t* header = (fragment_header_t*) buf;
524 assert(NULL != header);
525 if (header->magic != LIBERASURECODE_FRAG_HEADER_MAGIC) {
526 log_error(
"Invalid fragment header (get meta chksum)!");
530 return (uint32_t *) &header->metadata_chksum;
540 return (uint32_t *) 0;
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_ptr_array_from_data(char **frag_array, char **data, int num_data)
char * get_fragment_ptr_from_data(char *buf)
int get_data_ptr_array_from_fragments(char **data_array, char **fragments, int num_fragments)
int get_fragment_idx(char *buf)
uint32_t * get_metadata_chksum(char *buf)
char * get_fragment_ptr_from_data_novalidate(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_fragment_buffer_size(char *buf)
char * get_data_ptr_from_fragment(char *buf)
int set_backend_version(char *buf, uint32_t version)
void * alloc_zeroed_buffer(int size)
Allocate a zero-ed buffer of a specific size.
int free_fragment_buffer(char *buf)
int get_orig_data_size(char *buf)
int get_backend_version(char *buf, uint32_t *version)
char * alloc_fragment_buffer(int size)
void * check_and_free_buffer(void *buf)
Deallocate memory buffer if it's not NULL.
void * get_aligned_buffer16(int size)
Memory Management Methods.
int set_metadata_chksum(char *buf)
int get_fragment_payload_size(char *buf)
int set_checksum(ec_checksum_type_t ct, char *buf, int blocksize)
uint32_t * get_chksum(char *buf)
uint64_t get_fragment_size(char *buf)
Return total fragment length (on-disk, on-wire)
static bool is_fragment(char *buf)
int get_fragment_backend_metadata_size(char *buf)
int crc32(int crc, const void *buf, size_t size)
int get_backend_id(char *buf, ec_backend_id_t *id)
int set_backend_id(char *buf, ec_backend_id_t id)
int set_orig_data_size(char *buf, int orig_data_size)
int get_libec_version(char *buf, uint32_t *ver)
int set_fragment_payload_size(char *buf, int size)
int set_fragment_idx(char *buf, int idx)
int set_fragment_backend_metadata_size(char *buf, int size)
int set_libec_version(char *buf)