1 /*
2 * Copyright (c) 2004-2008 Voltaire, Inc. All rights reserved.
3 * Copyright (c) 2002-2005 Mellanox Technologies LTD. All rights reserved.
4 * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.
5 *
6 * This software is available to you under a choice of one of two
7 * licenses. You may choose to be licensed under the terms of the GNU
8 * General Public License (GPL) Version 2, available from the file
9 * COPYING in the main directory of this source tree, or the
10 * OpenIB.org BSD license below:
11 *
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
14 * conditions are met:
15 *
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
18 * disclaimer.
19 *
20 * - Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials
23 * provided with the distribution.
24 *
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 * SOFTWARE.
33 *
34 */
35
36 #if HAVE_CONFIG_H
37 # include <config.h>
38 #endif /* HAVE_CONFIG_H */
39
40 #include <math.h>
41 #include <stdlib.h>
42 #include <opensm/osm_helper.h>
43 #include <opensm/osm_log.h>
44 #include <vendor/osm_vendor.h>
45 #include <vendor/osm_vendor_api.h>
46 #include <opensm/osm_mad_pool.h>
47
48 #if defined(OSM_VENDOR_INTF_MTL) | defined(OSM_VENDOR_INTF_TS)
49
50 #include <vendor/osm_vendor_mtl_transaction_mgr.h>
51 #ifdef OSM_VENDOR_INTF_MTL
52 #include <vendor/osm_mtl_bind.h>
53 #endif
54
55 /* this is the callback function of the timer */
__osm_transaction_mgr_callback(IN void * context)56 void __osm_transaction_mgr_callback(IN void *context)
57 {
58 osm_transaction_mgr_t *trans_mgr_p;
59 osm_vendor_t *p_vend = (osm_vendor_t *) context;
60 cl_list_item_t *p_list_item;
61 cl_list_item_t *p_list_next_item;
62 osm_madw_req_t *osm_madw_req_p;
63 uint64_t current_time; /* [usec] */
64 uint32_t new_timeout; /* [msec] */
65 cl_status_t cl_status;
66 ib_mad_t *p_mad;
67 #ifdef OSM_VENDOR_INTF_MTL
68 osm_mtl_bind_info_t *p_bind;
69 #else
70 osm_ts_bind_info_t *p_bind;
71 #endif
72 cl_list_t tmp_madw_p_list; /* this list will include all the madw_p that should be removed. */
73 cl_list_t retry_madw_p_list; /* this list will include all the madw_p that were retried and need to be removed. */
74 osm_madw_t *madw_p;
75
76 OSM_LOG_ENTER(p_vend->p_log);
77
78 trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
79
80 /* initialize the tmp_madw_p_list */
81 cl_list_construct(&tmp_madw_p_list);
82 cl_status = cl_list_init(&tmp_madw_p_list, 50);
83 if (cl_status != CL_SUCCESS) {
84 osm_log(p_vend->p_log, OSM_LOG_ERROR,
85 "__osm_transaction_mgr_callback : ERROR 1000: "
86 "Failed to create tmp_madw_p_list\n");
87 }
88
89 cl_list_construct(&retry_madw_p_list);
90 cl_status = cl_list_init(&retry_madw_p_list, 50);
91 if (cl_status != CL_SUCCESS) {
92 osm_log(p_vend->p_log, OSM_LOG_ERROR,
93 "__osm_transaction_mgr_callback : ERROR 1000: "
94 "Failed to create retry_madw_p_list\n");
95 }
96
97 current_time = cl_get_time_stamp();
98 cl_spinlock_acquire(&(trans_mgr_p->transaction_mgr_lock));
99 p_list_item = cl_qlist_head(trans_mgr_p->madw_reqs_list_p);
100 if (p_list_item == cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
101 /* the list is empty - nothing to do */
102 cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
103 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
104 "__osm_transaction_mgr_callback : Nothing to do\n");
105 goto Exit;
106 }
107
108 /* non empty list: */
109
110 /* get the osm_madw_req_p */
111 osm_madw_req_p = PARENT_STRUCT(p_list_item, osm_madw_req_t, list_item);
112
113 while (osm_madw_req_p->waking_time <= current_time) {
114 /* this object was supposed to have gotten a response */
115 /* we need to decide if we need to retry or done with it. */
116 if (osm_madw_req_p->retry_cnt > 0) {
117 /* add to the list of the retrys : */
118 cl_list_insert_tail(&retry_madw_p_list, osm_madw_req_p);
119
120 /* update wakeup time and retry count */
121 osm_madw_req_p->waking_time =
122 p_vend->timeout * 1000 + cl_get_time_stamp();
123 osm_madw_req_p->retry_cnt--;
124
125 /* make sure we will get some timer call if not earlier */
126 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
127 "__osm_transaction_mgr_callback : Timer restart:%u\n",
128 p_vend->timeout);
129
130 cl_status =
131 cl_timer_start(&trans_mgr_p->madw_list_timer,
132 p_vend->timeout);
133
134 /* go to the next object and check if it also needs to be removed - didn't receive response */
135 /* we need to do it before we move current item to the end of the list */
136 p_list_next_item = cl_qlist_next(p_list_item);
137
138 /* remove from the head */
139 cl_qlist_remove_item(trans_mgr_p->madw_reqs_list_p,
140 &(osm_madw_req_p->list_item));
141
142 /* insert the object to the qlist and the qmap */
143 cl_qlist_insert_tail(trans_mgr_p->madw_reqs_list_p,
144 &(osm_madw_req_p->list_item));
145
146 } else {
147 /* go to the next object and check if it also needs to be removed - didn't receive response */
148 p_list_next_item = cl_qlist_next(p_list_item);
149
150 /* remove from the head */
151 cl_qlist_remove_item(trans_mgr_p->madw_reqs_list_p,
152 &(osm_madw_req_p->list_item));
153
154 /* add it to the tmp_madw_p_list to be removed */
155 cl_list_insert_tail(&tmp_madw_p_list,
156 osm_madw_req_p->p_madw);
157 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
158 "__osm_transaction_mgr_callback : Found failed transaction madw: %p\n",
159 osm_madw_req_p->p_madw);
160 }
161
162 /* Advance */
163 p_list_item = p_list_next_item;
164 if (p_list_item == cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
165 /* the list is empty - nothing to do */
166 break;
167 }
168
169 /* get the osm_madw_req_p */
170 osm_madw_req_p =
171 PARENT_STRUCT(p_list_item, osm_madw_req_t, list_item);
172 }
173
174 /* look at the current p_list_item. If it is not the end item - then we need to */
175 /* re-start the timer */
176 if (p_list_item != cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
177 /* get the osm_madw_req_p */
178 osm_madw_req_p =
179 PARENT_STRUCT(p_list_item, osm_madw_req_t, list_item);
180
181 /* we have the object that still didn't get response - re-start the timer */
182 /* start the timer to the timeout (in miliseconds) */
183 new_timeout =
184 (osm_madw_req_p->waking_time - cl_get_time_stamp()) / 1000 +
185 1;
186 cl_status =
187 cl_timer_start(&trans_mgr_p->madw_list_timer, new_timeout);
188 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
189 "__osm_transaction_mgr_callback : Timer restart:%u\n",
190 new_timeout);
191
192 if (cl_status != CL_SUCCESS) {
193 osm_log(p_vend->p_log, OSM_LOG_ERROR,
194 "__osm_transaction_mgr_callback : ERROR 1000: "
195 "Failed to start timer\n");
196 }
197 }
198 /* if not empty - retry on retry list: */
199 if (!cl_is_list_empty(&retry_madw_p_list)) {
200
201 /* remove all elements that were retried: */
202 osm_madw_req_p =
203 (osm_madw_req_t
204 *) (cl_list_remove_head(&retry_madw_p_list));
205 while (osm_madw_req_p != NULL) {
206
207 /* resend: */
208 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
209 "__osm_transaction_mgr_callback : "
210 "Retry %d of madw %p\n",
211 OSM_DEFAULT_RETRY_COUNT -
212 osm_madw_req_p->retry_cnt,
213 osm_madw_req_p->p_madw);
214
215 /* actually send it */
216 #ifdef OSM_VENDOR_INTF_MTL
217 osm_mtl_send_mad((osm_mtl_bind_info_t *)
218 osm_madw_req_p->p_bind,
219 osm_madw_req_p->p_madw);
220 #else
221 ib_api_status_t
222 osm_ts_send_mad(osm_ts_bind_info_t * p_bind,
223 osm_madw_t * const p_madw);
224 osm_ts_send_mad((osm_ts_bind_info_t *) osm_madw_req_p->
225 p_bind, osm_madw_req_p->p_madw);
226 #endif
227 /* next one */
228 osm_madw_req_p =
229 (osm_madw_req_t
230 *) (cl_list_remove_head(&retry_madw_p_list));
231 }
232 }
233
234 /* if the tmp_madw_p_list has elements - need to call the send_err_callback */
235 madw_p = (osm_madw_t *) (cl_list_remove_head(&tmp_madw_p_list));
236 while (madw_p != NULL) {
237 /* need to remove it from pool */
238
239 /* obtain the madw_p stored as the wrid in the send call */
240 p_mad = osm_madw_get_mad_ptr(madw_p);
241 p_bind = madw_p->h_bind;
242 /*
243 Return any wrappers to the pool that may have been
244 pre-emptively allocated to handle a receive.
245 */
246 if (madw_p->vend_wrap.p_resp_madw) {
247 #ifdef OSM_VENDOR_INTF_MTL
248 osm_mad_pool_put(p_bind->p_osm_pool,
249 madw_p->vend_wrap.p_resp_madw);
250 #else
251 osm_mad_pool_put(p_bind->p_osm_pool,
252 madw_p->vend_wrap.p_resp_madw);
253 #endif
254 madw_p->vend_wrap.p_resp_madw = NULL;
255 }
256
257 /* invoke the CB */
258 (*(osm_vend_mad_send_err_callback_t)
259 (p_bind->send_err_callback)) (p_bind->client_context, madw_p);
260 madw_p = (osm_madw_t *) (cl_list_remove_head(&tmp_madw_p_list));
261 }
262
263 Exit:
264 OSM_LOG_EXIT(p_vend->p_log);
265
266 }
267
268 /*
269 * Construct and Initialize
270 */
271
osm_transaction_mgr_init(IN osm_vendor_t * const p_vend)272 void osm_transaction_mgr_init(IN osm_vendor_t * const p_vend)
273 {
274 cl_status_t cl_status;
275 osm_transaction_mgr_t *trans_mgr_p;
276 OSM_LOG_ENTER(p_vend->p_log);
277
278 CL_ASSERT(p_vend->p_transaction_mgr == NULL);
279
280 (osm_transaction_mgr_t *) p_vend->p_transaction_mgr =
281 (osm_transaction_mgr_t *) malloc(sizeof(osm_transaction_mgr_t));
282
283 trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
284
285 /* construct lock object */
286 cl_spinlock_construct(&(trans_mgr_p->transaction_mgr_lock));
287 CL_ASSERT(cl_spinlock_init(&(trans_mgr_p->transaction_mgr_lock)) ==
288 CL_SUCCESS);
289
290 /* initialize the qlist */
291 trans_mgr_p->madw_reqs_list_p =
292 (cl_qlist_t *) malloc(sizeof(cl_qlist_t));
293 cl_qlist_init(trans_mgr_p->madw_reqs_list_p);
294
295 /* initialize the qmap */
296 trans_mgr_p->madw_by_tid_map_p =
297 (cl_qmap_t *) malloc(sizeof(cl_qmap_t));
298 cl_qmap_init(trans_mgr_p->madw_by_tid_map_p);
299
300 /* create the timer used by the madw_req_list */
301 cl_timer_construct(&(trans_mgr_p->madw_list_timer));
302
303 /* init the timer with timeout. */
304 cl_status = cl_timer_init(&trans_mgr_p->madw_list_timer,
305 __osm_transaction_mgr_callback, p_vend);
306
307 if (cl_status != CL_SUCCESS) {
308 osm_log(p_vend->p_log, OSM_LOG_ERROR,
309 "osm_transaction_mgr_init : ERROR 1000: "
310 "Failed to initialize madw_reqs_list timer\n");
311 }
312 OSM_LOG_EXIT(p_vend->p_log);
313 }
314
osm_transaction_mgr_destroy(IN osm_vendor_t * const p_vend)315 void osm_transaction_mgr_destroy(IN osm_vendor_t * const p_vend)
316 {
317 osm_transaction_mgr_t *trans_mgr_p;
318 cl_list_item_t *p_list_item;
319 cl_map_item_t *p_map_item;
320 osm_madw_req_t *osm_madw_req_p;
321
322 OSM_LOG_ENTER(p_vend->p_log);
323
324 trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
325
326 if (p_vend->p_transaction_mgr != NULL) {
327 /* we need to get a lock */
328 cl_spinlock_acquire(&trans_mgr_p->transaction_mgr_lock);
329
330 /* go over all the items in the list and remove them */
331 p_list_item =
332 cl_qlist_remove_head(trans_mgr_p->madw_reqs_list_p);
333 while (p_list_item !=
334 cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
335 osm_madw_req_p = (osm_madw_req_t *) p_list_item;
336
337 if (osm_madw_req_p->p_madw->p_mad)
338 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
339 "osm_transaction_mgr_destroy: "
340 "Found outstanding MADW:%p TID:<0x%"
341 PRIx64 ">.\n", osm_madw_req_p->p_madw,
342 osm_madw_req_p->p_madw->p_mad->
343 trans_id);
344 else
345 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
346 "osm_transaction_mgr_destroy: "
347 "Found outstanding MADW:%p TID:UNDEFINED.\n",
348 osm_madw_req_p->p_madw);
349
350 /* each item - remove it from the map */
351 p_map_item = &(osm_madw_req_p->map_item);
352 cl_qmap_remove_item(trans_mgr_p->madw_by_tid_map_p,
353 p_map_item);
354 /* free the item */
355 free(osm_madw_req_p);
356 p_list_item =
357 cl_qlist_remove_head(trans_mgr_p->madw_reqs_list_p);
358 }
359 /* free the qlist and qmap */
360 free(trans_mgr_p->madw_reqs_list_p);
361 free(trans_mgr_p->madw_by_tid_map_p);
362 /* reliease and destroy the lock */
363 cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
364 cl_spinlock_destroy(&(trans_mgr_p->transaction_mgr_lock));
365 /* destroy the timer */
366 cl_timer_trim(&trans_mgr_p->madw_list_timer, 1);
367 cl_timer_destroy(&trans_mgr_p->madw_list_timer);
368 /* free the transaction_manager object */
369 free(trans_mgr_p);
370 trans_mgr_p = NULL;
371 }
372
373 OSM_LOG_EXIT(p_vend->p_log);
374 }
375
376 ib_api_status_t
osm_transaction_mgr_insert_madw(IN osm_bind_handle_t * const p_bind,IN osm_madw_t * p_madw)377 osm_transaction_mgr_insert_madw(IN osm_bind_handle_t * const p_bind,
378 IN osm_madw_t * p_madw)
379 {
380 #ifdef OSM_VENDOR_INTF_MTL
381 osm_vendor_t *const p_vend = ((osm_mtl_bind_info_t *) p_bind)->p_vend;
382 #else
383 osm_vendor_t *const p_vend = ((osm_ts_bind_info_t *) p_bind)->p_vend;
384 #endif
385 osm_transaction_mgr_t *trans_mgr_p;
386 osm_madw_req_t *osm_madw_req_p;
387 uint64_t timeout;
388 uint64_t waking_time;
389 cl_status_t cl_status;
390 uint64_t key;
391 const ib_mad_t *mad_p = p_madw->p_mad;
392
393 OSM_LOG_ENTER(p_vend->p_log);
394
395 CL_ASSERT(mad_p);
396
397 trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
398
399 timeout = (uint64_t) (p_vend->timeout) * 1000; /* change the miliseconds value of timeout to microseconds. */
400 waking_time = timeout + cl_get_time_stamp();
401
402 osm_madw_req_p = (osm_madw_req_t *) malloc(sizeof(osm_madw_req_t));
403
404 osm_madw_req_p->p_madw = p_madw;
405 osm_madw_req_p->waking_time = waking_time;
406 osm_madw_req_p->retry_cnt = OSM_DEFAULT_RETRY_COUNT;
407 osm_madw_req_p->p_bind = p_bind;
408
409 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
410 "osm_transaction_mgr_insert_madw: "
411 "Inserting MADW:%p with waking_time: <0x%" PRIx64 "> TID:<0x%"
412 PRIx64 ">.\n", p_madw, waking_time, p_madw->p_mad->trans_id);
413
414 /* Get the lock on the manager */
415 cl_spinlock_acquire(&(trans_mgr_p->transaction_mgr_lock));
416 /* If the list is empty - need to start the timer with timer of timeout (in miliseconds) */
417 if (cl_is_qlist_empty(trans_mgr_p->madw_reqs_list_p)) {
418 /* stop the timer if it is running */
419 cl_timer_stop(&trans_mgr_p->madw_list_timer);
420
421 /* start the timer to the timeout (in miliseconds) */
422 cl_status = cl_timer_start(&trans_mgr_p->madw_list_timer,
423 p_vend->timeout);
424 if (cl_status != CL_SUCCESS) {
425 osm_log(p_vend->p_log, OSM_LOG_ERROR,
426 "osm_transaction_mgr_insert_madw : ERROR 1000: "
427 "Failed to start timer\n");
428 }
429 }
430
431 /* insert the object to the qlist and the qmap */
432 cl_qlist_insert_tail(trans_mgr_p->madw_reqs_list_p,
433 &(osm_madw_req_p->list_item));
434 /* get the key */
435 key = (uint64_t) mad_p->trans_id;
436 cl_qmap_insert(trans_mgr_p->madw_by_tid_map_p, key,
437 &(osm_madw_req_p->map_item));
438 cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
439
440 OSM_LOG_EXIT(p_vend->p_log);
441
442 return (IB_SUCCESS);
443 }
444
445 ib_api_status_t
osm_transaction_mgr_erase_madw(IN osm_vendor_t * const p_vend,IN ib_mad_t * p_mad)446 osm_transaction_mgr_erase_madw(IN osm_vendor_t * const p_vend,
447 IN ib_mad_t * p_mad)
448 {
449 osm_transaction_mgr_t *trans_mgr_p;
450 osm_madw_req_t *osm_madw_req_p;
451 uint64_t key;
452 cl_map_item_t *p_map_item;
453 OSM_LOG_ENTER(p_vend->p_log);
454
455 trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
456
457 key = (uint64_t) p_mad->trans_id;
458 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
459 "osm_transaction_mgr_erase_madw: "
460 "Removing TID:<0x%" PRIx64 ">.\n", p_mad->trans_id);
461
462 cl_spinlock_acquire(&trans_mgr_p->transaction_mgr_lock);
463 p_map_item = cl_qmap_get(trans_mgr_p->madw_by_tid_map_p, key);
464 if (p_map_item != cl_qmap_end(trans_mgr_p->madw_by_tid_map_p)) {
465 /* we found such an item. */
466 /* get the osm_madw_req_p */
467 osm_madw_req_p =
468 PARENT_STRUCT(p_map_item, osm_madw_req_t, map_item);
469
470 /* remove the item from the qlist */
471 cl_qlist_remove_item(trans_mgr_p->madw_reqs_list_p,
472 &(osm_madw_req_p->list_item));
473 /* remove the item from the qmap */
474 cl_qmap_remove_item(trans_mgr_p->madw_by_tid_map_p,
475 &(osm_madw_req_p->map_item));
476
477 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
478 "osm_transaction_mgr_erase_madw: "
479 "Removed TID:<0x%" PRIx64 ">.\n", p_mad->trans_id);
480
481 /* free the item */
482 free(osm_madw_req_p);
483 } else {
484 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
485 "osm_transaction_mgr_erase_madw: "
486 "osm_transaction_mgr_erase_madw:<0x%" PRIx64
487 "> NOT FOUND.\n", p_mad->trans_id);
488 }
489 cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
490 OSM_LOG_EXIT(p_vend->p_log);
491
492 return (IB_SUCCESS);
493 }
494
495 ib_api_status_t
osm_transaction_mgr_get_madw_for_tid(IN osm_vendor_t * const p_vend,IN ib_mad_t * const p_mad,OUT osm_madw_t ** req_madw_p)496 osm_transaction_mgr_get_madw_for_tid(IN osm_vendor_t * const p_vend,
497 IN ib_mad_t * const p_mad,
498 OUT osm_madw_t ** req_madw_p)
499 {
500 osm_transaction_mgr_t *trans_mgr_p;
501 osm_madw_req_t *osm_madw_req_p;
502 cl_map_item_t *p_map_item;
503 uint64_t key;
504 OSM_LOG_ENTER(p_vend->p_log);
505
506 trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
507
508 *req_madw_p = NULL;
509
510 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
511 "osm_transaction_mgr_get_madw_for_tid: "
512 "Looking for TID:<0x%" PRIx64 ">.\n", p_mad->trans_id);
513
514 key = (uint64_t) p_mad->trans_id;
515 cl_spinlock_acquire(&(trans_mgr_p->transaction_mgr_lock));
516 p_map_item = cl_qmap_get(trans_mgr_p->madw_by_tid_map_p, key);
517 if (p_map_item != cl_qmap_end(trans_mgr_p->madw_by_tid_map_p)) {
518 /* we found such an item. */
519 /* get the osm_madw_req_p */
520 osm_madw_req_p =
521 PARENT_STRUCT(p_map_item, osm_madw_req_t, map_item);
522
523 /* Since the Transaction was looked up and provided for */
524 /* processing we retire it */
525 cl_qlist_remove_item(trans_mgr_p->madw_reqs_list_p,
526 &(osm_madw_req_p->list_item));
527 /* remove the item from the qmap */
528 cl_qmap_remove_item(trans_mgr_p->madw_by_tid_map_p,
529 &(osm_madw_req_p->map_item));
530
531 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
532 "osm_transaction_mgr_get_madw_for_tid: "
533 "Removed TID:<0x%" PRIx64 ">.\n", p_mad->trans_id);
534
535 *req_madw_p = osm_madw_req_p->p_madw;
536 }
537
538 cl_spinlock_release(&(trans_mgr_p->transaction_mgr_lock));
539 osm_log(p_vend->p_log, OSM_LOG_DEBUG,
540 "osm_transaction_mgr_get_madw_for_tid: "
541 "Got MADW:%p.\n", *req_madw_p);
542 OSM_LOG_EXIT(p_vend->p_log);
543 return (IB_SUCCESS);
544 }
545
546 #endif
547