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