Commit 512353f8be456f9f8045faafbdb3356a4dbdb8ad - liberasurecode

+2

-2

configure.ac less more

41	41	if test x$debug = xtrue ; then
42	42	DEBUG=1
43	43	CXXFLAGS=""
44		CFLAGS="-O0 -ggdb -g3 -Werror -D_GNU_SOURCE=1"
	44	CFLAGS="-O0 -ggdb -g3 -Werror -D_GNU_SOURCE=1 -Wall -pedantic -std=c99"
45	45	else
46	46	DEBUG=0
47	47	CXXFLAGS=""
48		CFLAGS="-O2 -g -Werror -D_GNU_SOURCE=1"
	48	CFLAGS="-O2 -g -Werror -D_GNU_SOURCE=1 -Wall -pedantic -std=c99"
49	49	fi
50	50
51	51	AC_ARG_ENABLE([gcov],

+3

-1

include/erasurecode/alg_sig.h less more

24	24	#ifndef _ALG_SIG_H
25	25	#define _ALG_SIG_H
26	26
	27	typedef int (*galois_single_multiply_func)(int, int, int);
	28
27	29	struct jerasure_mult_routines {
28		int (*galois_single_multiply)(int, int, int);
	30	galois_single_multiply_func galois_single_multiply;
29	31	};
30	32
31	33	#define JERASURE_SONAME "libJerasure.dylib"

+0

-21

include/erasurecode/erasurecode.h less more

46	46	EC_BACKENDS_MAX,
47	47	} ec_backend_id_t;
48	48
49		#ifndef EC_BACKENDS_SUPPORTED
50		#define EC_BACKENDS_SUPPORTED
51		/* Supported EC backends */
52		static const char *ec_backend_names[EC_BACKENDS_MAX] = {
53		"null",
54		"jerasure_rs_vand",
55		"jerasure_rs_cauchy",
56		"flat_xor_hd",
57		};
58		#endif // EC_BACKENDS_SUPPORTED
59
60	49	/* ~==~==~==~= EC Fragment metadata - supported checksum types ~==~==~==~ */
61	50
62	51	/* Checksum types supported for fragment metadata stored in each fragment */

66	55	CHKSUM_MD5 = 2,
67	56	CHKSUM_TYPES_MAX,
68	57	} ec_checksum_type_t;
69
70		#ifndef EC_CHKSUM_TYPES_SUPPORTED
71		#define EC_CHKSUM_TYPES_SUPPORTED
72		/* Supported EC backends */
73		static const char *ec_chksum_types[CHKSUM_TYPES_MAX] = {
74		"none",
75		"crc32",
76		"md5",
77		};
78		#endif // EC_CHKSUM_TYPES_SUPPORTED
79	58
80	59	/* =~==~==~==~== EC Arguments - Common and backend-specific =~==~==~==~== */
81	60

+1

-1

include/erasurecode/erasurecode_helpers.h less more

134	134	int set_orig_data_size(char *buf, int orig_data_size);
135	135	int get_orig_data_size(char *buf);
136	136	int validate_fragment(char *buf);
137		int set_checksum(char *buf, int chksum);
	137	int set_checksum(char *buf, int blocksize);
138	138	int get_checksum(char *buf);
139	139
140	140	/* ==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~== */

+5

-1

include/erasurecode/erasurecode_postprocessing.h less more

29	29	#define _ERASURECODE_POSTPROCESSING_H_
30	30
31	31	int finalize_fragments_after_encode(ec_backend_t instance,
32		int k, int m, int blocksize,
	32	int k, int m, int blocksize, uint64_t orig_data_size,
33	33	char encoded_data, char encoded_parity);
34	34
	35	void add_fragment_metadata(char *fragment,
	36	int idx, uint64_t orig_data_size, int blocksize,
	37	int add_chksum);
	38
35	39	#endif

+2

-2

include/xor_codes/xor_code.h less more

53	53	int k;
54	54	int m;
55	55	int hd;
56		int *parity_bms;
57		int *data_bms;
	56	unsigned int *parity_bms;
	57	unsigned int *data_bms;
58	58	int (decode)(struct xor_code_s code_desc, char data, char parity, int *missing_idxs, int blocksize, int decode_parity);
59	59	void (encode)(struct xor_code_s code_desc, char data, char parity, int blocksize);
60	60	int (fragments_needed)(struct xor_code_s code_desc, int missing_idxs, int fragments_to_exclude, int *fragments_needed);

+63

-27

src/backends/jerasure/jerasure_rs_cauchy.c less more

36	36	struct ec_backend_op_stubs jerasure_rs_cauchy_ops;
37	37	struct ec_backend jerasure_rs_cauchy;
38	38
	39	typedef int* (*cauchy_original_coding_matrix_func)(int, int, int);
	40	typedef int* (jerasure_matrix_to_bitmatrix_func)(int, int, int, int );
	41	typedef int** (jerasure_smart_bitmatrix_to_schedule_func)(int, int, int, int );
	42	typedef void (jerasure_bitmatrix_encode_func)(int, int, int, int , char , char , int, int);
	43	typedef int (jerasure_bitmatrix_decode_func)(int, int, int, int , int, int ,char , char *, int, int);
	44	typedef int * (jerasure_erasures_to_erased_func)(int, int, int );
	45	typedef int (jerasure_make_decoding_bitmatrix_func)(int, int, int, int , int , int , int *);
	46	typedef void (jerasure_bitmatrix_dotprod_func)(int, int, int , int , int,char , char *, int, int);
	47
	48
	49
39	50	/*
40	51	* ToDo (KMG): Should we make this a parameter, or is that
41	52	* exposing too much b.s. to the client?

44	55
45	56	struct jerasure_rs_cauchy_descriptor {
46	57	/* calls required for init */
47		int * (*cauchy_original_coding_matrix)(int, int, int);
48		int * (jerasure_matrix_to_bitmatrix)(int, int, int, int);
49		int ** (jerasure_smart_bitmatrix_to_schedule)(int, int, int, int);
50
	58	cauchy_original_coding_matrix_func cauchy_original_coding_matrix;
	59	jerasure_matrix_to_bitmatrix_func jerasure_matrix_to_bitmatrix;
	60	jerasure_smart_bitmatrix_to_schedule_func jerasure_smart_bitmatrix_to_schedule;
	61
51	62	/* calls required for encode */
52		void (jerasure_bitmatrix_encode)(int, int, int, int , char , char , int, int);
	63	jerasure_bitmatrix_encode_func jerasure_bitmatrix_encode;
53	64
54	65
55	66	/* calls required for decode */
56		int (jerasure_bitmatrix_decode)(int, int, int, int , int, int ,char , char *, int, int);
	67	jerasure_bitmatrix_decode_func jerasure_bitmatrix_decode;
57	68
58	69
59	70	/* calls required for reconstruct */
60		int * (jerasure_erasures_to_erased)(int, int, int );
61		int (jerasure_make_decoding_bitmatrix)(int, int, int, int , int , int , int *);
62		void (jerasure_bitmatrix_dotprod)(int, int, int , int , int,char , char *, int, int);
	71	jerasure_erasures_to_erased_func jerasure_erasures_to_erased;
	72	jerasure_make_decoding_bitmatrix_func jerasure_make_decoding_bitmatrix;
	73	jerasure_bitmatrix_dotprod_func jerasure_bitmatrix_dotprod;
63	74
64	75	/* fields needed to hold state */
65	76	int *matrix;

92	103	(struct jerasure_rs_cauchy_descriptor*)desc;
93	104
94	105	/* FIXME - make jerasure_matrix_decode return a value */
95		jerasure_desc->jerasure_bitmatrix_decode(jerasure_desc->k,
	106	return jerasure_desc->jerasure_bitmatrix_decode(jerasure_desc->k,
96	107	jerasure_desc->m,
97	108	jerasure_desc->w,
98	109	jerasure_desc->bitmatrix,

180	191	}
181	192	}
182	193
183		out:
184	194	return ret;
185	195	}
186	196

220	230	goto error;
221	231	}
222	232	}
	233
	234	/*
	235	* ISO C forbids casting a void* to a function pointer.
	236	* Since dlsym return returns a void*, we use this union to
	237	* "transform" the void* to a function pointer.
	238	*/
	239	union {
	240	cauchy_original_coding_matrix_func initp;
	241	jerasure_matrix_to_bitmatrix_func matrixtobitmatrixp;
	242	jerasure_smart_bitmatrix_to_schedule_func matrixschedulep;
	243	jerasure_bitmatrix_encode_func encodep;
	244	jerasure_bitmatrix_decode_func decodep;
	245	jerasure_erasures_to_erased_func erasedp;
	246	jerasure_make_decoding_bitmatrix_func decodematrixp;
	247	jerasure_bitmatrix_dotprod_func dotprodp;
	248	void *vptr;
	249	} func_handle = {.vptr = NULL};
223	250
224	251	/* fill in function addresses */
225		desc->jerasure_bitmatrix_encode = dlsym(
226		backend_sohandle, "jerasure_bitmatrix_encode");
	252	func_handle.vptr = NULL;
	253	func_handle.vptr = dlsym(backend_sohandle, "jerasure_bitmatrix_encode");
	254	desc->jerasure_bitmatrix_encode = func_handle.encodep;
227	255	if (NULL == desc->jerasure_bitmatrix_encode) {
228	256	goto error;
229	257	}
230	258
231		desc->jerasure_bitmatrix_decode = dlsym(
232		backend_sohandle, "jerasure_bitmatrix_decode");
	259	func_handle.vptr = NULL;
	260	func_handle.vptr = dlsym(backend_sohandle, "jerasure_bitmatrix_decode");
	261	desc->jerasure_bitmatrix_decode = func_handle.decodep;
233	262	if (NULL == desc->jerasure_bitmatrix_decode) {
234	263	goto error;
235	264	}
236	265
237		desc->cauchy_original_coding_matrix = dlsym(
238		backend_sohandle, "cauchy_original_coding_matrix");
	266	func_handle.vptr = NULL;
	267	func_handle.vptr = dlsym(backend_sohandle, "cauchy_original_coding_matrix");
	268	desc->cauchy_original_coding_matrix = func_handle.initp;
239	269	if (NULL == desc->cauchy_original_coding_matrix) {
240	270	goto error;
241	271	}
242	272
243		desc->jerasure_matrix_to_bitmatrix = dlsym(
244		backend_sohandle, "jerasure_matrix_to_bitmatrix");
	273	func_handle.vptr = NULL;
	274	func_handle.vptr = dlsym(backend_sohandle, "jerasure_matrix_to_bitmatrix");
	275	desc->jerasure_matrix_to_bitmatrix = func_handle.matrixtobitmatrixp;
245	276	if (NULL == desc->jerasure_matrix_to_bitmatrix) {
246	277	goto error;
247	278	}
248	279
249		desc->jerasure_smart_bitmatrix_to_schedule = dlsym(
250		backend_sohandle, "jerasure_smart_bitmatrix_to_schedule");
	280	func_handle.vptr = NULL;
	281	func_handle.vptr = dlsym(backend_sohandle, "jerasure_smart_bitmatrix_to_schedule");
	282	desc->jerasure_smart_bitmatrix_to_schedule = func_handle.matrixschedulep;
251	283	if (NULL == desc->jerasure_smart_bitmatrix_to_schedule) {
252	284	goto error;
253	285	}
254	286
255		desc->jerasure_make_decoding_bitmatrix = dlsym(
256		backend_sohandle, "jerasure_make_decoding_bitmatrix");
	287	func_handle.vptr = NULL;
	288	func_handle.vptr = dlsym(backend_sohandle, "jerasure_make_decoding_bitmatrix");
	289	desc->jerasure_make_decoding_bitmatrix = func_handle.decodematrixp;
257	290	if (NULL == desc->jerasure_make_decoding_bitmatrix) {
258	291	goto error;
259	292	}
260	293
261		desc->jerasure_bitmatrix_dotprod = dlsym(
262		backend_sohandle, "jerasure_bitmatrix_dotprod");
	294	func_handle.vptr = NULL;
	295	func_handle.vptr = dlsym(backend_sohandle, "jerasure_bitmatrix_dotprod");
	296	desc->jerasure_bitmatrix_dotprod = func_handle.dotprodp;
263	297	if (NULL == desc->jerasure_bitmatrix_dotprod) {
264	298	goto error;
265	299	}
266	300
267		desc->jerasure_erasures_to_erased = dlsym(
268		backend_sohandle, "jerasure_erasures_to_erased");
	301	func_handle.vptr = NULL;
	302	func_handle.vptr = dlsym(backend_sohandle, "jerasure_erasures_to_erased");
	303	desc->jerasure_erasures_to_erased = func_handle.erasedp;
269	304	if (NULL == desc->jerasure_erasures_to_erased) {
270	305	goto error;
271	306	}

323	358	free(jerasure_desc->schedule);
324	359	}
325	360	free(desc);
	361	return 0;
326	362	}
327	363
328	364	struct ec_backend_op_stubs jerasure_rs_cauchy_op_stubs = {

+49

-19

src/backends/jerasure/jerasure_rs_vand.c less more

36	36	struct ec_backend_op_stubs jerasure_rs_vand_ops;
37	37	struct ec_backend jerasure_rs_vand;
38	38
	39	typedef int* (*reed_sol_vandermonde_coding_matrix_func)(int, int, int);
	40	typedef void (jerasure_matrix_encode_func)(int, int, int, int, char , char , int);
	41	typedef int (jerasure_matrix_decode_func)(int, int, int, int , int, int, char , char *, int);
	42	typedef int (jerasure_make_decoding_matrix_func)(int, int, int, int , int , int , int *);
	43	typedef int * (jerasure_erasures_to_erased_func)(int, int, int );
	44	typedef void (jerasure_matrix_dotprod_func)(int, int, int ,int , int,char , char *, int);
	45
39	46	struct jerasure_rs_vand_descriptor {
40	47	/* calls required for init */
41		int * (*reed_sol_vandermonde_coding_matrix)(int, int, int);
	48	reed_sol_vandermonde_coding_matrix_func reed_sol_vandermonde_coding_matrix;
42	49
43	50	/* calls required for encode */
44		void (jerasure_matrix_encode)(int, int, int, int, char , char , int);
	51	jerasure_matrix_encode_func jerasure_matrix_encode;
45	52
46	53	/* calls required for decode */
47		int (jerasure_matrix_decode)(int, int, int, int , int, int, char , char *, int);
	54	jerasure_matrix_decode_func jerasure_matrix_decode;
48	55
49	56	/* calls required for reconstruct */
50		int (jerasure_make_decoding_matrix)(int, int, int, int , int , int , int *);
51		int * (jerasure_erasures_to_erased)(int, int, int );
52		void (jerasure_matrix_dotprod)(int, int, int ,int , int,char , char *, int);
	57	jerasure_make_decoding_matrix_func jerasure_make_decoding_matrix;
	58	jerasure_erasures_to_erased_func jerasure_erasures_to_erased;
	59	jerasure_matrix_dotprod_func jerasure_matrix_dotprod;
53	60
54	61	/* fields needed to hold state */
55	62	int *matrix;

160	167	}
161	168	}
162	169
163		out:
164	170	return ret;
165	171	}
166	172

197	203	}
198	204	}
199	205
	206	/*
	207	* ISO C forbids casting a void* to a function pointer.
	208	* Since dlsym return returns a void*, we use this union to
	209	* "transform" the void* to a function pointer.
	210	*/
	211	union {
	212	reed_sol_vandermonde_coding_matrix_func initp;
	213	jerasure_matrix_encode_func encodep;
	214	jerasure_matrix_decode_func decodep;
	215	jerasure_make_decoding_matrix_func decodematrixp;
	216	jerasure_erasures_to_erased_func erasep;
	217	jerasure_matrix_dotprod_func dotprodp;
	218	void *vptr;
	219	} func_handle = {.vptr = NULL};
	220
	221
200	222	/* fill in function addresses */
201		desc->jerasure_matrix_encode = dlsym(
202		backend_sohandle, "jerasure_matrix_encode");
	223	func_handle.vptr = NULL;
	224	func_handle.vptr = dlsym(backend_sohandle, "jerasure_matrix_encode");
	225	desc->jerasure_matrix_encode = func_handle.encodep;
203	226	if (NULL == desc->jerasure_matrix_encode) {
204	227	goto error;
205	228	}
206	229
207		desc->jerasure_matrix_decode = dlsym(
208		backend_sohandle, "jerasure_matrix_decode");
	230	func_handle.vptr = NULL;
	231	func_handle.vptr = dlsym(backend_sohandle, "jerasure_matrix_decode");
	232	desc->jerasure_matrix_decode = func_handle.decodep;
209	233	if (NULL == desc->jerasure_matrix_decode) {
210	234	goto error;
211	235	}
212	236
213		desc->jerasure_make_decoding_matrix = dlsym(
214		backend_sohandle, "jerasure_make_decoding_matrix");
	237	func_handle.vptr = NULL;
	238	func_handle.vptr = dlsym(backend_sohandle, "jerasure_make_decoding_matrix");
	239	desc->jerasure_make_decoding_matrix = func_handle.decodematrixp;
215	240	if (NULL == desc->jerasure_make_decoding_matrix) {
216	241	goto error;
217	242	}
218	243
219		desc->jerasure_matrix_dotprod = dlsym(
220		backend_sohandle, "jerasure_matrix_dotprod");
	244	func_handle.vptr = NULL;
	245	func_handle.vptr = dlsym(backend_sohandle, "jerasure_matrix_dotprod");
	246	desc->jerasure_matrix_dotprod = func_handle.dotprodp;
221	247	if (NULL == desc->jerasure_matrix_dotprod) {
222	248	goto error;
223	249	}
224	250
225		desc->jerasure_erasures_to_erased = dlsym(
226		backend_sohandle, "jerasure_erasures_to_erased");
	251	func_handle.vptr = NULL;
	252	func_handle.vptr = dlsym(backend_sohandle, "jerasure_erasures_to_erased");
	253	desc->jerasure_erasures_to_erased = func_handle.erasep;
227	254	if (NULL == desc->jerasure_erasures_to_erased) {
228	255	goto error;
229	256	}
230	257
231		desc->reed_sol_vandermonde_coding_matrix = dlsym(
232		backend_sohandle, "reed_sol_vandermonde_coding_matrix");
	258	func_handle.vptr = NULL;
	259	func_handle.vptr = dlsym(backend_sohandle, "reed_sol_vandermonde_coding_matrix");
	260	desc->reed_sol_vandermonde_coding_matrix = func_handle.initp;
233	261	if (NULL == desc->reed_sol_vandermonde_coding_matrix) {
234	262	goto error;
235	263	}

272	300	jerasure_desc = (struct jerasure_rs_vand_descriptor*) desc;
273	301
274	302	free(jerasure_desc);
	303
	304	return 0;
275	305	}
276	306
277	307	struct ec_backend_op_stubs jerasure_rs_vand_op_stubs = {

+41

-27

src/backends/null/null.c less more

35	35	struct ec_backend null;
36	36	struct ec_backend_op_stubs null_ops;
37	37
	38	typedef void* (*init_null_code_func)(int, int, int);
	39	typedef int (null_code_encode_func)(void , char , char , int);
	40	typedef int (null_code_decode_func)(void , char , char , int *, int, int);
	41	typedef int (null_reconstruct_func)(char , int, uint64_t, int, char );
	42	typedef int (null_code_fragments_needed_func)(void , int , int , int *);
	43
38	44	struct null_descriptor {
39	45	/* calls required for init */
40		void* (*init_null_code)(int k, int m, int hd);
	46	init_null_code_func init_null_code;
41	47
42	48	/* calls required for encode */
43		int (null_code_encode)(void code_desc, char data, char parity,
44		int blocksize);
	49	null_code_encode_func null_code_encode;
45	50
46	51	/* calls required for decode */
47		int (null_code_decode)(void code_desc, char data, char parity,
48		int *missing_idxs, int blocksize, int decode_parity);
	52	null_code_decode_func null_code_decode;
49	53
50	54	/* calls required for reconstruct */
51		int (null_reconstruct)(char *available_fragments, int num_fragments,
52		uint64_t fragment_len, int destination_idx, char* out_fragment);
	55	null_reconstruct_func null_reconstruct;
53	56
54	57	/* set of fragments needed to reconstruct at a minimum */
55		int (null_code_fragments_needed)(void code_desc, int *missing_idxs,
56		int fragments_to_exclude, int fragments_needed);
	58	null_code_fragments_needed_func null_code_fragments_needed;
57	59
58	60	/* fields needed to hold state */
59	61	int *matrix;

67	69
68	70	static int null_encode(void desc, char data, char *parity, int blocksize)
69	71	{
70		struct null_descriptor xdesc = (struct null_descriptor ) desc;
71
72	72	return 0;
73	73	}
74	74
75	75	static int null_decode(void desc, char data, char *parity,
76	76	int *missing_idxs, int blocksize)
77	77	{
78		struct null_descriptor xdesc = (struct null_descriptor ) desc;
79
80	78	return 0;
81	79	}
82	80
83	81	static int null_reconstruct(void desc, char data, char *parity,
84	82	int *missing_idxs, int destination_idx, int blocksize)
85	83	{
86		struct null_descriptor xdesc = (struct null_descriptor ) desc;
87
88	84	return 0;
89	85	}
90	86
91	87	static int null_min_fragments(void desc, int missing_idxs,
92	88	int fragments_to_exclude, int fragments_needed)
93	89	{
94		struct null_descriptor xdesc = (struct null_descriptor ) desc;
95
96	90	return 0;
97	91	}
98	92

142	136	}
143	137	}
144	138
	139	/*
	140	* ISO C forbids casting a void* to a function pointer.
	141	* Since dlsym return returns a void*, we use this union to
	142	* "transform" the void* to a function pointer.
	143	*/
	144	union {
	145	init_null_code_func initp;
	146	null_code_encode_func encodep;
	147	null_code_decode_func decodep;
	148	null_reconstruct_func reconp;
	149	null_code_fragments_needed_func fragsneededp;
	150	void *vptr;
	151	} func_handle = {.vptr = NULL};
	152
145	153	/* fill in function addresses */
146		xdesc->init_null_code = dlsym(
147		backend_sohandle, "null_code_init");
	154	func_handle.vptr = NULL;
	155	func_handle.vptr = dlsym(backend_sohandle, "null_code_init");
	156	xdesc->init_null_code = func_handle.initp;
148	157	if (NULL == xdesc->init_null_code) {
149	158	goto error;
150	159	}
151	160
152		xdesc->null_code_encode = dlsym(
153		backend_sohandle, "null_code_encode");
	161	func_handle.vptr = NULL;
	162	func_handle.vptr = dlsym(backend_sohandle, "null_code_encode");
	163	xdesc->null_code_encode = func_handle.encodep;
154	164	if (NULL == xdesc->null_code_encode) {
155	165	goto error;
156	166	}
157	167
158		xdesc->null_code_decode = dlsym(
159		backend_sohandle, "null_code_decode");
	168	func_handle.vptr = NULL;
	169	func_handle.vptr = dlsym(backend_sohandle, "null_code_decode");
	170	xdesc->null_code_decode = func_handle.decodep;
160	171	if (NULL == xdesc->null_code_decode) {
161	172	goto error;
162	173	}
163	174
164		xdesc->null_reconstruct = dlsym(
165		backend_sohandle, "null_reconstruct");
	175	func_handle.vptr = NULL;
	176	func_handle.vptr = dlsym(backend_sohandle, "null_reconstruct");
	177	xdesc->null_reconstruct = func_handle.reconp;
166	178	if (NULL == xdesc->null_reconstruct) {
167	179	goto error;
168	180	}
169	181
170		xdesc->null_code_fragments_needed = dlsym(
171		backend_sohandle, "null_code_fragments_needed");
	182	func_handle.vptr = NULL;
	183	func_handle.vptr = dlsym(backend_sohandle, "null_code_fragments_needed");
	184	xdesc->null_code_fragments_needed = func_handle.fragsneededp;
172	185	if (NULL == xdesc->null_code_fragments_needed) {
173	186	goto error;
174	187	}

186	199	struct null_descriptor xdesc = (struct null_descriptor ) desc;
187	200
188	201	free (xdesc);
	202	return 0;
189	203	}
190	204
191	205	struct ec_backend_op_stubs null_op_stubs = {

+12

-9

src/backends/xor/flat_xor_hd.c less more

36	36	struct ec_backend_op_stubs flat_xor_hd_ops;
37	37	struct ec_backend flat_xor_hd;
38	38
	39	typedef xor_code_t* (*init_xor_hd_code_func)(int, int, int);
	40	typedef void (xor_code_encode_func)(xor_code_t , char , char , int);
	41	typedef int (xor_code_decode_func)(xor_code_t , char , char , int *, int, int);
	42	typedef int (xor_hd_fragments_needed_func)(xor_code_t , int , int , int *);
	43
39	44	struct flat_xor_hd_descriptor {
40	45	xor_code_t *xor_desc;
41
42		xor_code_t* (*init_xor_hd_code)(int k, int m, int hd);
43		void (xor_code_encode)(xor_code_t code_desc, char data, char parity,
44		int blocksize);
45		int (xor_hd_decode)(xor_code_t code_desc, char data, char parity,
46		int *missing_idxs, int blocksize, int decode_parity);
47		int (xor_hd_fragments_needed)(xor_code_t code_desc, int *missing_idxs,
48		int fragments_to_exclude, int fragments_needed);
	46	init_xor_hd_code_func init_xor_hd_code;
	47	xor_code_encode_func xor_code_encode;
	48	xor_code_decode_func xor_code_decode;
	49	xor_hd_fragments_needed_func xor_hd_fragments_needed;
49	50	};
50	51
51	52	#define DEFAULT_W 32

58	59
59	60	xor_code_t xor_desc = (xor_code_t ) xdesc->xor_desc;
60	61	xor_desc->encode(xor_desc, data, parity, blocksize);
	62	return 0;
61	63	}
62	64
63	65	static int flat_xor_hd_decode(void *desc,

68	70	(struct flat_xor_hd_descriptor *) desc;
69	71
70	72	xor_code_t xor_desc = (xor_code_t ) xdesc->xor_desc;
71		xor_desc->decode(xor_desc, data, parity, missing_idxs, blocksize, 1);
	73	return xor_desc->decode(xor_desc, data, parity, missing_idxs, blocksize, 1);
72	74	}
73	75
74	76	static int flat_xor_hd_reconstruct(void *desc,

144	146
145	147	free (bdesc->xor_desc);
146	148	free (bdesc);
	149	return 0;
147	150	}
148	151
149	152	struct ec_backend_op_stubs flat_xor_hd_op_stubs = {

+2

-0

src/builtin/null_code/null_code.c less more

25	25	* vi: set noai tw=79 ts=4 sw=4:
26	26	*/
27	27
	28	#include <stdlib.h>
28	29	#include <stdint.h>
29	30
30	31	/* calls required for init */
31	32	void* null_code_init(int k, int m, int hd)
32	33	{
33	34	/* add your code here */
	35	return NULL;
34	36	}
35	37
36	38	/* calls required for encode */

+0

-1

src/builtin/xor_codes/xor_hd_code.c less more

57	57	// Verify that missing_data[2] == -1?
58	58	int data_index = missing_data[0];
59	59	int parity_index = index_of_connected_parity(code_desc, data_index, missing_parity, missing_data);
60		int i;
61	60	int ret;
62	61
63	62	if (parity_index < 0) {

+14

-12

src/erasurecode.c less more

30	30	#include "erasurecode_backend.h"
31	31	#include "erasurecode_helpers.h"
32	32	#include "erasurecode_preprocessing.h"
	33	#include "erasurecode_postprocessing.h"
33	34	#include "erasurecode_stdinc.h"
	35	#include "erasurecode/alg_sig.h"
34	36
35	37	/* =~==~==~==~==~==~= Supported EC backends =~==~==~==~==~==~==~==~== /
36	38

39	41	extern struct ec_backend_common backend_flat_xor_hd;
40	42	extern struct ec_backend_common backend_jerasure_rs_vand;
41	43	extern struct ec_backend_common backend_jerasure_rs_cauchy;
	44
	45	static const char *ec_chksum_types[CHKSUM_TYPES_MAX] = {
	46	"none",
	47	"crc32",
	48	"md5",
	49	};
42	50
43	51	ec_backend_t ec_backends_supported[] = {
44	52	(ec_backend_t) &backend_null,

170	178	} else {
171	179	goto exit;
172	180	}
173
174		register_out:
175	181	rwlock_unlock(&active_instances_rwlock);
	182
176	183	exit:
177	184	return rc;
178	185	}

191	198	/* Generic dlopen/dlclose routines */
192	199	int liberasurecode_backend_open(ec_backend_t instance)
193	200	{
194		void *handle = NULL;
195	201	if (instance && NULL != instance->desc.backend_sohandle)
196	202	return 0;
197	203

439	445	char *encoded_data, char encoded_parity, / output */
440	446	uint64_t fragment_len) / output */
441	447	{
442		int i;
443	448	int k, m;
444	449	int ret = 0; /* return code */
445	450
446	451	int blocksize = 0; /* length of each of k data elements */
447		int data_len; /* data len to write to fragment headers */
448		int aligned_data_len; /* EC algorithm compatible data length */
449	452
450	453	if (orig_data == NULL) {
451	454	log_error("Pointer to data buffer is null!");

540	543	*/
541	544	int liberasurecode_decode_cleanup(int desc, char *data)
542	545	{
543		int i;
544	546	ec_backend_t instance = liberasurecode_backend_instance_get_by_desc(desc);
545	547	if (NULL == instance) {
546	548	return -EBACKENDNOTAVAIL;

571	573	int i, j;
572	574	int ret = 0;
573	575
574		int k, m;
	576	int k = -1, m = -1;
575	577	int orig_data_size = 0;
576	578
577	579	int blocksize = 0;

761	763	char **parity = NULL;
762	764	int *missing_idxs = NULL;
763	765	char *fragment_ptr = NULL;
764		int k;
765		int m;
	766	int k = -1;
	767	int m = -1;
766	768	int i;
767		int j;
768	769	uint64_t realloc_bm = 0;
769	770	char **data_segments = NULL;
770	771	char **parity_segments = NULL;
	772	int set_chksum = 1;
771	773
772	774	ec_backend_t instance = liberasurecode_backend_instance_get_by_desc(desc);
773	775	if (NULL == instance) {

862	864	}
863	865	init_fragment_header(fragment_ptr);
864	866	add_fragment_metadata(fragment_ptr, destination_idx, orig_data_size,
865		blocksize);
	867	blocksize, !set_chksum);
866	868
867	869	/*
868	870	* Copy the reconstructed fragment to the output buffer

+2

-2

src/erasurecode_helpers.c less more

30	30	#include "erasurecode_backend.h"
31	31	#include "erasurecode_helpers.h"
32	32	#include "erasurecode_stdinc.h"
	33	#include "erasurecode/alg_sig.h"
33	34
34	35	/* ==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~== */
35	36

168	169	int get_aligned_data_size(ec_backend_t instance, int data_len)
169	170	{
170	171	int k = instance->args.uargs.k;
171		int m = instance->args.uargs.m;
172	172	int w = instance->args.uargs.w;
173	173	int word_size = w / 8;
174	174	int alignment_multiple;

340	340
341	341	/* ==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~==~== */
342	342
343		inline int set_chksum(char *buf, int blocksize)
	343	inline int set_checksum(char *buf, int blocksize)
344	344	{
345	345	fragment_header_t* header = (fragment_header_t*) buf;
346	346	char *data = get_data_ptr_from_fragment(buf);

+1

-1

src/erasurecode_postprocessing.c less more

37	37	set_orig_data_size(fragment, orig_data_size);
38	38	set_fragment_payload_size(fragment, blocksize);
39	39	if (add_chksum) {
40		set_chksum(fragment, blocksize);
	40	set_checksum(fragment, blocksize);
41	41	}
42	42	}
43	43

+16

-5

src/utils/chksum/alg_sig.c less more

26	26	#include <stdio.h>
27	27	#include <stdlib.h>
28	28	#include <string.h>
	29	#define GALOIS_SINGLE_MULTIPLY "galois_single_multiply"
29	30
30	31	int valid_gf_w[] = { 8, 16, -1 };
31	32	int valid_pairs[][2] = { { 8, 32}, {16, 32}, {16, 64}, {-1, -1} };
32	33
	34	galois_single_multiply_func get_galois_multi_func(void *handle) {
	35	/*
	36	* ISO C forbids casting a void* to a function pointer.
	37	* Since dlsym return returns a void*, we use this union to
	38	* "transform" the void* to a function pointer.
	39	*/
	40	union {
	41	galois_single_multiply_func fptr;
	42	void *vptr;
	43	} func_handle = {.vptr = NULL};
	44	func_handle.vptr = dlsym(handle, GALOIS_SINGLE_MULTIPLY);
	45	return func_handle.fptr;
	46	}
	47
33	48	void *get_jerasure_sohandle()
34	49	{
35	50	return dlopen(JERASURE_SONAME, RTLD_LAZY \| RTLD_LOCAL);

37	52
38	53	int load_gf_functions(void sohandle, struct jerasure_mult_routines routines)
39	54	{
40		routines->galois_single_multiply = dlsym(sohandle, "galois_single_multiply");
	55	routines->galois_single_multiply = get_galois_multi_func(sohandle);
41	56	if (NULL == routines->galois_single_multiply) {
42	57	return -1;
43	58	}

53	68	int w = 8;
54	69	int alpha = 2, beta = 4, gamma = 8;
55	70	int num_components = sig_len / w;
56		struct jerasure_mult_routines g_jerasure_mult_routines;
57	71
58	72	alg_sig_handle = (alg_sig_t *)malloc(sizeof(alg_sig_t));
59	73	if (NULL == alg_sig_handle) {

225	239	static
226	240	int compute_w8_alg_sig_32(alg_sig_t alg_sig_handle, char buf, int len, char *sig)
227	241	{
228		int bit_mask;
229	242	int i;
230		int alpha = 2, beta = 4, gamma = 8;
231		int w = 8;
232	243
233	244	if (len == 0) {
234	245	bzero(sig, 4);

+5

-5

test/builtin/xor_codes/test_xor_hd_code.c less more

28	28	#include <xor_code.h>
29	29	#include "test_xor_hd_code.h"
30	30
31		void fill_buffer(unsigned char *buf, int size, int seed)
	31	void fill_buffer(char *buf, int size, int seed)
32	32	{
33	33	int i;
34	34

78	78	parity = (char*)malloc(code_desc->m sizeof(char*));
79	79	fragments_needed = (int)malloc(code_desc->kcode_desc->m*sizeof(int));
80	80	if (!fragments_needed) {
81		fprintf(stderr, "Could not allocate memory for fragments %d\n", i);
	81	fprintf(stderr, "Could not allocate memory for fragments\n");
82	82	exit(2);
83	83	}
84	84

177	177
178	178	code_desc->decode(code_desc, data, parity, missing_idxs, blocksize, 1);
179	179
180		if (missing_idxs[0] > -1 && missing_idxs[0] < code_desc->k && check_buffer(data[missing_idx_0], blocksize, missing_idx_0) < 0) {
	180	if (missing_idxs[0] > -1 && missing_idxs[0] < code_desc->k && check_buffer((unsigned char *)data[missing_idx_0], blocksize, missing_idx_0) < 0) {
181	181	fprintf(stderr, "Decode did not work: %d (%d %d %d)!\n", missing_idxs[0], missing_idxs[0], missing_idxs[1], missing_idxs[2]);
182	182	exit(2);
183	183	}
184		if (missing_idxs[1] > -1 && missing_idxs[1] < code_desc->k && check_buffer(data[missing_idx_1], blocksize, missing_idx_1) < 0) {
	184	if (missing_idxs[1] > -1 && missing_idxs[1] < code_desc->k && check_buffer((unsigned char *)data[missing_idx_1], blocksize, missing_idx_1) < 0) {
185	185	fprintf(stderr, "Decode did not work: %d (%d %d %d)!\n", missing_idxs[1], missing_idxs[0], missing_idxs[1], missing_idxs[2]);
186	186	exit(2);
187	187	}
188		if (missing_idxs[2] > -1 && missing_idxs[2] < code_desc->k && check_buffer(data[missing_idx_2], blocksize, missing_idx_2) < 0) {
	188	if (missing_idxs[2] > -1 && missing_idxs[2] < code_desc->k && check_buffer((unsigned char *)data[missing_idx_2], blocksize, missing_idx_2) < 0) {
189	189	fprintf(stderr, "Decode did not work: %d (%d %d %d)!\n", missing_idxs[2], missing_idxs[0], missing_idxs[1], missing_idxs[2]);
190	190	exit(2);
191	191	}

+7

-11

test/libec_slap.c less more

66	66	fprintf(stderr,"\n");
67	67	}
68	68
69		void missing_mask_to_array(unsigned long mask, unsigned int *missing)
	69	void missing_mask_to_array(long mask, int *missing)
70	70	{
71	71	unsigned int i = 0;
72	72	unsigned long pos = 1;

99	99	unsigned int num_frags = 0;
100	100	unsigned long i = 0;
101	101	fragment_header_t *header = NULL;
102		char **ptr = NULL;
103	102	size_t size = (num_data_frags + num_parity_frags) * sizeof(char *);
104	103	char **array = malloc(size);
105	104

141	140	return rc;
142	141	}
143	142
144		static void fill_buffer(unsigned char *buf, size_t size, int seed)
145		{
146		size_t i;
	143	static void fill_buffer(char *buf, size_t size, int seed)
	144	{
	145	int i;
147	146	buf[0] = seed;
148	147
149	148	for (i=1; i < size; i++) {

168	167	char **encoded_parity = NULL;
169	168	uint64_t encoded_fragment_len = 0;
170	169	int rc = 0;
171		int num_fragments = args->k + args->m;
172		char **available_frags = NULL;
173	170	char *out_data = NULL;
174	171	uint64_t out_data_len = 0;
175	172	unsigned long mask = 0;
176	173	int desc = -1;
177		unsigned int num_available_frags = 0;
178	174	struct frag_array_set frags; //MOVE ME
179	175
180	176	srand(time(NULL));

185	181
186	182	fragments_needed = (int)malloc(args->kargs->m*sizeof(int));
187	183	if (!fragments_needed) {
188		fprintf(stderr, "Could not allocate memory for fragments %d\n", i);
	184	fprintf(stderr, "Could not allocate memory for fragments\n");
189	185	exit(2);
190	186	}
191	187	memset(fragments_needed, 0, args->kargs->msizeof(int));
192	188
193	189	err = posix_memalign((void *) &data, 16, blocksize args->k);
194	190	if (err != 0 \|\| !data) {
195		fprintf(stderr, "Could not allocate memory for data %d\n", i);
	191	fprintf(stderr, "Could not allocate memory for data\n");
196	192	exit(1);
197	193	}
198		fill_buffer(data, blocksize * args->k, i);
	194	fill_buffer(data, blocksize * args->k, 0);
199	195
200	196	parity = (char*)malloc(args->m sizeof(char*));
201	197	for (i=0; i < args->m; i++) {

+1

-4

test/liberasurecode_test.c less more

405	405	char *orig_data = NULL;
406	406	char encoded_data = NULL, encoded_parity = NULL;
407	407	uint64_t encoded_fragment_len = 0;
408		int num_fragments = args-> k + args->m;
409	408	uint64_t decoded_data_len = 0;
410	409	char *decoded_data = NULL;
411	410	size_t frag_header_size = sizeof(fragment_header_t);

437	436	assert(metadata.idx == i);
438	437	assert(metadata.size == encoded_fragment_len - frag_header_size);
439	438	assert(metadata.orig_data_size == orig_data_size);
440		unsigned char *data_ptr = frag + frag_header_size;
	439	char *data_ptr = frag + frag_header_size;
441	440	int cmp_size = remaining >= metadata.size ? metadata.size : remaining;
442	441	assert(memcmp(data_ptr, orig_data_ptr, cmp_size) == 0);
443	442	remaining -= cmp_size;

479	478	char encoded_data = NULL, encoded_parity = NULL;
480	479	uint64_t encoded_fragment_len = 0;
481	480	int num_fragments = args-> k + args->m;
482		uint64_t decoded_data_len = 0;
483		char *decoded_data = NULL;
484	481	char **avail_frags = NULL;
485	482	int num_avail_frags = 0;
486	483	int i = 0;

+0

-1

test/utils/chksum/test_alg_sig.c less more

74	74	ret = 1;
75	75	}
76	76
77		out:
78	77	free(parity_sig);
79	78
80	79	return ret;