osm_db_domain_t *osm_db_domain_init(IN osm_db_t * const p_db,
IN char *domain_name)
{
osm_db_domain_t *p_domain;
osm_db_domain_imp_t *p_domain_imp;
int dir_name_len;
osm_log_t *p_log = p_db->p_log;
FILE *p_file;
OSM_LOG_ENTER(p_log);
/* allocate a new domain object */
p_domain = (osm_db_domain_t *) malloc(sizeof(osm_db_domain_t));
CL_ASSERT(p_domain != NULL);
p_domain_imp =
(osm_db_domain_imp_t *) malloc(sizeof(osm_db_domain_imp_t));
CL_ASSERT(p_domain_imp != NULL);
dir_name_len = strlen(((osm_db_imp_t *) p_db->p_db_imp)->db_dir_name);
/* set the domain file name */
p_domain_imp->file_name =
(char *)malloc(sizeof(char) * (dir_name_len) + strlen(domain_name) +
2);
CL_ASSERT(p_domain_imp->file_name != NULL);
strcpy(p_domain_imp->file_name,
((osm_db_imp_t *) p_db->p_db_imp)->db_dir_name);
strcat(p_domain_imp->file_name, domain_name);
/* make sure the file exists - or exit if not writable */
p_file = fopen(p_domain_imp->file_name, "a+");
if (!p_file) {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 6102: "
"Failed to open the db file:%s\n",
p_domain_imp->file_name);
free(p_domain_imp);
free(p_domain);
p_domain = NULL;
goto Exit;
}
fclose(p_file);
/* initialize the hash table object */
p_domain_imp->p_hash = st_init_strtable();
CL_ASSERT(p_domain_imp->p_hash != NULL);
p_domain->p_db = p_db;
cl_list_insert_tail(&p_db->domains, p_domain);
p_domain->p_domain_imp = p_domain_imp;
cl_spinlock_construct(&p_domain_imp->lock);
cl_spinlock_init(&p_domain_imp->lock);
Exit:
OSM_LOG_EXIT(p_log);
return p_domain;
}
void cl_disp_construct(IN cl_dispatcher_t * const p_disp)
{
CL_ASSERT(p_disp);
cl_qlist_init(&p_disp->reg_list);
cl_ptr_vector_construct(&p_disp->reg_vec);
cl_qlist_init(&p_disp->msg_fifo);
cl_spinlock_construct(&p_disp->lock);
cl_qpool_construct(&p_disp->msg_pool);
}
void osm_vl15_construct(IN osm_vl15_t * p_vl)
{
memset(p_vl, 0, sizeof(*p_vl));
p_vl->state = OSM_VL15_STATE_INIT;
p_vl->thread_state = OSM_THREAD_STATE_NONE;
cl_event_construct(&p_vl->signal);
cl_spinlock_construct(&p_vl->lock);
cl_qlist_init(&p_vl->rfifo);
cl_qlist_init(&p_vl->ufifo);
cl_thread_construct(&p_vl->poller);
}
ib_api_status_t
osm_vendor_init(IN osm_vendor_t * const p_vend,
IN osm_log_t * const p_log, IN const uint32_t timeout)
{
FSTATUS Status;
PUMADT_GET_INTERFACE uMadtGetInterface;
char *error;
umadt_obj_t *p_umadt_obj = (umadt_obj_t *) p_vend;
OSM_LOG_ENTER(p_log);
p_umadt_obj->p_log = p_log;
p_umadt_obj->timeout = timeout;
p_umadt_obj->umadt_handle = dlopen("libibt.so", RTLD_NOW);
if (!p_umadt_obj->umadt_handle) {
printf("Could not load libibt.so <%s>\n", dlerror());
return IB_ERROR;
}
uMadtGetInterface =
dlsym(p_umadt_obj->umadt_handle, "uMadtGetInterface");
if ((error = dlerror()) != NULL) {
printf("Could not resolve symbol uMadtGetInterface ERROR<%s>\n",
error);
return IB_ERROR;
}
Status = (*uMadtGetInterface) (&p_umadt_obj->uMadtInterface);
if (Status != FSUCCESS) {
printf(" Error in getting uMADT interface ERROR<%d>\n", Status);
return IB_ERROR;
}
/* Initialize the register list and register list lock */
cl_qlist_init(&p_umadt_obj->register_list);
cl_spinlock_construct(&p_umadt_obj->register_lock);
CL_ASSERT(cl_spinlock_init(&p_umadt_obj->register_lock) == CL_SUCCESS);
p_umadt_obj->init_done = TRUE;
printf("*****SUCCESS*****\n");
OSM_LOG_EXIT(p_log);
return IB_SUCCESS;
}
void osm_transaction_mgr_init(IN osm_vendor_t * const p_vend)
{
cl_status_t cl_status;
osm_transaction_mgr_t *trans_mgr_p;
OSM_LOG_ENTER(p_vend->p_log);
CL_ASSERT(p_vend->p_transaction_mgr == NULL);
(osm_transaction_mgr_t *) p_vend->p_transaction_mgr =
(osm_transaction_mgr_t *) malloc(sizeof(osm_transaction_mgr_t));
trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
/* construct lock object */
cl_spinlock_construct(&(trans_mgr_p->transaction_mgr_lock));
CL_ASSERT(cl_spinlock_init(&(trans_mgr_p->transaction_mgr_lock)) ==
CL_SUCCESS);
/* initialize the qlist */
trans_mgr_p->madw_reqs_list_p =
(cl_qlist_t *) malloc(sizeof(cl_qlist_t));
cl_qlist_init(trans_mgr_p->madw_reqs_list_p);
/* initialize the qmap */
trans_mgr_p->madw_by_tid_map_p =
(cl_qmap_t *) malloc(sizeof(cl_qmap_t));
cl_qmap_init(trans_mgr_p->madw_by_tid_map_p);
/* create the timer used by the madw_req_list */
cl_timer_construct(&(trans_mgr_p->madw_list_timer));
/* init the timer with timeout. */
cl_status = cl_timer_init(&trans_mgr_p->madw_list_timer,
__osm_transaction_mgr_callback, p_vend);
if (cl_status != CL_SUCCESS) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_transaction_mgr_init : ERROR 1000: "
"Failed to initialize madw_reqs_list timer\n");
}
OSM_LOG_EXIT(p_vend->p_log);
}
osm_bind_handle_t
osm_vendor_bind(IN osm_vendor_t * const p_vend,
IN osm_bind_info_t * const p_osm_bind_info,
IN osm_mad_pool_t * const p_mad_pool,
IN osm_vend_mad_recv_callback_t mad_recv_callback,
IN void *context)
{
cl_status_t cl_status;
FSTATUS Status; /* GEN1 Status for Umadt */
mad_bind_info_t *p_mad_bind_info;
RegisterClassStruct *p_umadt_reg_class;
umadt_obj_t *p_umadt_obj;
OSM_LOG_ENTER(((umadt_obj_t *) p_vend)->p_log);
CL_ASSERT(p_vend);
p_umadt_obj = (umadt_obj_t *) p_vend;
/* Sanity check */
CL_ASSERT(p_umadt_obj->init_done);
CL_ASSERT(p_osm_bind_info);
CL_ASSERT(p_mad_pool);
CL_ASSERT(mad_recv_callback);
/* Allocate memory for registering the handle. */
p_mad_bind_info = (mad_bind_info_t *) malloc(sizeof(*p_mad_bind_info));
if (p_mad_bind_info) {
memset(p_mad_bind_info, 0, sizeof(*p_mad_bind_info));
p_umadt_reg_class = &p_mad_bind_info->umadt_reg_class;
}
p_umadt_reg_class->PortGuid = cl_ntoh64(p_osm_bind_info->port_guid);
p_umadt_reg_class->ClassId = p_osm_bind_info->mad_class;
p_umadt_reg_class->ClassVersion = p_osm_bind_info->class_version;
p_umadt_reg_class->isResponder = p_osm_bind_info->is_responder;
p_umadt_reg_class->isTrapProcessor = p_osm_bind_info->is_trap_processor;
p_umadt_reg_class->isReportProcessor =
p_osm_bind_info->is_report_processor;
p_umadt_reg_class->SendQueueSize = p_osm_bind_info->send_q_size;
p_umadt_reg_class->RecvQueueSize = p_osm_bind_info->recv_q_size;
p_umadt_reg_class->NotifySendCompletion = TRUE;
p_mad_bind_info->p_umadt_obj = p_umadt_obj;
p_mad_bind_info->p_mad_pool = p_mad_pool;
p_mad_bind_info->mad_recv_callback = mad_recv_callback;
p_mad_bind_info->client_context = context;
/* register with Umadt for MAD interface */
Status = p_umadt_obj->uMadtInterface.uMadtRegister(p_umadt_reg_class,
&p_mad_bind_info->
umadt_handle);
if (Status != FSUCCESS) {
free(p_mad_bind_info);
OSM_LOG_EXIT(p_umadt_obj->p_log);
return (OSM_BIND_INVALID_HANDLE);
}
CL_ASSERT(p_mad_bind_info->umadt_handle);
/* */
/* Start a worker thread to process receives. */
/* */
cl_thread_construct(&p_mad_bind_info->recv_processor_thread);
cl_status = cl_thread_init(&p_mad_bind_info->recv_processor_thread,
__mad_recv_processor,
(void *)p_mad_bind_info, "mad_recv_worker");
CL_ASSERT(cl_status == CL_SUCCESS);
cl_qlist_init(&p_mad_bind_info->trans_ctxt_list);
cl_spinlock_construct(&p_mad_bind_info->trans_ctxt_lock);
cl_spinlock_init(&p_mad_bind_info->trans_ctxt_lock);
cl_spinlock_construct(&p_mad_bind_info->timeout_list_lock);
cl_spinlock_init(&p_mad_bind_info->timeout_list_lock);
cl_status = cl_timer_init(&p_mad_bind_info->timeout_timer,
__osm_vendor_timer_callback,
(void *)p_mad_bind_info);
CL_ASSERT(cl_status == CL_SUCCESS);
cl_qlist_init(&p_mad_bind_info->timeout_list);
/* */
/* Insert the mad_reg_struct in list and return pointer to it as the handle */
/* */
cl_spinlock_acquire(&p_umadt_obj->register_lock);
cl_qlist_insert_head(&p_umadt_obj->register_list,
&p_mad_bind_info->list_item);
cl_spinlock_release(&p_umadt_obj->register_lock);
/*
A timeout value of 0 means disable timeouts.
*/
if (p_umadt_obj->timeout) {
cl_timer_start(&p_mad_bind_info->timeout_timer,
DEFAULT_TIMER_INTERVAL_MSEC);
}
OSM_LOG_EXIT(p_umadt_obj->p_log);
return ((osm_bind_handle_t) p_mad_bind_info);
}
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;
}
/*
* Construct and Initialize
*/
void cl_event_wheel_construct(IN cl_event_wheel_t * const p_event_wheel)
{
cl_spinlock_construct(&(p_event_wheel->lock));
cl_timer_construct(&(p_event_wheel->timer));
}
