ib_api_status_t
__osmv_txnmgr_remove_txn(IN osmv_txn_mgr_t * p_tx_mgr,
IN uint64_t key, OUT osmv_txn_ctx_t ** pp_txn)
{
cl_map_obj_t *p_obj;
cl_map_item_t *p_item;
OSM_LOG_ENTER(p_tx_mgr->p_log);
CL_ASSERT(p_tx_mgr);
CL_ASSERT(pp_txn);
p_item = cl_qmap_remove(p_tx_mgr->p_txn_map, key);
if (p_item == cl_qmap_end(p_tx_mgr->p_txn_map)) {
osm_log(p_tx_mgr->p_log, OSM_LOG_ERROR,
"__osmv_txnmgr_remove_txn: ERR 6701: "
"Could not remove the transaction 0x%llX - "
"something is really wrong!\n", key);
OSM_LOG_EXIT(p_tx_mgr->p_log);
return IB_NOT_FOUND;
}
p_obj = PARENT_STRUCT(p_item, cl_map_obj_t, item);
*pp_txn = cl_qmap_obj(p_obj);
free(p_obj);
OSM_LOG_EXIT(p_tx_mgr->p_log);
return IB_SUCCESS;
}
static uint8_t link_mgr_get_smsl(IN osm_sm_t * sm, IN osm_physp_t * p_physp)
{
osm_opensm_t *p_osm = sm->p_subn->p_osm;
struct osm_routing_engine *re = p_osm->routing_engine_used;
ib_net16_t slid;
ib_net16_t smlid;
uint8_t sl;
OSM_LOG_ENTER(sm->p_log);
if (!(re && re->path_sl &&
(slid = osm_physp_get_base_lid(p_physp)))) {
/*
* Use default SL if routing engine does not provide a
* path SL lookup callback.
*/
OSM_LOG_EXIT(sm->p_log);
return sm->p_subn->opt.sm_sl;
}
smlid = sm->p_subn->sm_base_lid;
/* Call into routing engine to find proper SL */
sl = re->path_sl(re->context, sm->p_subn->opt.sm_sl,
slid, smlid);
OSM_LOG_EXIT(sm->p_log);
return sl;
}
static uint8_t link_mgr_get_smsl(IN osm_sm_t * sm, IN osm_physp_t * p_physp)
{
osm_opensm_t *p_osm = sm->p_subn->p_osm;
struct osm_routing_engine *re = p_osm->routing_engine_used;
const osm_port_t *p_sm_port, *p_src_port;
ib_net16_t slid;
uint8_t sl;
OSM_LOG_ENTER(sm->p_log);
if (!(re && re->path_sl &&
(slid = osm_physp_get_base_lid(p_physp)))) {
/*
* Use default SL if routing engine does not provide a
* path SL lookup callback.
*/
OSM_LOG_EXIT(sm->p_log);
return sm->p_subn->opt.sm_sl;
}
/* Find osm_port of the SM itself = dest_port */
p_sm_port = osm_get_port_by_lid(sm->p_subn, sm->p_subn->sm_base_lid);
/* Find osm_port of the source = p_physp */
p_src_port = osm_get_port_by_lid(sm->p_subn, slid);
/* Call into routing engine to find proper SL */
sl = re->path_sl(re->context, sm->p_subn->opt.sm_sl,
p_src_port, p_sm_port);
OSM_LOG_EXIT(sm->p_log);
return sl;
}
uint8_t
osm_vendor_get_port_num(IN osm_vendor_t * const p_vend,
IN const ib_net64_t port_guid)
{
uint8_t index;
uint8_t num_ports;
uint32_t num_guids = 0;
osm_ca_info_t *p_ca_info;
uint32_t ca;
OSM_LOG_ENTER(p_vend->p_log);
CL_ASSERT(port_guid);
/*
First, locate the HCA that owns this port.
*/
if (p_vend->p_ca_info == NULL) {
/*
Initialize the osm_ca_info_t array which allows
us to match port GUID to CA.
*/
osm_vendor_get_all_port_attr(p_vend, NULL, &num_guids);
}
CL_ASSERT(p_vend->p_ca_info);
CL_ASSERT(p_vend->ca_count);
for (ca = 0; ca < p_vend->ca_count; ca++) {
p_ca_info = &p_vend->p_ca_info[ca];
num_ports = osm_ca_info_get_num_ports(p_ca_info);
CL_ASSERT(num_ports);
for (index = 0; index < num_ports; index++) {
if (port_guid ==
osm_ca_info_get_port_guid(p_ca_info, index)) {
OSM_LOG_EXIT(p_vend->p_log);
return (osm_ca_info_get_port_num
(p_ca_info, index));
}
}
}
/*
No local CA owns this guid!
*/
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_vendor_get_port_num: ERR 3B30: "
"Unable to determine CA guid.\n");
OSM_LOG_EXIT(p_vend->p_log);
return (0);
}
ib_api_status_t
osmv_txn_init(IN osm_bind_handle_t h_bind,
IN uint64_t tid, IN uint64_t key, OUT osmv_txn_ctx_t ** pp_txn)
{
ib_api_status_t st;
osmv_txn_ctx_t *p_txn;
osmv_bind_obj_t *p_bo = (osmv_bind_obj_t *) h_bind;
OSM_LOG_ENTER(p_bo->p_vendor->p_log);
CL_ASSERT(NULL != h_bind && NULL != pp_txn);
osm_log(p_bo->p_vendor->p_log, OSM_LOG_DEBUG,
"Starting transaction 0x%016" PRIx64
" (key=0x%016" PRIx64 ")\n", tid, key);
p_txn = malloc(sizeof(osmv_txn_ctx_t));
if (!p_txn) {
return IB_INSUFFICIENT_MEMORY;
}
memset(p_txn, 0, sizeof(osmv_txn_ctx_t));
p_txn->p_log = p_bo->txn_mgr.p_log;
p_txn->tid = tid;
p_txn->key = key;
p_txn->p_madw = NULL;
p_txn->rmpp_txfr.rmpp_state = OSMV_TXN_RMPP_NONE;
/* insert into transaction manager DB */
st = __osmv_txnmgr_insert_txn(&p_bo->txn_mgr, p_txn, key);
if (IB_SUCCESS != st) {
osm_log(p_bo->p_vendor->p_log, OSM_LOG_ERROR,
"osmv_txn_init: ERR 6703: "
"Failed to insert to transaction 0x%016" PRIx64
" (key=0x%016" PRIx64 ") to manager DB\n",
tid, key);
goto insert_txn_failed;
}
*pp_txn = p_txn;
OSM_LOG_EXIT(p_bo->p_vendor->p_log);
return IB_SUCCESS;
insert_txn_failed:
free(p_txn);
OSM_LOG_EXIT(p_bo->p_vendor->p_log);
return st;
}
/**********************************************************************
* Return a MAD by providing it's wrapper object.
**********************************************************************/
void
osm_vendor_put(IN osm_bind_handle_t h_bind, IN osm_vend_wrap_t * const p_vw)
{
osm_ts_bind_info_t *p_bind = (osm_ts_bind_info_t *) h_bind;
osm_vendor_t *p_vend = p_bind->p_vend;
osm_madw_t *p_madw;
OSM_LOG_ENTER(p_vend->p_log);
CL_ASSERT(p_vw);
CL_ASSERT(p_vw->p_mad_buf);
if (osm_log_get_level(p_vend->p_log) >= OSM_LOG_DEBUG) {
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_vendor_put: " "Retiring MAD %p.\n",
p_vw->p_mad_buf);
}
/*
* We moved the removal of the transaction to immediatly after
* it was looked up.
*/
/* free the mad but the wrapper is part of the madw object */
free(p_vw->p_mad_buf);
p_vw->p_mad_buf = NULL;
p_madw = PARENT_STRUCT(p_vw, osm_madw_t, vend_wrap);
p_madw->p_mad = NULL;
OSM_LOG_EXIT(p_vend->p_log);
}
void osm_vendor_set_sm(IN osm_bind_handle_t h_bind, IN boolean_t is_sm_val)
{
osm_ts_bind_info_t *p_bind = (osm_ts_bind_info_t *) h_bind;
osm_vendor_t *p_vend = p_bind->p_vend;
VAPI_ret_t status;
VAPI_hca_attr_t attr_mod;
VAPI_hca_attr_mask_t attr_mask;
OSM_LOG_ENTER(p_vend->p_log);
memset(&attr_mod, 0, sizeof(attr_mod));
memset(&attr_mask, 0, sizeof(attr_mask));
attr_mod.is_sm = is_sm_val;
attr_mask = HCA_ATTR_IS_SM;
status =
VAPI_modify_hca_attr(p_bind->hca_hndl, p_bind->port_num, &attr_mod,
&attr_mask);
if (status != VAPI_OK) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_vendor_set_sm: ERR 5027: "
"Unable set 'IS_SM' bit to:%u in port attributes (%d).\n",
is_sm_val, status);
}
OSM_LOG_EXIT(p_vend->p_log);
}
void osm_vendor_set_sm(IN osm_bind_handle_t h_bind, IN boolean_t is_sm_val)
{
osmv_bind_obj_t *p_bo = (osmv_bind_obj_t *) h_bind;
osm_vendor_t const *p_vend = p_bo->p_vendor;
int ret;
ibms_cap_msg_t cap_msg;
OSM_LOG_ENTER(p_vend->p_log);
cap_msg.mask = IB_PORT_CAP_IS_SM;
if (is_sm_val)
cap_msg.capabilities = IB_PORT_CAP_IS_SM;
else
cap_msg.capabilities = 0;
ret = ibms_set_cap(((osmv_ibms_transport_mgr_t *) (p_bo->
p_transp_mgr))->
conHdl, &cap_msg);
if (ret) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_vendor_set_sm: ERR 5312: "
"Unable set 'IS_SM' bit to:%u in port attributes.\n",
is_sm_val);
}
OSM_LOG_EXIT(p_vend->p_log);
}
/**********************************************************************
* Create and Initialize osm_vendor_t Object
**********************************************************************/
osm_vendor_t *osm_vendor_new(IN osm_log_t * const p_log,
IN const uint32_t timeout)
{
ib_api_status_t status;
osm_vendor_t *p_vend;
OSM_LOG_ENTER(p_log);
CL_ASSERT(p_log);
p_vend = malloc(sizeof(*p_vend));
if (p_vend != NULL) {
memset(p_vend, 0, sizeof(*p_vend));
status = osm_vendor_init(p_vend, p_log, timeout);
if (status != IB_SUCCESS) {
osm_vendor_delete(&p_vend);
}
} else {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_vendor_new: ERR 5007: "
"Fail to allocate vendor object.\n");
}
OSM_LOG_EXIT(p_log);
return (p_vend);
}
/**********************************************************************
Notifies the transport layer that the local LID has changed,
which give it a chance to update address vectors, etc..
**********************************************************************/
static ib_api_status_t state_mgr_notify_lid_change(IN osm_sm_t * sm)
{
ib_api_status_t status;
osm_bind_handle_t h_bind;
OSM_LOG_ENTER(sm->p_log);
/*
* First, get the bind handle.
*/
h_bind = osm_sm_mad_ctrl_get_bind_handle(&sm->mad_ctrl);
if (h_bind == OSM_BIND_INVALID_HANDLE) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3306: "
"No bound ports\n");
status = IB_ERROR;
goto Exit;
}
/*
* Notify the transport layer that we changed the local LID.
*/
status = osm_vendor_local_lid_change(h_bind);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3307: "
"Vendor LID update failed (%s)\n",
ib_get_err_str(status));
Exit:
OSM_LOG_EXIT(sm->p_log);
return status;
}
/**********************************************************************
* This code actually handles the call
**********************************************************************/
void osm_cpi_rcv_process(IN void *context, IN void *data)
{
osm_sa_t *sa = context;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *p_sa_mad;
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
/* we only support GET */
if (p_sa_mad->method != IB_MAD_METHOD_GET) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 1403: "
"Unsupported Method (%s) for ClassPortInfo request\n",
ib_get_sa_method_str(p_sa_mad->method));
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
}
CL_ASSERT(p_sa_mad->attr_id == IB_MAD_ATTR_CLASS_PORT_INFO);
/* CLASS PORT INFO does not really look at the SMDB - no lock required. */
cpi_rcv_respond(sa, p_madw);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
/****f* opensm: SM/__osm_sm_mad_ctrl_disp_done_callback
* NAME
* __osm_sm_mad_ctrl_disp_done_callback
*
* DESCRIPTION
* This function is the Dispatcher callback that indicates
* a received MAD has been processed by the recipient.
*
* SYNOPSIS
*/
static void
__osm_sm_mad_ctrl_disp_done_callback(IN void *context, IN void *p_data)
{
osm_sm_mad_ctrl_t *const p_ctrl = (osm_sm_mad_ctrl_t *) context;
osm_madw_t *const p_madw = (osm_madw_t *) p_data;
ib_smp_t *p_smp;
OSM_LOG_ENTER(p_ctrl->p_log);
/*
If the MAD that just finished processing was a response,
then retire the transaction, since we must have generated
the request.
Otherwise, retire the transaction if a response was expected,
as in the case of a send failure. If a response was not expected,
just put the MAD back in the pool, because the MAD was a query
from some outside agent, e.g. Get(SMInfo) from another SM.
*/
p_smp = osm_madw_get_smp_ptr(p_madw);
if (ib_smp_is_response(p_smp)) {
CL_ASSERT(p_madw->resp_expected == FALSE);
__osm_sm_mad_ctrl_retire_trans_mad(p_ctrl, p_madw);
} else if (p_madw->resp_expected == TRUE)
__osm_sm_mad_ctrl_retire_trans_mad(p_ctrl, p_madw);
else
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
OSM_LOG_EXIT(p_ctrl->p_log);
}
static void nd_rcv_process_nd(IN osm_sm_t * sm, IN osm_node_t * p_node,
IN const ib_node_desc_t * p_nd)
{
char *tmp_desc;
char print_desc[IB_NODE_DESCRIPTION_SIZE + 1];
OSM_LOG_ENTER(sm->p_log);
memcpy(&p_node->node_desc.description, p_nd, sizeof(*p_nd));
/* also set up a printable version */
memcpy(print_desc, p_nd, sizeof(*p_nd));
print_desc[IB_NODE_DESCRIPTION_SIZE] = '\0';
tmp_desc = remap_node_name(sm->p_subn->p_osm->node_name_map,
cl_ntoh64(osm_node_get_node_guid(p_node)),
print_desc);
/* make a copy for this node to "own" */
if (p_node->print_desc)
free(p_node->print_desc);
p_node->print_desc = tmp_desc;
#ifdef ENABLE_OSM_PERF_MGR
/* update the perfmgr entry if available */
osm_perfmgr_update_nodename(&sm->p_subn->p_osm->perfmgr,
cl_ntoh64(osm_node_get_node_guid(p_node)),
p_node->print_desc);
#endif /* ENABLE_OSM_PERF_MGR */
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Node 0x%" PRIx64 ", Description = %s\n",
cl_ntoh64(osm_node_get_node_guid(p_node)), p_node->print_desc);
OSM_LOG_EXIT(sm->p_log);
}
static void state_mgr_get_sw_info(IN cl_map_item_t * p_object, IN void *context)
{
osm_node_t *p_node;
osm_dr_path_t *p_dr_path;
osm_madw_context_t mad_context;
osm_switch_t *const p_sw = (osm_switch_t *) p_object;
osm_sm_t *sm = context;
ib_api_status_t status;
OSM_LOG_ENTER(sm->p_log);
p_node = p_sw->p_node;
p_dr_path =
osm_physp_get_dr_path_ptr(osm_node_get_physp_ptr(p_node, 0));
memset(&mad_context, 0, sizeof(mad_context));
mad_context.si_context.node_guid = osm_node_get_node_guid(p_node);
mad_context.si_context.set_method = FALSE;
mad_context.si_context.light_sweep = TRUE;
status = osm_req_get(sm, p_dr_path, IB_MAD_ATTR_SWITCH_INFO, 0,
OSM_MSG_LIGHT_SWEEP_FAIL, &mad_context);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3304: "
"Request for SwitchInfo failed (%s)\n",
ib_get_err_str(status));
OSM_LOG_EXIT(sm->p_log);
}
/**********************************************************************
o13-12.1.1: Confirm a valid request for event subscription by responding
with an InformInfo attribute that is a copy of the data in the
Set(InformInfo) request.
**********************************************************************/
static void
__osm_infr_rcv_respond(IN osm_sa_t * sa,
IN osm_madw_t * const p_madw)
{
cl_qlist_t rec_list;
osm_iir_item_t *item;
OSM_LOG_ENTER(sa->p_log);
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Generating successful InformInfo response\n");
item = malloc(sizeof(*item));
if (!item) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4303: "
"rec_item alloc failed\n");
goto Exit;
}
memcpy(&item->rec,
ib_sa_mad_get_payload_ptr(osm_madw_get_sa_mad_ptr(p_madw)),
sizeof(item->rec));
cl_qlist_init(&rec_list);
cl_qlist_insert_tail(&rec_list, &item->list_item);
osm_sa_respond(sa, p_madw, sizeof(ib_inform_info_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osmv_txn_abort_rmpp_txns(osm_bind_handle_t h_bind)
{
osmv_bind_obj_t *p_bo = (osmv_bind_obj_t *) h_bind;
cl_map_item_t *p_item;
cl_map_obj_t *p_obj;
osmv_txn_ctx_t *p_txn;
osmv_rmpp_send_ctx_t *p_send_ctx;
cl_qmap_t *p_map = p_bo->txn_mgr.p_txn_map;
OSM_LOG_ENTER(p_bo->p_vendor->p_log);
while (FALSE == cl_is_qmap_empty(p_map)) {
p_item = cl_qmap_head(p_map);
p_obj = PARENT_STRUCT(p_item, cl_map_obj_t, item);
p_txn = (osmv_txn_ctx_t *) cl_qmap_obj(p_obj);
p_send_ctx = osmv_txn_get_rmpp_send_ctx(p_txn);
if (NULL != p_send_ctx) {
p_send_ctx->status = IB_INTERRUPTED;
/* Wake up the sender thread to let it break out */
cl_event_signal(&p_send_ctx->event);
}
cl_qmap_remove_item(p_map, p_item);
}
OSM_LOG_EXIT(p_bo->p_vendor->p_log);
}
boolean_t osm_port_share_pkey(IN osm_log_t * p_log,
IN const osm_port_t * p_port_1,
IN const osm_port_t * p_port_2,
IN boolean_t allow_both_pkeys)
{
osm_physp_t *p_physp1, *p_physp2;
boolean_t ret;
OSM_LOG_ENTER(p_log);
if (!p_port_1 || !p_port_2) {
ret = FALSE;
goto Exit;
}
p_physp1 = p_port_1->p_physp;
p_physp2 = p_port_2->p_physp;
if (!p_physp1 || !p_physp2) {
ret = FALSE;
goto Exit;
}
ret = osm_physp_share_pkey(p_log, p_physp1, p_physp2, allow_both_pkeys);
Exit:
OSM_LOG_EXIT(p_log);
return ret;
}
/**********************************************************************
* Go over all the remote SMs (as updated in the sm_guid_tbl).
* Find if there is a remote sm that is a master SM.
* If there is a remote master SM - return a pointer to it,
* else - return NULL.
**********************************************************************/
static osm_remote_sm_t *state_mgr_exists_other_master_sm(IN osm_sm_t * sm)
{
cl_qmap_t *p_sm_tbl;
osm_remote_sm_t *p_sm;
osm_remote_sm_t *p_sm_res = NULL;
OSM_LOG_ENTER(sm->p_log);
p_sm_tbl = &sm->p_subn->sm_guid_tbl;
/* go over all the remote SMs */
for (p_sm = (osm_remote_sm_t *) cl_qmap_head(p_sm_tbl);
p_sm != (osm_remote_sm_t *) cl_qmap_end(p_sm_tbl);
p_sm = (osm_remote_sm_t *) cl_qmap_next(&p_sm->map_item)) {
/* If the sm is in MASTER state - return a pointer to it */
if (ib_sminfo_get_state(&p_sm->smi) == IB_SMINFO_STATE_MASTER) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Found remote master SM with guid:0x%016" PRIx64
" (node %s)\n", cl_ntoh64(p_sm->smi.guid),
p_sm->p_port->p_node ? p_sm->p_port->p_node->
print_desc : "UNKNOWN");
p_sm_res = p_sm;
goto Exit;
}
}
Exit:
OSM_LOG_EXIT(sm->p_log);
return p_sm_res;
}
void osm_nd_rcv_process(IN void *context, IN void *data)
{
osm_sm_t *sm = context;
osm_madw_t *p_madw = data;
ib_node_desc_t *p_nd;
ib_smp_t *p_smp;
osm_node_t *p_node;
ib_net64_t node_guid;
CL_ASSERT(sm);
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_nd = ib_smp_get_payload_ptr(p_smp);
/* Acquire the node object and add the node description. */
node_guid = osm_madw_get_nd_context_ptr(p_madw)->node_guid;
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
p_node = osm_get_node_by_guid(sm->p_subn, node_guid);
if (!p_node)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0B01: "
"NodeDescription received for nonexistent node "
"0x%" PRIx64 "\n", cl_ntoh64(node_guid));
else
nd_rcv_process_nd(sm, p_node, p_nd);
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG_EXIT(sm->p_log);
}
static void
__osm_sm_mad_ctrl_retire_trans_mad(IN osm_sm_mad_ctrl_t * const p_ctrl,
IN osm_madw_t * const p_madw)
{
uint32_t outstanding;
OSM_LOG_ENTER(p_ctrl->p_log);
CL_ASSERT(p_madw);
/*
Return the MAD & wrapper to the pool.
*/
OSM_LOG(p_ctrl->p_log, OSM_LOG_DEBUG,
"Retiring MAD with TID 0x%" PRIx64 "\n",
cl_ntoh64(osm_madw_get_smp_ptr(p_madw)->trans_id));
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
outstanding = osm_stats_dec_qp0_outstanding(p_ctrl->p_stats);
OSM_LOG(p_ctrl->p_log, OSM_LOG_DEBUG, "%u QP0 MADs outstanding%s\n",
p_ctrl->p_stats->qp0_mads_outstanding,
outstanding ? "" : ": wire is clean.");
OSM_LOG_EXIT(p_ctrl->p_log);
}
/*
Send Error Callback:
Only report the error and get rid of the mad wrapper
*/
static void __osmv_sa_mad_err_cb(IN void *bind_context, IN osm_madw_t * p_madw)
{
osmv_sa_bind_info_t *p_bind = (osmv_sa_bind_info_t *) bind_context;
osmv_query_req_t *p_query_req_copy = NULL;
osmv_query_res_t query_res;
OSM_LOG_ENTER(p_bind->p_log);
/* Obtain the sent context etc */
p_query_req_copy =
(osmv_query_req_t *) (long *)(long)(p_madw->context.ni_context.
node_guid);
/* provide the context of the original request in the result */
query_res.query_context = p_query_req_copy->query_context;
query_res.p_result_madw = p_madw;
query_res.status = IB_TIMEOUT;
query_res.result_cnt = 0;
query_res.query_type = p_query_req_copy->query_type;
p_query_req_copy->pfn_query_cb(&query_res);
if ((p_query_req_copy->flags & OSM_SA_FLAGS_SYNC) == OSM_SA_FLAGS_SYNC)
cl_event_signal(&p_bind->sync_event);
if (p_query_req_copy)
free(p_query_req_copy);
OSM_LOG_EXIT(p_bind->p_log);
}
/**********************************************************************
The plock must be held before calling this function.
**********************************************************************/
static void ni_rcv_get_node_desc(IN osm_sm_t * sm, IN osm_node_t * p_node,
IN const osm_madw_t * p_madw)
{
ib_node_info_t *p_ni;
ib_smp_t *p_smp;
uint8_t port_num;
osm_physp_t *p_physp = NULL;
OSM_LOG_ENTER(sm->p_log);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_ni = ib_smp_get_payload_ptr(p_smp);
port_num = ib_node_info_get_local_port_num(p_ni);
/*
Request PortInfo & NodeDescription attributes for the port
that responded to the NodeInfo attribute.
Because this is a channel adapter or router, we are
not allowed to request PortInfo for the other ports.
Set the context union properly, so the recipient
knows which node & port are relevant.
*/
p_physp = osm_node_get_physp_ptr(p_node, port_num);
if (!p_physp) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR OD1F: "
"Failed to find physp for port %d of Node GUID 0x%"
PRIx64 "\n", port_num,
cl_ntoh64(osm_node_get_node_guid(p_node)));
return;
}
osm_req_get_node_desc(sm, p_physp);
OSM_LOG_EXIT(sm->p_log);
}
void osm_infir_rcv_process(IN void *context, IN void *data)
{
osm_sa_t *sa = context;
osm_madw_t *p_madw = data;
ib_sa_mad_t *p_sa_mad;
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
CL_ASSERT(p_sa_mad->attr_id == IB_MAD_ATTR_INFORM_INFO_RECORD);
if (p_sa_mad->method != IB_MAD_METHOD_GET &&
p_sa_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG, "Unsupported Method (%s)\n",
ib_get_sa_method_str(p_sa_mad->method));
osm_sa_send_error(sa, p_madw, IB_MAD_STATUS_UNSUP_METHOD_ATTR);
goto Exit;
}
osm_infr_rcv_process_get_method(sa, p_madw);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_state_mgr_process(IN osm_sm_t * sm, IN osm_signal_t signal)
{
CL_ASSERT(sm);
OSM_LOG_ENTER(sm->p_log);
OSM_LOG(sm->p_log, OSM_LOG_DEBUG, "Received signal %s in state %s\n",
osm_get_sm_signal_str(signal),
osm_get_sm_mgr_state_str(sm->p_subn->sm_state));
switch (signal) {
case OSM_SIGNAL_SWEEP:
if (!sm->p_subn->sweeping_enabled) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG, "sweeping disabled - "
"ignoring signal %s in state %s\n",
osm_get_sm_signal_str(signal),
osm_get_sm_mgr_state_str(sm->p_subn->sm_state));
} else
do_sweep(sm);
break;
case OSM_SIGNAL_IDLE_TIME_PROCESS_REQUEST:
do_process_mgrp_queue(sm);
break;
default:
CL_ASSERT(FALSE);
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3320: "
"Invalid SM signal %u\n", signal);
break;
}
OSM_LOG_EXIT(sm->p_log);
}
/****f* opensm: SM/__osm_sm_mad_ctrl_process_set
* NAME
* __osm_sm_mad_ctrl_process_set
*
* DESCRIPTION
* This function handles method Set() for received MADs.
*
* SYNOPSIS
*/
static void
__osm_sm_mad_ctrl_process_set(IN osm_sm_mad_ctrl_t * const p_ctrl,
IN osm_madw_t * p_madw)
{
ib_smp_t *p_smp;
cl_status_t status;
cl_disp_msgid_t msg_id = CL_DISP_MSGID_NONE;
OSM_LOG_ENTER(p_ctrl->p_log);
p_smp = osm_madw_get_smp_ptr(p_madw);
/*
Note that attr_id (like the rest of the MAD) is in
network byte order.
*/
switch (p_smp->attr_id) {
case IB_MAD_ATTR_SM_INFO:
msg_id = OSM_MSG_MAD_SM_INFO;
break;
default:
cl_atomic_inc(&p_ctrl->p_stats->qp0_mads_rcvd_unknown);
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 3107: "
"Unsupported attribute = 0x%X\n",
cl_ntoh16(p_smp->attr_id));
osm_dump_dr_smp(p_ctrl->p_log, p_smp, OSM_LOG_ERROR);
break;
}
if (msg_id == CL_DISP_MSGID_NONE) {
/*
There is an unknown MAD attribute type for which there is
no recipient. Simply retire the MAD here.
*/
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
goto Exit;
}
/*
Post this MAD to the dispatcher for asynchronous
processing by the appropriate controller.
*/
OSM_LOG(p_ctrl->p_log, OSM_LOG_DEBUG, "Posting Dispatcher message %s\n",
osm_get_disp_msg_str(msg_id));
status = cl_disp_post(p_ctrl->h_disp, msg_id, p_madw,
__osm_sm_mad_ctrl_disp_done_callback, p_ctrl);
if (status != CL_SUCCESS) {
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 3108: "
"Dispatcher post message failed (%s)\n",
CL_STATUS_MSG(status));
goto Exit;
}
Exit:
OSM_LOG_EXIT(p_ctrl->p_log);
}
void osm_vendor_set_sm(IN osm_bind_handle_t h_bind, IN boolean_t is_sm_val)
{
osmv_bind_obj_t *p_bo = (osmv_bind_obj_t *) h_bind;
osm_vendor_t const *p_vend = p_bo->p_vendor;
int ts_ioctl_ret;
int device_fd =
((osmv_TOPSPIN_transport_mgr_t *) (p_bo->p_transp_mgr))->device_fd;
struct ib_set_port_info_ioctl set_port_data;
OSM_LOG_ENTER(p_vend->p_log);
memset(&set_port_data, 0, sizeof(set_port_data));
set_port_data.port = p_bo->port_num;
set_port_data.port_info.valid_fields = IB_PORT_IS_SM;
set_port_data.port_info.is_sm = is_sm_val;
ts_ioctl_ret = ioctl(device_fd, TS_IB_IOCSPORTINFO, &set_port_data);
if (ts_ioctl_ret < 0) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_vendor_set_sm: ERR 6805: "
"Unable set 'IS_SM' bit to:%u in port attributes (%d).\n",
is_sm_val, ts_ioctl_ret);
}
OSM_LOG_EXIT(p_vend->p_log);
}
osm_signal_t osm_link_mgr_process(osm_sm_t * sm, IN const uint8_t link_state)
{
cl_qmap_t *p_node_guid_tbl;
osm_node_t *p_node;
osm_signal_t signal = OSM_SIGNAL_DONE;
OSM_LOG_ENTER(sm->p_log);
p_node_guid_tbl = &sm->p_subn->node_guid_tbl;
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
for (p_node = (osm_node_t *) cl_qmap_head(p_node_guid_tbl);
p_node != (osm_node_t *) cl_qmap_end(p_node_guid_tbl);
p_node = (osm_node_t *) cl_qmap_next(&p_node->map_item)) {
if (__osm_link_mgr_process_node(sm, p_node, link_state) ==
OSM_SIGNAL_DONE_PENDING)
signal = OSM_SIGNAL_DONE_PENDING;
}
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG_EXIT(sm->p_log);
return (signal);
}
osm_vendor_t *osm_vendor_new(IN osm_log_t * const p_log,
IN const uint32_t timeout)
{
ib_api_status_t status;
umadt_obj_t *p_umadt_obj;
OSM_LOG_ENTER(p_log);
p_umadt_obj = malloc(sizeof(umadt_obj_t));
if (p_umadt_obj) {
memset(p_umadt_obj, 0, sizeof(umadt_obj_t));
status = osm_vendor_init((osm_vendor_t *) p_umadt_obj, p_log,
timeout);
if (status != IB_SUCCESS) {
osm_vendor_delete((osm_vendor_t **) & p_umadt_obj);
}
} else {
printf
("osm_vendor_construct: ERROR! Unable to create Umadt object!\n");
}
OSM_LOG_EXIT(p_log);
return ((osm_vendor_t *) p_umadt_obj);
}
static void ni_rcv_process_switch(IN osm_sm_t * sm, IN osm_node_t * p_node,
IN const osm_madw_t * p_madw)
{
ib_api_status_t status = IB_SUCCESS;
osm_physp_t *p_physp;
osm_madw_context_t context;
osm_dr_path_t *path;
ib_smp_t *p_smp;
OSM_LOG_ENTER(sm->p_log);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_physp = osm_node_get_physp_ptr(p_node, 0);
/* update DR path of already initialized switch port 0 */
path = osm_physp_get_dr_path_ptr(p_physp);
osm_dr_path_init(path, p_smp->hop_count, p_smp->initial_path);
context.si_context.node_guid = osm_node_get_node_guid(p_node);
context.si_context.set_method = FALSE;
context.si_context.light_sweep = FALSE;
context.si_context.lft_top_change = FALSE;
/* Request a SwitchInfo attribute */
status = osm_req_get(sm, path, IB_MAD_ATTR_SWITCH_INFO, 0, TRUE, 0,
CL_DISP_MSGID_NONE, &context);
if (status != IB_SUCCESS)
/* continue despite error */
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D06: "
"Failure initiating SwitchInfo request (%s)\n",
ib_get_err_str(status));
OSM_LOG_EXIT(sm->p_log);
}
void osm_vendor_delete(IN osm_vendor_t ** const pp_vend)
{
umadt_obj_t *p_umadt_obj = (umadt_obj_t *) * pp_vend;
cl_list_item_t *p_list_item;
uint32_t count, i;
mad_bind_info_t *p_mad_bind_info;
OSM_LOG_ENTER(p_umadt_obj->p_log);
cl_spinlock_acquire(&p_umadt_obj->register_lock);
p_mad_bind_info =
(mad_bind_info_t *) cl_qlist_head(&p_umadt_obj->register_list);
count = cl_qlist_count(&p_umadt_obj->register_list);
cl_spinlock_release(&p_umadt_obj->register_lock);
for (i = 0; i < count; i++) {
cl_spinlock_acquire(&p_umadt_obj->register_lock);
p_list_item = cl_qlist_next(&p_mad_bind_info->list_item);
cl_spinlock_release(&p_umadt_obj->register_lock);
/* Unbind this handle */
/* osm_vendor_ubind also removesd the item from the list */
/* osm_vendor_unbind takes the list lock so release it here */
osm_vendor_unbind((osm_bind_handle_t) p_mad_bind_info);
p_mad_bind_info = (mad_bind_info_t *) p_list_item;
}
dlclose(p_umadt_obj->umadt_handle);
free(p_umadt_obj);
*pp_vend = NULL;
OSM_LOG_EXIT(p_umadt_obj->p_log);
}
