2 * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
40 * Initializes the comm_element with any given type of data
43 init_comm_element(struct comm_element *element, enum comm_element_t type)
46 TRACE_IN(init_comm_element);
47 memset(element, 0, sizeof(struct comm_element));
50 case CET_WRITE_REQUEST:
51 init_cache_write_request(&element->c_write_request);
53 case CET_WRITE_RESPONSE:
54 init_cache_write_response(&element->c_write_response);
56 case CET_READ_REQUEST:
57 init_cache_read_request(&element->c_read_request);
59 case CET_READ_RESPONSE:
60 init_cache_read_response(&element->c_read_response);
62 case CET_TRANSFORM_REQUEST:
63 init_cache_transform_request(&element->c_transform_request);
65 case CET_TRANSFORM_RESPONSE:
66 init_cache_transform_response(&element->c_transform_response);
68 case CET_MP_WRITE_SESSION_REQUEST:
69 init_cache_mp_write_session_request(&element->c_mp_ws_request);
71 case CET_MP_WRITE_SESSION_RESPONSE:
72 init_cache_mp_write_session_response(&element->c_mp_ws_response);
74 case CET_MP_WRITE_SESSION_WRITE_REQUEST:
75 init_cache_mp_write_session_write_request(
76 &element->c_mp_ws_write_request);
78 case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
79 init_cache_mp_write_session_write_response(
80 &element->c_mp_ws_write_response);
82 case CET_MP_READ_SESSION_REQUEST:
83 init_cache_mp_read_session_request(&element->c_mp_rs_request);
85 case CET_MP_READ_SESSION_RESPONSE:
86 init_cache_mp_read_session_response(&element->c_mp_rs_response);
88 case CET_MP_READ_SESSION_READ_RESPONSE:
89 init_cache_mp_read_session_read_response(
90 &element->c_mp_rs_read_response);
95 LOG_ERR_2("init_comm_element", "invalid communication element");
96 TRACE_OUT(init_comm_element);
100 element->type = type;
101 TRACE_OUT(init_comm_element);
105 finalize_comm_element(struct comm_element *element)
108 TRACE_IN(finalize_comm_element);
109 switch (element->type) {
110 case CET_WRITE_REQUEST:
111 finalize_cache_write_request(&element->c_write_request);
113 case CET_WRITE_RESPONSE:
114 finalize_cache_write_response(&element->c_write_response);
116 case CET_READ_REQUEST:
117 finalize_cache_read_request(&element->c_read_request);
119 case CET_READ_RESPONSE:
120 finalize_cache_read_response(&element->c_read_response);
122 case CET_TRANSFORM_REQUEST:
123 finalize_cache_transform_request(&element->c_transform_request);
125 case CET_TRANSFORM_RESPONSE:
126 finalize_cache_transform_response(
127 &element->c_transform_response);
129 case CET_MP_WRITE_SESSION_REQUEST:
130 finalize_cache_mp_write_session_request(
131 &element->c_mp_ws_request);
133 case CET_MP_WRITE_SESSION_RESPONSE:
134 finalize_cache_mp_write_session_response(
135 &element->c_mp_ws_response);
137 case CET_MP_WRITE_SESSION_WRITE_REQUEST:
138 finalize_cache_mp_write_session_write_request(
139 &element->c_mp_ws_write_request);
141 case CET_MP_WRITE_SESSION_WRITE_RESPONSE:
142 finalize_cache_mp_write_session_write_response(
143 &element->c_mp_ws_write_response);
145 case CET_MP_READ_SESSION_REQUEST:
146 finalize_cache_mp_read_session_request(
147 &element->c_mp_rs_request);
149 case CET_MP_READ_SESSION_RESPONSE:
150 finalize_cache_mp_read_session_response(
151 &element->c_mp_rs_response);
153 case CET_MP_READ_SESSION_READ_RESPONSE:
154 finalize_cache_mp_read_session_read_response(
155 &element->c_mp_rs_read_response);
163 element->type = CET_UNDEFINED;
164 TRACE_OUT(finalize_comm_element);
168 init_cache_write_request(struct cache_write_request *write_request)
171 TRACE_IN(init_cache_write_request);
172 memset(write_request, 0, sizeof(struct cache_write_request));
173 TRACE_OUT(init_cache_write_request);
177 finalize_cache_write_request(struct cache_write_request *write_request)
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);
187 struct cache_write_request *
188 get_cache_write_request(struct comm_element *element)
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);
198 init_cache_write_response(struct cache_write_response *write_response)
201 TRACE_IN(init_cache_write_response);
202 memset(write_response, 0, sizeof(struct cache_write_response));
203 TRACE_OUT(init_cache_write_response);
207 finalize_cache_write_response(struct cache_write_response *write_response)
210 TRACE_IN(finalize_cache_write_response);
211 TRACE_OUT(finalize_cache_write_response);
214 struct cache_write_response *
215 get_cache_write_response(struct comm_element *element)
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);
225 init_cache_read_request(struct cache_read_request *read_request)
228 TRACE_IN(init_cache_read_request);
229 memset(read_request, 0, sizeof(struct cache_read_request));
230 TRACE_OUT(init_cache_read_request);
234 finalize_cache_read_request(struct cache_read_request *read_request)
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);
243 struct cache_read_request *
244 get_cache_read_request(struct comm_element *element)
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);
254 init_cache_read_response(struct cache_read_response *read_response)
257 TRACE_IN(init_cache_read_response);
258 memset(read_response, 0, sizeof(struct cache_read_response));
259 TRACE_OUT(init_cache_read_response);
263 finalize_cache_read_response(struct cache_read_response *read_response)
266 TRACE_IN(finalize_cache_read_response);
267 free(read_response->data);
268 TRACE_OUT(finalize_cache_read_response);
271 struct cache_read_response *
272 get_cache_read_response(struct comm_element *element)
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);
282 init_cache_transform_request(struct cache_transform_request *transform_request)
285 TRACE_IN(init_cache_transform_request);
286 memset(transform_request, 0, sizeof(struct cache_transform_request));
287 TRACE_OUT(init_cache_transform_request);
291 finalize_cache_transform_request(
292 struct cache_transform_request *transform_request)
295 TRACE_IN(finalize_cache_transform_request);
296 free(transform_request->entry);
297 TRACE_OUT(finalize_cache_transform_request);
300 struct cache_transform_request *
301 get_cache_transform_request(struct comm_element *element)
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);
311 init_cache_transform_response(
312 struct cache_transform_response *transform_response)
315 TRACE_IN(init_cache_transform_request);
316 memset(transform_response, 0, sizeof(struct cache_transform_response));
317 TRACE_OUT(init_cache_transform_request);
321 finalize_cache_transform_response(
322 struct cache_transform_response *transform_response)
325 TRACE_IN(finalize_cache_transform_response);
326 TRACE_OUT(finalize_cache_transform_response);
329 struct cache_transform_response *
330 get_cache_transform_response(struct comm_element *element)
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);
341 init_cache_mp_write_session_request(
342 struct cache_mp_write_session_request *mp_ws_request)
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);
352 finalize_cache_mp_write_session_request(
353 struct cache_mp_write_session_request *mp_ws_request)
356 TRACE_IN(finalize_cache_mp_write_session_request);
357 free(mp_ws_request->entry);
358 TRACE_OUT(finalize_cache_mp_write_session_request);
361 struct cache_mp_write_session_request *
362 get_cache_mp_write_session_request(struct comm_element *element)
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);
372 init_cache_mp_write_session_response(
373 struct cache_mp_write_session_response *mp_ws_response)
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);
383 finalize_cache_mp_write_session_response(
384 struct cache_mp_write_session_response *mp_ws_response)
387 TRACE_IN(finalize_cache_mp_write_session_response);
388 TRACE_OUT(finalize_cache_mp_write_session_response);
391 struct cache_mp_write_session_response *
392 get_cache_mp_write_session_response(struct comm_element *element)
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);
402 init_cache_mp_write_session_write_request(
403 struct cache_mp_write_session_write_request *mp_ws_write_request)
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);
413 finalize_cache_mp_write_session_write_request(
414 struct cache_mp_write_session_write_request *mp_ws_write_request)
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);
422 struct cache_mp_write_session_write_request *
423 get_cache_mp_write_session_write_request(struct comm_element *element)
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);
433 init_cache_mp_write_session_write_response(
434 struct cache_mp_write_session_write_response *mp_ws_write_response)
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);
444 finalize_cache_mp_write_session_write_response(
445 struct cache_mp_write_session_write_response *mp_ws_write_response)
448 TRACE_IN(finalize_cache_mp_write_session_write_response);
449 TRACE_OUT(finalize_cache_mp_write_session_write_response);
452 struct cache_mp_write_session_write_response *
453 get_cache_mp_write_session_write_response(struct comm_element *element)
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);
463 init_cache_mp_read_session_request(
464 struct cache_mp_read_session_request *mp_rs_request)
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);
473 finalize_cache_mp_read_session_request(
474 struct cache_mp_read_session_request *mp_rs_request)
477 TRACE_IN(finalize_cache_mp_read_session_request);
478 free(mp_rs_request->entry);
479 TRACE_OUT(finalize_cache_mp_read_session_request);
482 struct cache_mp_read_session_request *
483 get_cache_mp_read_session_request(struct comm_element *element)
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);
493 init_cache_mp_read_session_response(
494 struct cache_mp_read_session_response *mp_rs_response)
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);
504 finalize_cache_mp_read_session_response(
505 struct cache_mp_read_session_response *mp_rs_response)
508 TRACE_IN(finalize_cache_mp_read_session_response);
509 TRACE_OUT(finalize_cache_mp_read_session_response);
512 struct cache_mp_read_session_response *
513 get_cache_mp_read_session_response(struct comm_element *element)
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);
523 init_cache_mp_read_session_read_response(
524 struct cache_mp_read_session_read_response *mp_ws_read_response)
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);
534 finalize_cache_mp_read_session_read_response(
535 struct cache_mp_read_session_read_response *mp_rs_read_response)
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);
543 struct cache_mp_read_session_read_response *
544 get_cache_mp_read_session_read_response(struct comm_element *element)
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);