1 /*-
2 * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 */
27
28 #include <sys/cdefs.h>
29 #include <assert.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include "debug.h"
34 #include "log.h"
35 #include "protocol.h"
36
37 /*
38 * Initializes the comm_element with any given type of data
39 */
40 void
init_comm_element(struct comm_element * element,enum comm_element_t type)41 init_comm_element(struct comm_element *element, enum comm_element_t type)
42 {
43
44 TRACE_IN(init_comm_element);
45 memset(element, 0, sizeof(struct comm_element));
46
47 switch (type) {
48 case CET_WRITE_REQUEST:
49 init_cache_write_request(&element->c_write_request);
50 break;
51 case CET_WRITE_RESPONSE:
52 init_cache_write_response(&element->c_write_response);
53 break;
54 case CET_READ_REQUEST:
55 init_cache_read_request(&element->c_read_request);
56 break;
57 case CET_READ_RESPONSE:
58 init_cache_read_response(&element->c_read_response);
59 break;
60 case CET_TRANSFORM_REQUEST:
61 init_cache_transform_request(&element->c_transform_request);
62 break;
63 case CET_TRANSFORM_RESPONSE:
64 init_cache_transform_response(&element->c_transform_response);
65 break;
66 case CET_MP_WRITE_SESSION_REQUEST:
67 init_cache_mp_write_session_request(&element->c_mp_ws_request);
68 break;
69 case CET_MP_WRITE_SESSION_RESPONSE:
70 init_cache_mp_write_session_response(&element->c_mp_ws_response);
71 break;
72 case CET_MP_WRITE_SESSION_WRITE_REQUEST:
73 init_cache_mp_write_session_write_request(
74 &element->c_mp_ws_write_request);
75 break;
76 case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
77 init_cache_mp_write_session_write_response(
78 &element->c_mp_ws_write_response);
79 break;
80 case CET_MP_READ_SESSION_REQUEST:
81 init_cache_mp_read_session_request(&element->c_mp_rs_request);
82 break;
83 case CET_MP_READ_SESSION_RESPONSE:
84 init_cache_mp_read_session_response(&element->c_mp_rs_response);
85 break;
86 case CET_MP_READ_SESSION_READ_RESPONSE:
87 init_cache_mp_read_session_read_response(
88 &element->c_mp_rs_read_response);
89 break;
90 case CET_UNDEFINED:
91 break;
92 default:
93 LOG_ERR_2("init_comm_element", "invalid communication element");
94 TRACE_OUT(init_comm_element);
95 return;
96 }
97
98 element->type = type;
99 TRACE_OUT(init_comm_element);
100 }
101
102 void
finalize_comm_element(struct comm_element * element)103 finalize_comm_element(struct comm_element *element)
104 {
105
106 TRACE_IN(finalize_comm_element);
107 switch (element->type) {
108 case CET_WRITE_REQUEST:
109 finalize_cache_write_request(&element->c_write_request);
110 break;
111 case CET_WRITE_RESPONSE:
112 finalize_cache_write_response(&element->c_write_response);
113 break;
114 case CET_READ_REQUEST:
115 finalize_cache_read_request(&element->c_read_request);
116 break;
117 case CET_READ_RESPONSE:
118 finalize_cache_read_response(&element->c_read_response);
119 break;
120 case CET_TRANSFORM_REQUEST:
121 finalize_cache_transform_request(&element->c_transform_request);
122 break;
123 case CET_TRANSFORM_RESPONSE:
124 finalize_cache_transform_response(
125 &element->c_transform_response);
126 break;
127 case CET_MP_WRITE_SESSION_REQUEST:
128 finalize_cache_mp_write_session_request(
129 &element->c_mp_ws_request);
130 break;
131 case CET_MP_WRITE_SESSION_RESPONSE:
132 finalize_cache_mp_write_session_response(
133 &element->c_mp_ws_response);
134 break;
135 case CET_MP_WRITE_SESSION_WRITE_REQUEST:
136 finalize_cache_mp_write_session_write_request(
137 &element->c_mp_ws_write_request);
138 break;
139 case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
140 finalize_cache_mp_write_session_write_response(
141 &element->c_mp_ws_write_response);
142 break;
143 case CET_MP_READ_SESSION_REQUEST:
144 finalize_cache_mp_read_session_request(
145 &element->c_mp_rs_request);
146 break;
147 case CET_MP_READ_SESSION_RESPONSE:
148 finalize_cache_mp_read_session_response(
149 &element->c_mp_rs_response);
150 break;
151 case CET_MP_READ_SESSION_READ_RESPONSE:
152 finalize_cache_mp_read_session_read_response(
153 &element->c_mp_rs_read_response);
154 break;
155 case CET_UNDEFINED:
156 break;
157 default:
158 break;
159 }
160
161 element->type = CET_UNDEFINED;
162 TRACE_OUT(finalize_comm_element);
163 }
164
165 void
init_cache_write_request(struct cache_write_request * write_request)166 init_cache_write_request(struct cache_write_request *write_request)
167 {
168
169 TRACE_IN(init_cache_write_request);
170 memset(write_request, 0, sizeof(struct cache_write_request));
171 TRACE_OUT(init_cache_write_request);
172 }
173
174 void
finalize_cache_write_request(struct cache_write_request * write_request)175 finalize_cache_write_request(struct cache_write_request *write_request)
176 {
177
178 TRACE_IN(finalize_cache_write_request);
179 free(write_request->entry);
180 free(write_request->cache_key);
181 free(write_request->data);
182 TRACE_OUT(finalize_cache_write_request);
183 }
184
185 struct cache_write_request *
get_cache_write_request(struct comm_element * element)186 get_cache_write_request(struct comm_element *element)
187 {
188
189 TRACE_IN(get_cache_write_request);
190 assert(element->type == CET_WRITE_REQUEST);
191 TRACE_OUT(get_cache_write_request);
192 return (&element->c_write_request);
193 }
194
195 void
init_cache_write_response(struct cache_write_response * write_response)196 init_cache_write_response(struct cache_write_response *write_response)
197 {
198
199 TRACE_IN(init_cache_write_response);
200 memset(write_response, 0, sizeof(struct cache_write_response));
201 TRACE_OUT(init_cache_write_response);
202 }
203
204 void
finalize_cache_write_response(struct cache_write_response * write_response)205 finalize_cache_write_response(struct cache_write_response *write_response)
206 {
207
208 TRACE_IN(finalize_cache_write_response);
209 TRACE_OUT(finalize_cache_write_response);
210 }
211
212 struct cache_write_response *
get_cache_write_response(struct comm_element * element)213 get_cache_write_response(struct comm_element *element)
214 {
215
216 TRACE_IN(get_cache_write_response);
217 assert(element->type == CET_WRITE_RESPONSE);
218 TRACE_OUT(get_cache_write_response);
219 return (&element->c_write_response);
220 }
221
222 void
init_cache_read_request(struct cache_read_request * read_request)223 init_cache_read_request(struct cache_read_request *read_request)
224 {
225
226 TRACE_IN(init_cache_read_request);
227 memset(read_request, 0, sizeof(struct cache_read_request));
228 TRACE_OUT(init_cache_read_request);
229 }
230
231 void
finalize_cache_read_request(struct cache_read_request * read_request)232 finalize_cache_read_request(struct cache_read_request *read_request)
233 {
234
235 TRACE_IN(finalize_cache_read_request);
236 free(read_request->entry);
237 free(read_request->cache_key);
238 TRACE_OUT(finalize_cache_read_request);
239 }
240
241 struct cache_read_request *
get_cache_read_request(struct comm_element * element)242 get_cache_read_request(struct comm_element *element)
243 {
244
245 TRACE_IN(get_cache_read_request);
246 assert(element->type == CET_READ_REQUEST);
247 TRACE_OUT(get_cache_read_request);
248 return (&element->c_read_request);
249 }
250
251 void
init_cache_read_response(struct cache_read_response * read_response)252 init_cache_read_response(struct cache_read_response *read_response)
253 {
254
255 TRACE_IN(init_cache_read_response);
256 memset(read_response, 0, sizeof(struct cache_read_response));
257 TRACE_OUT(init_cache_read_response);
258 }
259
260 void
finalize_cache_read_response(struct cache_read_response * read_response)261 finalize_cache_read_response(struct cache_read_response *read_response)
262 {
263
264 TRACE_IN(finalize_cache_read_response);
265 free(read_response->data);
266 TRACE_OUT(finalize_cache_read_response);
267 }
268
269 struct cache_read_response *
get_cache_read_response(struct comm_element * element)270 get_cache_read_response(struct comm_element *element)
271 {
272
273 TRACE_IN(get_cache_read_response);
274 assert(element->type == CET_READ_RESPONSE);
275 TRACE_OUT(get_cache_read_response);
276 return (&element->c_read_response);
277 }
278
279 void
init_cache_transform_request(struct cache_transform_request * transform_request)280 init_cache_transform_request(struct cache_transform_request *transform_request)
281 {
282
283 TRACE_IN(init_cache_transform_request);
284 memset(transform_request, 0, sizeof(struct cache_transform_request));
285 TRACE_OUT(init_cache_transform_request);
286 }
287
288 void
finalize_cache_transform_request(struct cache_transform_request * transform_request)289 finalize_cache_transform_request(
290 struct cache_transform_request *transform_request)
291 {
292
293 TRACE_IN(finalize_cache_transform_request);
294 free(transform_request->entry);
295 TRACE_OUT(finalize_cache_transform_request);
296 }
297
298 struct cache_transform_request *
get_cache_transform_request(struct comm_element * element)299 get_cache_transform_request(struct comm_element *element)
300 {
301
302 TRACE_IN(get_cache_transform_request);
303 assert(element->type == CET_TRANSFORM_REQUEST);
304 TRACE_OUT(get_cache_transform_request);
305 return (&element->c_transform_request);
306 }
307
308 void
init_cache_transform_response(struct cache_transform_response * transform_response)309 init_cache_transform_response(
310 struct cache_transform_response *transform_response)
311 {
312
313 TRACE_IN(init_cache_transform_request);
314 memset(transform_response, 0, sizeof(struct cache_transform_response));
315 TRACE_OUT(init_cache_transform_request);
316 }
317
318 void
finalize_cache_transform_response(struct cache_transform_response * transform_response)319 finalize_cache_transform_response(
320 struct cache_transform_response *transform_response)
321 {
322
323 TRACE_IN(finalize_cache_transform_response);
324 TRACE_OUT(finalize_cache_transform_response);
325 }
326
327 struct cache_transform_response *
get_cache_transform_response(struct comm_element * element)328 get_cache_transform_response(struct comm_element *element)
329 {
330
331 TRACE_IN(get_cache_transform_response);
332 assert(element->type == CET_TRANSFORM_RESPONSE);
333 TRACE_OUT(get_cache_transform_response);
334 return (&element->c_transform_response);
335 }
336
337
338 void
init_cache_mp_write_session_request(struct cache_mp_write_session_request * mp_ws_request)339 init_cache_mp_write_session_request(
340 struct cache_mp_write_session_request *mp_ws_request)
341 {
342
343 TRACE_IN(init_cache_mp_write_session_request);
344 memset(mp_ws_request, 0,
345 sizeof(struct cache_mp_write_session_request));
346 TRACE_OUT(init_cache_mp_write_session_request);
347 }
348
349 void
finalize_cache_mp_write_session_request(struct cache_mp_write_session_request * mp_ws_request)350 finalize_cache_mp_write_session_request(
351 struct cache_mp_write_session_request *mp_ws_request)
352 {
353
354 TRACE_IN(finalize_cache_mp_write_session_request);
355 free(mp_ws_request->entry);
356 TRACE_OUT(finalize_cache_mp_write_session_request);
357 }
358
359 struct cache_mp_write_session_request *
get_cache_mp_write_session_request(struct comm_element * element)360 get_cache_mp_write_session_request(struct comm_element *element)
361 {
362
363 TRACE_IN(get_cache_mp_write_session_request);
364 assert(element->type == CET_MP_WRITE_SESSION_REQUEST);
365 TRACE_OUT(get_cache_mp_write_session_request);
366 return (&element->c_mp_ws_request);
367 }
368
369 void
init_cache_mp_write_session_response(struct cache_mp_write_session_response * mp_ws_response)370 init_cache_mp_write_session_response(
371 struct cache_mp_write_session_response *mp_ws_response)
372 {
373
374 TRACE_IN(init_cache_mp_write_session_response);
375 memset(mp_ws_response, 0,
376 sizeof(struct cache_mp_write_session_response));
377 TRACE_OUT(init_cache_mp_write_session_response);
378 }
379
380 void
finalize_cache_mp_write_session_response(struct cache_mp_write_session_response * mp_ws_response)381 finalize_cache_mp_write_session_response(
382 struct cache_mp_write_session_response *mp_ws_response)
383 {
384
385 TRACE_IN(finalize_cache_mp_write_session_response);
386 TRACE_OUT(finalize_cache_mp_write_session_response);
387 }
388
389 struct cache_mp_write_session_response *
get_cache_mp_write_session_response(struct comm_element * element)390 get_cache_mp_write_session_response(struct comm_element *element)
391 {
392
393 TRACE_IN(get_cache_mp_write_session_response);
394 assert(element->type == CET_MP_WRITE_SESSION_RESPONSE);
395 TRACE_OUT(get_cache_mp_write_session_response);
396 return (&element->c_mp_ws_response);
397 }
398
399 void
init_cache_mp_write_session_write_request(struct cache_mp_write_session_write_request * mp_ws_write_request)400 init_cache_mp_write_session_write_request(
401 struct cache_mp_write_session_write_request *mp_ws_write_request)
402 {
403
404 TRACE_IN(init_cache_mp_write_session_write_request);
405 memset(mp_ws_write_request, 0,
406 sizeof(struct cache_mp_write_session_write_request));
407 TRACE_OUT(init_cache_mp_write_session_write_response);
408 }
409
410 void
finalize_cache_mp_write_session_write_request(struct cache_mp_write_session_write_request * mp_ws_write_request)411 finalize_cache_mp_write_session_write_request(
412 struct cache_mp_write_session_write_request *mp_ws_write_request)
413 {
414
415 TRACE_IN(finalize_cache_mp_write_session_write_request);
416 free(mp_ws_write_request->data);
417 TRACE_OUT(finalize_cache_mp_write_session_write_request);
418 }
419
420 struct cache_mp_write_session_write_request *
get_cache_mp_write_session_write_request(struct comm_element * element)421 get_cache_mp_write_session_write_request(struct comm_element *element)
422 {
423
424 TRACE_IN(get_cache_mp_write_session_write_request);
425 assert(element->type == CET_MP_WRITE_SESSION_WRITE_REQUEST);
426 TRACE_OUT(get_cache_mp_write_session_write_request);
427 return (&element->c_mp_ws_write_request);
428 }
429
430 void
init_cache_mp_write_session_write_response(struct cache_mp_write_session_write_response * mp_ws_write_response)431 init_cache_mp_write_session_write_response(
432 struct cache_mp_write_session_write_response *mp_ws_write_response)
433 {
434
435 TRACE_IN(init_cache_mp_write_session_write_response);
436 memset(mp_ws_write_response, 0,
437 sizeof(struct cache_mp_write_session_write_response));
438 TRACE_OUT(init_cache_mp_write_session_write_response);
439 }
440
441 void
finalize_cache_mp_write_session_write_response(struct cache_mp_write_session_write_response * mp_ws_write_response)442 finalize_cache_mp_write_session_write_response(
443 struct cache_mp_write_session_write_response *mp_ws_write_response)
444 {
445
446 TRACE_IN(finalize_cache_mp_write_session_write_response);
447 TRACE_OUT(finalize_cache_mp_write_session_write_response);
448 }
449
450 struct cache_mp_write_session_write_response *
get_cache_mp_write_session_write_response(struct comm_element * element)451 get_cache_mp_write_session_write_response(struct comm_element *element)
452 {
453
454 TRACE_IN(get_cache_mp_write_session_write_response);
455 assert(element->type == CET_MP_WRITE_SESSION_WRITE_RESPONSE);
456 TRACE_OUT(get_cache_mp_write_session_write_response);
457 return (&element->c_mp_ws_write_response);
458 }
459
460 void
init_cache_mp_read_session_request(struct cache_mp_read_session_request * mp_rs_request)461 init_cache_mp_read_session_request(
462 struct cache_mp_read_session_request *mp_rs_request)
463 {
464
465 TRACE_IN(init_cache_mp_read_session_request);
466 memset(mp_rs_request, 0, sizeof(struct cache_mp_read_session_request));
467 TRACE_OUT(init_cache_mp_read_session_request);
468 }
469
470 void
finalize_cache_mp_read_session_request(struct cache_mp_read_session_request * mp_rs_request)471 finalize_cache_mp_read_session_request(
472 struct cache_mp_read_session_request *mp_rs_request)
473 {
474
475 TRACE_IN(finalize_cache_mp_read_session_request);
476 free(mp_rs_request->entry);
477 TRACE_OUT(finalize_cache_mp_read_session_request);
478 }
479
480 struct cache_mp_read_session_request *
get_cache_mp_read_session_request(struct comm_element * element)481 get_cache_mp_read_session_request(struct comm_element *element)
482 {
483
484 TRACE_IN(get_cache_mp_read_session_request);
485 assert(element->type == CET_MP_READ_SESSION_REQUEST);
486 TRACE_OUT(get_cache_mp_read_session_request);
487 return (&element->c_mp_rs_request);
488 }
489
490 void
init_cache_mp_read_session_response(struct cache_mp_read_session_response * mp_rs_response)491 init_cache_mp_read_session_response(
492 struct cache_mp_read_session_response *mp_rs_response)
493 {
494
495 TRACE_IN(init_cache_mp_read_session_response);
496 memset(mp_rs_response, 0,
497 sizeof(struct cache_mp_read_session_response));
498 TRACE_OUT(init_cache_mp_read_session_response);
499 }
500
501 void
finalize_cache_mp_read_session_response(struct cache_mp_read_session_response * mp_rs_response)502 finalize_cache_mp_read_session_response(
503 struct cache_mp_read_session_response *mp_rs_response)
504 {
505
506 TRACE_IN(finalize_cache_mp_read_session_response);
507 TRACE_OUT(finalize_cache_mp_read_session_response);
508 }
509
510 struct cache_mp_read_session_response *
get_cache_mp_read_session_response(struct comm_element * element)511 get_cache_mp_read_session_response(struct comm_element *element)
512 {
513
514 TRACE_IN(get_cache_mp_read_session_response);
515 assert(element->type == CET_MP_READ_SESSION_RESPONSE);
516 TRACE_OUT(get_cache_mp_read_session_response);
517 return (&element->c_mp_rs_response);
518 }
519
520 void
init_cache_mp_read_session_read_response(struct cache_mp_read_session_read_response * mp_ws_read_response)521 init_cache_mp_read_session_read_response(
522 struct cache_mp_read_session_read_response *mp_ws_read_response)
523 {
524
525 TRACE_IN(init_cache_mp_read_session_read_response);
526 memset(mp_ws_read_response, 0,
527 sizeof(struct cache_mp_read_session_read_response));
528 TRACE_OUT(init_cache_mp_read_session_read_response);
529 }
530
531 void
finalize_cache_mp_read_session_read_response(struct cache_mp_read_session_read_response * mp_rs_read_response)532 finalize_cache_mp_read_session_read_response(
533 struct cache_mp_read_session_read_response *mp_rs_read_response)
534 {
535
536 TRACE_IN(finalize_cache_mp_read_session_read_response);
537 free(mp_rs_read_response->data);
538 TRACE_OUT(finalize_cache_mp_read_session_read_response);
539 }
540
541 struct cache_mp_read_session_read_response *
get_cache_mp_read_session_read_response(struct comm_element * element)542 get_cache_mp_read_session_read_response(struct comm_element *element)
543 {
544
545 TRACE_IN(get_cache_mp_read_session_read_response);
546 assert(element->type == CET_MP_READ_SESSION_READ_RESPONSE);
547 TRACE_OUT(get_cache_mp_read_session_read_response);
548 return (&element->c_mp_rs_read_response);
549 }
550