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;
46 int metadata_size, data_offset = 0;
49 data_len = orig_data_size;
51 *blocksize = payload_size = (aligned_data_len / k);
52 metadata_size = instance->common.ops->get_backend_metadata_size(
53 instance->desc.backend_desc,
55 data_offset = instance->common.ops->get_encode_offset(
56 instance->desc.backend_desc,
58 buffer_size = payload_size + metadata_size;
60 for (i = 0; i < k; i++) {
61 int copy_size = data_len > payload_size ? payload_size : data_len;
63 if (NULL == fragment) {
72 memcpy(encoded_data[i] + data_offset, orig_data, copy_size);
75 orig_data += copy_size;
76 data_len -= copy_size;
79 for (i = 0; i < m; i++) {
81 if (NULL == fragment) {
93 printf (
"ERROR in encode\n");
95 for (i = 0; i < k; i++) {
102 if (encoded_parity) {
103 for (i = 0; i < m; i++) {
104 if (encoded_parity[i])
122 char **data,
char **parity,
124 int *orig_size,
int *fragment_payload_size,
int fragment_size,
125 uint64_t *realloc_bm)
128 unsigned long long missing_bm;
129 int orig_data_size = -1;
130 int payload_size = -1;
132 missing_bm = convert_list_to_bitmap(missing_idxs);
140 for (i = 0; i < k; i++) {
147 if (NULL == data[i]) {
149 if (NULL == data[i]) {
150 log_error(
"Could not allocate data buffer!");
153 *realloc_bm = *realloc_bm | (1 << i);
154 }
else if (!is_addr_aligned((
unsigned long)data[i], 16)) {
156 if (NULL == tmp_buf) {
157 log_error(
"Could not allocate temp buffer!");
160 memcpy(tmp_buf, data[i], fragment_size);
162 *realloc_bm = *realloc_bm | (1 << i);
166 if (((missing_bm & (1 << i)) == 0) && orig_data_size < 0) {
168 if (orig_data_size < 0) {
169 log_error(
"Invalid orig_data_size in fragment header!");
173 if (orig_data_size < 0) {
174 log_error(
"Invalid fragment_size in fragment header!");
181 for (i = 0; i < m; i++) {
186 if (NULL == parity[i]) {
188 if (NULL == parity[i]) {
189 log_error(
"Could not allocate parity buffer!");
192 *realloc_bm = *realloc_bm | (1 << (k + i));
193 }
else if (!is_addr_aligned((
unsigned long)parity[i], 16)) {
195 if (NULL == tmp_buf) {
196 log_error(
"Could not allocate temp buffer!");
199 memcpy(tmp_buf, parity[i], fragment_size);
201 *realloc_bm = *realloc_bm | (1 << (k + i));
205 if (((missing_bm & (1 << (k + i))) == 0) && orig_data_size < 0) {
207 if (orig_data_size < 0) {
208 log_error(
"Invalid orig_data_size in fragment header!");
212 if (orig_data_size < 0) {
213 log_error(
"Invalid fragment_size in fragment header!");
220 *orig_size = orig_data_size;
221 *fragment_payload_size = payload_size;
228 char **fragments,
int num_fragments,
229 char **data,
char **parity,
int *missing)
238 for (i = 0; i < k; i++) {
241 for (i = 0; i < m; i++) {
248 for (i = 0; i < num_fragments; i++) {
250 if (index < 0 || index > (k + m)) {
254 data[index] = fragments[i];
256 parity[index - k] = fragments[i];
263 for (i = 0; i < k; i++) {
264 if (NULL == data[i]) {
265 missing[num_missing] = i;
269 for (i = 0; i < m; i++) {
270 if (NULL == parity[i]) {
271 missing[num_missing] = i + k;
277 return (num_missing > m) ? -EINSUFFFRAGS : 0;
281 char **fragments,
int num_fragments,
282 char **orig_payload, uint64_t *payload_len)
284 char *internal_payload = NULL;
286 int orig_data_size = -1;
294 if (num_fragments < k) {
305 log_error(
"Could not allocate buffer for data!!");
310 for (i = 0; i < num_fragments; i++) {
313 if ((index < 0) || (data_size < 0)) {
314 log_error(
"Invalid fragment header information!");
320 if (orig_data_size < 0) {
324 log_error(
"Inconsistent orig_data_size in fragment header!");
335 if (NULL == data[index]) {
336 data[index] = fragments[i];
353 if (NULL == internal_payload) {
354 log_error(
"Could not allocate buffer for decoded string!");
360 *payload_len = orig_data_size;
363 for (i = 0; i < num_data && orig_data_size > 0; i++) {
366 int payload_size = orig_data_size > fragment_size ? fragment_size : orig_data_size;
367 memcpy(internal_payload + string_off, fragment_data, payload_size);
368 orig_data_size -= payload_size;
369 string_off += payload_size;
380 *orig_payload = internal_payload;