void osm_transaction_mgr_destroy(IN osm_vendor_t * const p_vend)
{
osm_transaction_mgr_t *trans_mgr_p;
cl_list_item_t *p_list_item;
cl_map_item_t *p_map_item;
osm_madw_req_t *osm_madw_req_p;
OSM_LOG_ENTER(p_vend->p_log);
trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
if (p_vend->p_transaction_mgr != NULL) {
/* we need to get a lock */
cl_spinlock_acquire(&trans_mgr_p->transaction_mgr_lock);
/* go over all the items in the list and remove them */
p_list_item =
cl_qlist_remove_head(trans_mgr_p->madw_reqs_list_p);
while (p_list_item !=
cl_qlist_end(trans_mgr_p->madw_reqs_list_p)) {
osm_madw_req_p = (osm_madw_req_t *) p_list_item;
if (osm_madw_req_p->p_madw->p_mad)
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_destroy: "
"Found outstanding MADW:%p TID:<0x%"
PRIx64 ">.\n", osm_madw_req_p->p_madw,
osm_madw_req_p->p_madw->p_mad->
trans_id);
else
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_destroy: "
"Found outstanding MADW:%p TID:UNDEFINED.\n",
osm_madw_req_p->p_madw);
/* each item - remove it from the map */
p_map_item = &(osm_madw_req_p->map_item);
cl_qmap_remove_item(trans_mgr_p->madw_by_tid_map_p,
p_map_item);
/* free the item */
free(osm_madw_req_p);
p_list_item =
cl_qlist_remove_head(trans_mgr_p->madw_reqs_list_p);
}
/* free the qlist and qmap */
free(trans_mgr_p->madw_reqs_list_p);
free(trans_mgr_p->madw_by_tid_map_p);
/* reliease and destroy the lock */
cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
cl_spinlock_destroy(&(trans_mgr_p->transaction_mgr_lock));
/* destroy the timer */
cl_timer_trim(&trans_mgr_p->madw_list_timer, 1);
cl_timer_destroy(&trans_mgr_p->madw_list_timer);
/* free the transaction_manager object */
free(trans_mgr_p);
trans_mgr_p = NULL;
}
OSM_LOG_EXIT(p_vend->p_log);
}
void cl_disp_destroy(IN cl_dispatcher_t * const p_disp)
{
CL_ASSERT(p_disp);
cl_spinlock_destroy(&p_disp->lock);
/* Destroy the message pool */
cl_qpool_destroy(&p_disp->msg_pool);
/* Destroy the pointer vector of registrants. */
cl_ptr_vector_destroy(&p_disp->reg_vec);
}
void osm_db_domain_destroy(IN osm_db_domain_t * const p_db_domain)
{
osm_db_domain_imp_t *p_domain_imp;
p_domain_imp = (osm_db_domain_imp_t *) p_db_domain->p_domain_imp;
osm_db_clear(p_db_domain);
cl_spinlock_destroy(&p_domain_imp->lock);
st_free_table(p_domain_imp->p_hash);
free(p_domain_imp->file_name);
free(p_domain_imp);
}
void osm_vl15_destroy(IN osm_vl15_t * p_vl, IN struct osm_mad_pool *p_pool)
{
osm_madw_t *p_madw;
OSM_LOG_ENTER(p_vl->p_log);
/*
Signal our threads that we're leaving.
*/
p_vl->thread_state = OSM_THREAD_STATE_EXIT;
/*
Don't trigger unless event has been initialized.
Destroy the thread before we tear down the other objects.
*/
if (p_vl->state != OSM_VL15_STATE_INIT)
cl_event_signal(&p_vl->signal);
cl_thread_destroy(&p_vl->poller);
/*
Return the outstanding messages to the pool
*/
cl_spinlock_acquire(&p_vl->lock);
while (!cl_is_qlist_empty(&p_vl->rfifo)) {
p_madw = (osm_madw_t *) cl_qlist_remove_head(&p_vl->rfifo);
osm_mad_pool_put(p_pool, p_madw);
}
while (!cl_is_qlist_empty(&p_vl->ufifo)) {
p_madw = (osm_madw_t *) cl_qlist_remove_head(&p_vl->ufifo);
osm_mad_pool_put(p_pool, p_madw);
}
cl_spinlock_release(&p_vl->lock);
cl_event_destroy(&p_vl->signal);
p_vl->state = OSM_VL15_STATE_INIT;
cl_spinlock_destroy(&p_vl->lock);
OSM_LOG_EXIT(p_vl->p_log);
}
void cl_event_wheel_destroy(IN cl_event_wheel_t * const p_event_wheel)
{
cl_list_item_t *p_list_item;
cl_map_item_t *p_map_item;
cl_event_wheel_reg_info_t *p_event;
/* we need to get a lock */
cl_spinlock_acquire(&p_event_wheel->lock);
cl_event_wheel_dump(p_event_wheel);
/* go over all the items in the list and remove them */
p_list_item = cl_qlist_remove_head(&p_event_wheel->events_wheel);
while (p_list_item != cl_qlist_end(&p_event_wheel->events_wheel)) {
p_event =
PARENT_STRUCT(p_list_item, cl_event_wheel_reg_info_t,
list_item);
CL_DBG("cl_event_wheel_destroy: Found outstanding event"
" key:<0x%" PRIx64 ">\n", p_event->key);
/* remove it from the map */
p_map_item = &(p_event->map_item);
cl_qmap_remove_item(&p_event_wheel->events_map, p_map_item);
free(p_event); /* allocated by cl_event_wheel_reg */
p_list_item =
cl_qlist_remove_head(&p_event_wheel->events_wheel);
}
/* destroy the timer */
cl_timer_destroy(&p_event_wheel->timer);
/* destroy the lock (this should be done without releasing - we don't want
any other run to grab the lock at this point. */
cl_spinlock_release(&p_event_wheel->lock);
cl_spinlock_destroy(&(p_event_wheel->lock));
}
osm_bind_handle_t
osm_vendor_bind(IN osm_vendor_t * const p_vend,
IN osm_bind_info_t * const p_bind_info,
IN osm_mad_pool_t * const p_mad_pool,
IN osm_vend_mad_recv_callback_t mad_recv_callback,
IN osm_vend_mad_send_err_callback_t send_err_callback,
IN void *context)
{
osmv_bind_obj_t *p_bo;
ib_api_status_t status;
char hca_id[32];
cl_status_t cl_st;
cl_list_obj_t *p_obj;
uint8_t hca_index;
if (NULL == p_vend || NULL == p_bind_info || NULL == p_mad_pool
|| NULL == mad_recv_callback || NULL == send_err_callback) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_vendor_bind: ERR 7302: "
"NULL parameter passed in: p_vend=%p p_bind_info=%p p_mad_pool=%p recv_cb=%p send_err_cb=%p\n",
p_vend, p_bind_info, p_mad_pool, mad_recv_callback,
send_err_callback);
return OSM_BIND_INVALID_HANDLE;
}
p_bo = malloc(sizeof(osmv_bind_obj_t));
if (NULL == p_bo) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_vendor_bind: ERR 7303: could not allocate the bind object\n");
return OSM_BIND_INVALID_HANDLE;
}
memset(p_bo, 0, sizeof(osmv_bind_obj_t));
p_bo->p_vendor = p_vend;
p_bo->recv_cb = mad_recv_callback;
p_bo->send_err_cb = send_err_callback;
p_bo->cb_context = context;
p_bo->p_osm_pool = p_mad_pool;
/* obtain the hca name and port num from the guid */
osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG,
"osm_vendor_bind: "
"Finding CA and Port that owns port guid 0x%" PRIx64 ".\n",
cl_ntoh64(p_bind_info->port_guid));
status = osm_vendor_get_guid_ca_and_port(p_bo->p_vendor,
p_bind_info->port_guid,
&(p_bo->hca_hndl),
hca_id,
&hca_index, &(p_bo->port_num));
if (status != IB_SUCCESS) {
osm_log(p_bo->p_vendor->p_log, OSM_LOG_ERROR,
"osm_vendor_bind: ERR 7304: "
"Fail to find port number of port guid:0x%016" PRIx64
"\n", p_bind_info->port_guid);
free(p_bo);
return OSM_BIND_INVALID_HANDLE;
}
/* Initialize the magic_ptr to the pointer of the p_bo info.
This will be used to signal when the object is being destroyed, so no
real action will be done then. */
p_bo->magic_ptr = p_bo;
p_bo->is_closing = FALSE;
cl_spinlock_construct(&(p_bo->lock));
cl_st = cl_spinlock_init(&(p_bo->lock));
if (cl_st != CL_SUCCESS) {
osm_log(p_bo->p_vendor->p_log, OSM_LOG_ERROR,
"osm_vendor_bind: ERR 7305: "
"could not initialize the spinlock ...\n");
free(p_bo);
return OSM_BIND_INVALID_HANDLE;
}
osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG,
"osm_vendor_bind: osmv_txnmgr_init ... \n");
if (osmv_txnmgr_init(&p_bo->txn_mgr, p_vend->p_log, &(p_bo->lock)) !=
IB_SUCCESS) {
osm_log(p_bo->p_vendor->p_log, OSM_LOG_ERROR,
"osm_vendor_bind: ERR 7306: "
"osmv_txnmgr_init failed \n");
cl_spinlock_destroy(&p_bo->lock);
free(p_bo);
return OSM_BIND_INVALID_HANDLE;
}
/* Do the real job! (Transport-dependent) */
if (IB_SUCCESS !=
osmv_transport_init(p_bind_info, hca_id, hca_index, p_bo)) {
osm_log(p_bo->p_vendor->p_log, OSM_LOG_ERROR,
"osm_vendor_bind: ERR 7307: "
"osmv_transport_init failed \n");
osmv_txnmgr_done((osm_bind_handle_t) p_bo);
cl_spinlock_destroy(&p_bo->lock);
free(p_bo);
return OSM_BIND_INVALID_HANDLE;
}
/* insert bind handle into db */
p_obj = malloc(sizeof(cl_list_obj_t));
if (NULL == p_obj) {
osm_log(p_bo->p_vendor->p_log, OSM_LOG_ERROR,
"osm_vendor_bind: ERR 7308: "
"osm_vendor_bind: could not allocate the list object\n");
osmv_transport_done(p_bo->p_transp_mgr);
osmv_txnmgr_done((osm_bind_handle_t) p_bo);
cl_spinlock_destroy(&p_bo->lock);
free(p_bo);
return OSM_BIND_INVALID_HANDLE;
}
memset(p_obj, 0, sizeof(cl_list_obj_t));
cl_qlist_set_obj(p_obj, p_bo);
cl_qlist_insert_head(&p_vend->bind_handles, &p_obj->list_item);
return (osm_bind_handle_t) p_bo;
}
