29 #include "erasurecode_backend.h"
30 #include "erasurecode_helpers.h"
31 #include "erasurecode_helpers_ext.h"
32 #include "erasurecode_log.h"
33 #include "erasurecode_preprocessing.h"
34 #include "erasurecode_stdinc.h"
38 const char *orig_data, uint64_t orig_data_size,
39 char **encoded_data,
char **encoded_parity,
45 int buffer_size, payload_size = 0;
48 data_len = orig_data_size;
50 *blocksize = payload_size = (aligned_data_len / k);
51 buffer_size = payload_size + instance->common.backend_metadata_size;
53 for (i = 0; i < k; i++) {
54 int copy_size = data_len > payload_size ? payload_size : data_len;
56 if (NULL == fragment) {
65 memcpy(encoded_data[i], orig_data, copy_size);
68 orig_data += copy_size;
69 data_len -= copy_size;
72 for (i = 0; i < m; i++) {
74 if (NULL == fragment) {
86 printf (
"ERROR in encode\n");
88 for (i = 0; i < k; i++) {
96 for (i = 0; i < m; i++) {
97 if (encoded_parity[i])
115 char **data,
char **parity,
117 int *orig_size,
int *fragment_payload_size,
int fragment_size,
118 uint64_t *realloc_bm)
121 unsigned long long missing_bm;
122 int orig_data_size = -1;
123 int payload_size = -1;
125 missing_bm = convert_list_to_bitmap(missing_idxs);
133 for (i = 0; i < k; i++) {
140 if (NULL == data[i]) {
142 if (NULL == data[i]) {
143 log_error(
"Could not allocate data buffer!");
146 *realloc_bm = *realloc_bm | (1 << i);
147 }
else if (!is_addr_aligned((
unsigned long)data[i], 16)) {
149 if (NULL == tmp_buf) {
150 log_error(
"Could not allocate temp buffer!");
153 memcpy(tmp_buf, data[i], fragment_size);
155 *realloc_bm = *realloc_bm | (1 << i);
159 if (((missing_bm & (1 << i)) == 0) && orig_data_size < 0) {
161 if (orig_data_size < 0) {
162 log_error(
"Invalid orig_data_size in fragment header!");
166 if (orig_data_size < 0) {
167 log_error(
"Invalid fragment_size in fragment header!");
174 for (i = 0; i < m; i++) {
179 if (NULL == parity[i]) {
181 if (NULL == parity[i]) {
182 log_error(
"Could not allocate parity buffer!");
185 *realloc_bm = *realloc_bm | (1 << (k + i));
186 }
else if (!is_addr_aligned((
unsigned long)parity[i], 16)) {
188 if (NULL == tmp_buf) {
189 log_error(
"Could not allocate temp buffer!");
192 memcpy(tmp_buf, parity[i], fragment_size);
194 *realloc_bm = *realloc_bm | (1 << (k + i));
198 if (((missing_bm & (1 << (k + i))) == 0) && orig_data_size < 0) {
200 if (orig_data_size < 0) {
201 log_error(
"Invalid orig_data_size in fragment header!");
205 if (orig_data_size < 0) {
206 log_error(
"Invalid fragment_size in fragment header!");
213 *orig_size = orig_data_size;
214 *fragment_payload_size = payload_size;
221 char **fragments,
int num_fragments,
222 char **data,
char **parity,
int *missing)
231 for (i = 0; i < k; i++) {
234 for (i = 0; i < m; i++) {
241 for (i = 0; i < num_fragments; i++) {
243 if (index < 0 || index > (k + m)) {
247 data[index] = fragments[i];
249 parity[index - k] = fragments[i];
256 for (i = 0; i < k; i++) {
257 if (NULL == data[i]) {
258 missing[num_missing] = i;
262 for (i = 0; i < m; i++) {
263 if (NULL == parity[i]) {
264 missing[num_missing] = i + k;
270 return (num_missing > m) ? -EINSUFFFRAGS : 0;
274 char **fragments,
int num_fragments,
275 char **orig_payload, uint64_t *payload_len)
277 char *internal_payload = NULL;
279 int orig_data_size = -1;
287 if (num_fragments < k) {
298 log_error(
"Could not allocate buffer for data!!");
303 for (i = 0; i < num_fragments; i++) {
306 if ((index < 0) || (data_size < 0)) {
307 log_error(
"Invalid fragment header information!");
313 if (orig_data_size < 0) {
317 log_error(
"Inconsistent orig_data_size in fragment header!");
328 if (NULL == data[index]) {
329 data[index] = fragments[i];
346 if (NULL == internal_payload) {
347 log_error(
"Could not allocate buffer for decoded string!");
353 *payload_len = orig_data_size;
356 for (i = 0; i < num_data && orig_data_size > 0; i++) {
359 int payload_size = orig_data_size > fragment_size ? fragment_size : orig_data_size;
361 memcpy(internal_payload + string_off, fragment_data, payload_size);
362 orig_data_size -= payload_size;
363 string_off += payload_size;
374 *orig_payload = internal_payload;
int get_fragment_partition(int k, int m, char **fragments, int num_fragments, char **data, char **parity, int *missing)
int get_fragment_idx(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...
char * get_data_ptr_from_fragment(char *buf)
int free_fragment_buffer(char *buf)
int prepare_fragments_for_decode(int k, int m, char **data, char **parity, int *missing_idxs, int *orig_size, int *fragment_payload_size, int fragment_size, uint64_t *realloc_bm)
int get_orig_data_size(char *buf)
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 get_fragment_payload_size(char *buf)
int fragments_to_string(int k, int m, char **fragments, int num_fragments, char **orig_payload, uint64_t *payload_len)
int prepare_fragments_for_encode(ec_backend_t instance, int k, int m, const char *orig_data, uint64_t orig_data_size, char **encoded_data, char **encoded_parity, int *blocksize)