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);
}
/**********************************************************************
* 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);
}
void osm_mpr_rcv_process(IN void *context, IN void *data)
{
osm_sa_t *sa = context;
osm_madw_t *p_madw = data;
const ib_multipath_rec_t *p_mpr;
ib_sa_mad_t *p_sa_mad;
osm_port_t *requester_port;
osm_alias_guid_t *pp_alias_guids[IB_MULTIPATH_MAX_GIDS];
cl_qlist_t pr_list;
ib_net16_t sa_status;
int nsrc, ndest;
uint8_t rate, mtu;
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_mpr = (ib_multipath_rec_t *) ib_sa_mad_get_payload_ptr(p_sa_mad);
CL_ASSERT(p_sa_mad->attr_id == IB_MAD_ATTR_MULTIPATH_RECORD);
if ((p_sa_mad->rmpp_flags & IB_RMPP_FLAG_ACTIVE) != IB_RMPP_FLAG_ACTIVE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4510: "
"Invalid request since RMPP_FLAG_ACTIVE is not set\n");
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
}
/* we only support SubnAdmGetMulti method */
if (p_sa_mad->method != IB_MAD_METHOD_GETMULTI) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4513: "
"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;
}
/* update the requester physical port */
requester_port = osm_get_port_by_mad_addr(sa->p_log, sa->p_subn,
osm_madw_get_mad_addr_ptr
(p_madw));
if (requester_port == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4517: "
"Cannot find requester physical port\n");
goto Exit;
}
if (OSM_LOG_IS_ACTIVE_V2(sa->p_log, OSM_LOG_DEBUG)) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Requester port GUID 0x%" PRIx64 "\n",
cl_ntoh64(osm_port_get_guid(requester_port)));
osm_dump_multipath_record_v2(sa->p_log, p_mpr, FILE_ID, OSM_LOG_DEBUG);
}
/* Make sure required components (S/DGIDCount) are supplied */
if (!(p_sa_mad->comp_mask & IB_MPR_COMPMASK_SGIDCOUNT) ||
!(p_sa_mad->comp_mask & IB_MPR_COMPMASK_DGIDCOUNT)) {
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_INSUF_COMPS);
goto Exit;
}
/* Validate rate if supplied */
if ((p_sa_mad->comp_mask & IB_MPR_COMPMASK_RATESELEC) &&
(p_sa_mad->comp_mask & IB_MPR_COMPMASK_RATE)) {
rate = ib_multipath_rec_rate(p_mpr);
if (!ib_rate_is_valid(rate)) {
osm_sa_send_error(sa, p_madw,
IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
}
}
/* Validate MTU if supplied */
if ((p_sa_mad->comp_mask & IB_MPR_COMPMASK_MTUSELEC) &&
(p_sa_mad->comp_mask & IB_MPR_COMPMASK_MTU)) {
mtu = ib_multipath_rec_mtu(p_mpr);
if (!ib_mtu_is_valid(mtu)) {
osm_sa_send_error(sa, p_madw,
IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
}
}
/* Make sure either none or both ServiceID parameters are supplied */
if ((p_sa_mad->comp_mask & IB_MPR_COMPMASK_SERVICEID) != 0 &&
(p_sa_mad->comp_mask & IB_MPR_COMPMASK_SERVICEID) !=
IB_MPR_COMPMASK_SERVICEID) {
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_INSUF_COMPS);
goto Exit;
}
cl_qlist_init(&pr_list);
/*
Most SA functions (including this one) are read-only on the
subnet object, so we grab the lock non-exclusively.
*/
cl_plock_acquire(sa->p_lock);
sa_status = mpr_rcv_get_end_points(sa, p_madw, pp_alias_guids,
&nsrc, &ndest);
if (sa_status != IB_SA_MAD_STATUS_SUCCESS || !nsrc || !ndest) {
if (sa_status == IB_SA_MAD_STATUS_SUCCESS && (!nsrc || !ndest))
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4512: "
"mpr_rcv_get_end_points failed, # GIDs found; "
"src %d; dest %d)\n", nsrc, ndest);
cl_plock_release(sa->p_lock);
if (sa_status == IB_SA_MAD_STATUS_SUCCESS)
osm_sa_send_error(sa, p_madw,
IB_SA_MAD_STATUS_REQ_INVALID);
else
osm_sa_send_error(sa, p_madw, sa_status);
goto Exit;
}
/* APM request */
if (nsrc == 2 && ndest == 2 && (p_mpr->num_path & 0x7F) == 2)
mpr_rcv_get_apm_paths(sa, p_mpr, requester_port, pp_alias_guids,
p_sa_mad->comp_mask, &pr_list);
else
mpr_rcv_process_pairs(sa, p_mpr, requester_port, pp_alias_guids,
nsrc, ndest, p_sa_mad->comp_mask,
&pr_list);
cl_plock_release(sa->p_lock);
/* o15-0.2.7: If MultiPath is supported, then SA shall respond to a
SubnAdmGetMulti() containing a valid MultiPathRecord attribute with
a set of zero or more PathRecords satisfying the constraints
indicated in the MultiPathRecord received. The PathRecord Attribute
ID shall be used in the response.
*/
p_sa_mad->attr_id = IB_MAD_ATTR_PATH_RECORD;
osm_sa_respond(sa, p_madw, sizeof(ib_path_rec_t), &pr_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_slvl_rec_rcv_process(IN void *ctx, IN void *data)
{
osm_sa_t *sa = ctx;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *p_rcvd_mad;
const ib_slvl_table_record_t *p_rcvd_rec;
const osm_port_t *p_port = NULL;
cl_qlist_t rec_list;
osm_slvl_search_ctxt_t context;
ib_api_status_t status = IB_SUCCESS;
ib_net64_t comp_mask;
osm_physp_t *p_req_physp;
CL_ASSERT(sa);
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_rcvd_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec =
(ib_slvl_table_record_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
comp_mask = p_rcvd_mad->comp_mask;
CL_ASSERT(p_rcvd_mad->attr_id == IB_MAD_ATTR_SLVL_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (p_rcvd_mad->method != IB_MAD_METHOD_GET &&
p_rcvd_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2604: "
"Unsupported Method (%s)\n",
ib_get_sa_method_str(p_rcvd_mad->method));
osm_sa_send_error(sa, p_madw, IB_MAD_STATUS_UNSUP_METHOD_ATTR);
goto Exit;
}
/* update the requester physical port. */
p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
osm_madw_get_mad_addr_ptr
(p_madw));
if (p_req_physp == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2603: "
"Cannot find requester physical port\n");
goto Exit;
}
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = p_rcvd_mad->comp_mask;
context.sa = sa;
context.in_port_num = p_rcvd_rec->in_port_num;
context.p_req_physp = p_req_physp;
cl_plock_acquire(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Got Query Lid:%u(%02X), In-Port:0x%02X(%02X), Out-Port:0x%02X(%02X)\n",
cl_ntoh16(p_rcvd_rec->lid),
(comp_mask & IB_SLVL_COMPMASK_LID) != 0,
p_rcvd_rec->in_port_num,
(comp_mask & IB_SLVL_COMPMASK_IN_PORT) != 0,
p_rcvd_rec->out_port_num,
(comp_mask & IB_SLVL_COMPMASK_OUT_PORT) != 0);
/*
If the user specified a LID, it obviously narrows our
work load, since we don't have to search every port
*/
if (comp_mask & IB_SLVL_COMPMASK_LID) {
status =
osm_get_port_by_base_lid(sa->p_subn, p_rcvd_rec->lid,
&p_port);
if ((status != IB_SUCCESS) || (p_port == NULL)) {
status = IB_NOT_FOUND;
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2608: "
"No port found with LID %u\n",
cl_ntoh16(p_rcvd_rec->lid));
}
}
if (status == IB_SUCCESS) {
/* if we have a unique port - no need for a port search */
if (p_port)
/* this does the loop on all the port phys ports */
__osm_sa_slvl_by_comp_mask(sa, p_port, &context);
else
cl_qmap_apply_func(&sa->p_subn->port_guid_tbl,
__osm_sa_slvl_by_comp_mask_cb,
&context);
}
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_slvl_table_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
/*********************************************************************
Received a Set(InformInfo) MAD
**********************************************************************/
static void
osm_infr_rcv_process_set_method(IN osm_sa_t * sa,
IN osm_madw_t * const p_madw)
{
ib_sa_mad_t *p_sa_mad;
ib_inform_info_t *p_recvd_inform_info;
osm_infr_t inform_info_rec; /* actual inform record to be stored for reports */
osm_infr_t *p_infr;
ib_net32_t qpn;
uint8_t resp_time_val;
ib_api_status_t res;
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_recvd_inform_info =
(ib_inform_info_t *) ib_sa_mad_get_payload_ptr(p_sa_mad);
#if 0
if (osm_log_is_active(sa->p_log, OSM_LOG_DEBUG))
osm_dump_inform_info(sa->p_log, p_recvd_inform_info,
OSM_LOG_DEBUG);
#endif
/* Grab the lock */
cl_plock_excl_acquire(sa->p_lock);
/* define the inform record */
inform_info_rec.inform_record.inform_info = *p_recvd_inform_info;
/* following C13-32.1.2 Tbl 120: we only copy the source address vector */
inform_info_rec.report_addr = p_madw->mad_addr;
/* we will need to know the mad srvc to send back through */
inform_info_rec.h_bind = p_madw->h_bind;
inform_info_rec.sa = sa;
/* update the subscriber GID according to mad address */
res = osm_get_gid_by_mad_addr(sa->p_log, sa->p_subn, &p_madw->mad_addr,
&inform_info_rec.inform_record.
subscriber_gid);
if (res != IB_SUCCESS) {
cl_plock_release(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4308 "
"Subscribe Request from unknown LID: %u\n",
cl_ntoh16(p_madw->mad_addr.dest_lid));
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
}
/* HACK: enum is always 0 (currently) */
inform_info_rec.inform_record.subscriber_enum = 0;
/* Subscribe values above 1 are undefined */
if (p_recvd_inform_info->subscribe > 1) {
cl_plock_release(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4308 "
"Invalid subscribe: %d\n",
p_recvd_inform_info->subscribe);
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
}
/*
* MODIFICATIONS DONE ON INCOMING REQUEST:
*
* QPN:
* Internally we keep the QPN field of the InformInfo updated
* so we can simply compare it in the record - when finding such.
*/
if (p_recvd_inform_info->subscribe) {
ib_inform_info_set_qpn(&inform_info_rec.inform_record.
inform_info,
inform_info_rec.report_addr.addr_type.
gsi.remote_qp);
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Subscribe Request with QPN: 0x%06X\n",
cl_ntoh32(inform_info_rec.report_addr.addr_type.gsi.
remote_qp));
} else {
ib_inform_info_get_qpn_resp_time(p_recvd_inform_info->g_or_v.
generic.qpn_resp_time_val,
&qpn, &resp_time_val);
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"UnSubscribe Request with QPN: 0x%06X\n",
cl_ntoh32(qpn));
}
/* If record exists with matching InformInfo */
p_infr =
osm_infr_get_by_rec(sa->p_subn, sa->p_log, &inform_info_rec);
/* check to see if the request was for subscribe */
if (p_recvd_inform_info->subscribe) {
/* validate the request for a new or update InformInfo */
if (__validate_infr(sa, &inform_info_rec) != TRUE) {
cl_plock_release(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4305: "
"Failed to validate a new inform object\n");
/* o13-13.1.1: we need to set the subscribe bit to 0 */
p_recvd_inform_info->subscribe = 0;
osm_sa_send_error(sa, p_madw,
IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
}
/* ok - we can try and create a new entry */
if (p_infr == NULL) {
/* Create the instance of the osm_infr_t object */
p_infr = osm_infr_new(&inform_info_rec);
if (p_infr == NULL) {
cl_plock_release(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4306: "
"Failed to create a new inform object\n");
/* o13-13.1.1: we need to set the subscribe bit to 0 */
p_recvd_inform_info->subscribe = 0;
osm_sa_send_error(sa, p_madw,
IB_SA_MAD_STATUS_NO_RESOURCES);
goto Exit;
}
/* Add this new osm_infr_t object to subnet object */
osm_infr_insert_to_db(sa->p_subn, sa->p_log, p_infr);
} else
/* Update the old instance of the osm_infr_t object */
p_infr->inform_record = inform_info_rec.inform_record;
/* We got an UnSubscribe request */
} else if (p_infr == NULL) {
cl_plock_release(sa->p_lock);
/* No Such Item - So Error */
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4307: "
"Failed to UnSubscribe to non existing inform object\n");
/* o13-13.1.1: we need to set the subscribe bit to 0 */
p_recvd_inform_info->subscribe = 0;
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
} else
/* Delete this object from the subnet list of informs */
osm_infr_remove_from_db(sa->p_subn, sa->p_log, p_infr);
cl_plock_release(sa->p_lock);
/* send the success response */
__osm_infr_rcv_respond(sa, p_madw);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_pkey_rec_rcv_process(IN void *ctx, IN void *data)
{
osm_sa_t *sa = ctx;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *p_rcvd_mad;
const ib_pkey_table_record_t *p_rcvd_rec;
const osm_port_t *p_port = NULL;
const ib_pkey_table_t *p_pkey;
cl_qlist_t rec_list;
osm_pkey_search_ctxt_t context;
ib_api_status_t status = IB_SUCCESS;
ib_net64_t comp_mask;
osm_physp_t *p_req_physp;
CL_ASSERT(sa);
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_rcvd_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec =
(ib_pkey_table_record_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
comp_mask = p_rcvd_mad->comp_mask;
CL_ASSERT(p_rcvd_mad->attr_id == IB_MAD_ATTR_PKEY_TBL_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (p_rcvd_mad->method != IB_MAD_METHOD_GET &&
p_rcvd_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4605: "
"Unsupported Method (%s)\n",
ib_get_sa_method_str(p_rcvd_mad->method));
osm_sa_send_error(sa, p_madw, IB_MAD_STATUS_UNSUP_METHOD_ATTR);
goto Exit;
}
/*
p922 - P_KeyTableRecords shall only be provided in response
to trusted requests.
Check that the requester is a trusted one.
*/
if (p_rcvd_mad->sm_key != sa->p_subn->opt.sa_key) {
/* This is not a trusted requester! */
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4608: "
"Request from non-trusted requester: "
"Given SM_Key:0x%016" PRIx64 "\n",
cl_ntoh64(p_rcvd_mad->sm_key));
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_REQ_INVALID);
goto Exit;
}
/* update the requester physical port. */
p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
osm_madw_get_mad_addr_ptr
(p_madw));
if (p_req_physp == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4604: "
"Cannot find requester physical port\n");
goto Exit;
}
p_pkey = (ib_pkey_table_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = p_rcvd_mad->comp_mask;
context.sa = sa;
context.block_num = p_rcvd_rec->block_num;
context.p_req_physp = p_req_physp;
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Got Query Lid:%u(%02X), Block:0x%02X(%02X), Port:0x%02X(%02X)\n",
cl_ntoh16(p_rcvd_rec->lid),
(comp_mask & IB_PKEY_COMPMASK_LID) != 0, p_rcvd_rec->port_num,
(comp_mask & IB_PKEY_COMPMASK_PORT) != 0, p_rcvd_rec->block_num,
(comp_mask & IB_PKEY_COMPMASK_BLOCK) != 0);
cl_plock_acquire(sa->p_lock);
/*
If the user specified a LID, it obviously narrows our
work load, since we don't have to search every port
*/
if (comp_mask & IB_PKEY_COMPMASK_LID) {
status = osm_get_port_by_base_lid(sa->p_subn, p_rcvd_rec->lid,
&p_port);
if (status != IB_SUCCESS || p_port == NULL) {
status = IB_NOT_FOUND;
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 460B: "
"No port found with LID %u\n",
cl_ntoh16(p_rcvd_rec->lid));
}
}
if (status == IB_SUCCESS) {
/* if we got a unique port - no need for a port search */
if (p_port)
/* this does the loop on all the port phys ports */
__osm_sa_pkey_by_comp_mask(sa, p_port, &context);
else
cl_qmap_apply_func(&sa->p_subn->port_guid_tbl,
__osm_sa_pkey_by_comp_mask_cb,
&context);
}
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_pkey_table_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_lftr_rcv_process(IN void *ctx, IN void *data)
{
osm_sa_t *sa = ctx;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *p_rcvd_mad;
const ib_lft_record_t *p_rcvd_rec;
cl_qlist_t rec_list;
osm_lftr_search_ctxt_t context;
osm_physp_t *p_req_physp;
CL_ASSERT(sa);
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_rcvd_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec = (ib_lft_record_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
CL_ASSERT(p_rcvd_mad->attr_id == IB_MAD_ATTR_LFT_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (p_rcvd_mad->method != IB_MAD_METHOD_GET &&
p_rcvd_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4408: "
"Unsupported Method (%s)\n",
ib_get_sa_method_str(p_rcvd_mad->method));
osm_sa_send_error(sa, p_madw, IB_MAD_STATUS_UNSUP_METHOD_ATTR);
goto Exit;
}
/* update the requester physical port */
p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
osm_madw_get_mad_addr_ptr
(p_madw));
if (p_req_physp == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4407: "
"Cannot find requester physical port\n");
goto Exit;
}
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Requester port GUID 0x%" PRIx64 "\n",
cl_ntoh64(osm_physp_get_port_guid(p_req_physp)));
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = p_rcvd_mad->comp_mask;
context.sa = sa;
context.p_req_physp = p_req_physp;
cl_plock_acquire(sa->p_lock);
/* Go over all switches */
cl_qmap_apply_func(&sa->p_subn->sw_guid_tbl, lftr_rcv_by_comp_mask,
&context);
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_lft_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_smir_rcv_process(IN void *ctx, IN void *data)
{
osm_sa_t *sa = ctx;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *sad_mad;
const ib_sminfo_record_t *p_rcvd_rec;
const osm_port_t *p_port = NULL;
const ib_sm_info_t *p_smi;
cl_qlist_t rec_list;
osm_smir_search_ctxt_t context;
ib_api_status_t status = IB_SUCCESS;
ib_net64_t comp_mask;
ib_net64_t port_guid;
osm_physp_t *p_req_physp;
osm_port_t *local_port;
osm_remote_sm_t *p_rem_sm;
cl_qmap_t *p_sm_guid_tbl;
uint8_t pri_state;
CL_ASSERT(sa);
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
sad_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec = (ib_sminfo_record_t *) ib_sa_mad_get_payload_ptr(sad_mad);
comp_mask = sad_mad->comp_mask;
CL_ASSERT(sad_mad->attr_id == IB_MAD_ATTR_SMINFO_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (sad_mad->method != IB_MAD_METHOD_GET &&
sad_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2804: "
"Unsupported Method (%s)\n",
ib_get_sa_method_str(sad_mad->method));
osm_sa_send_error(sa, p_madw, IB_MAD_STATUS_UNSUP_METHOD_ATTR);
goto Exit;
}
/* update the requester physical port */
p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
osm_madw_get_mad_addr_ptr
(p_madw));
if (p_req_physp == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2803: "
"Cannot find requester physical port\n");
goto Exit;
}
if (OSM_LOG_IS_ACTIVE_V2(sa->p_log, OSM_LOG_DEBUG)) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Requester port GUID 0x%" PRIx64 "\n",
cl_ntoh64(osm_physp_get_port_guid(p_req_physp)));
osm_dump_sm_info_record_v2(sa->p_log, p_rcvd_rec, FILE_ID, OSM_LOG_DEBUG);
}
p_smi = &p_rcvd_rec->sm_info;
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = sad_mad->comp_mask;
context.sa = sa;
context.p_req_physp = p_req_physp;
cl_plock_acquire(sa->p_lock);
/*
If the user specified a LID, it obviously narrows our
work load, since we don't have to search every port
*/
if (comp_mask & IB_SMIR_COMPMASK_LID) {
p_port = osm_get_port_by_lid(sa->p_subn, p_rcvd_rec->lid);
if (!p_port) {
status = IB_NOT_FOUND;
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2806: "
"No port found with LID %u\n",
cl_ntoh16(p_rcvd_rec->lid));
}
}
if (status == IB_SUCCESS) {
/* Handle our own SM first */
local_port = osm_get_port_by_guid(sa->p_subn,
sa->p_subn->sm_port_guid);
if (!local_port) {
cl_plock_release(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2809: "
"No port found with GUID 0x%016" PRIx64 "\n",
cl_ntoh64(sa->p_subn->sm_port_guid));
goto Exit;
}
if (!p_port || local_port == p_port) {
if (FALSE ==
osm_physp_share_pkey(sa->p_log, p_req_physp,
local_port->p_physp,
sa->p_subn->opt.allow_both_pkeys)) {
cl_plock_release(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2805: "
"Cannot get SMInfo record due to pkey violation\n");
goto Exit;
}
/* Check that other search components specified match */
if ((comp_mask & IB_SMIR_COMPMASK_GUID) &&
sa->p_subn->sm_port_guid != p_smi->guid)
goto Remotes;
if ((comp_mask & IB_SMIR_COMPMASK_PRIORITY) &&
sa->p_subn->opt.sm_priority !=
ib_sminfo_get_priority(p_smi))
goto Remotes;
if ((comp_mask & IB_SMIR_COMPMASK_SMSTATE) &&
sa->p_subn->sm_state != ib_sminfo_get_state(p_smi))
goto Remotes;
/* Now, add local SMInfo to list */
pri_state = sa->p_subn->sm_state & 0x0F;
pri_state |= (sa->p_subn->opt.sm_priority & 0x0F) << 4;
smir_rcv_new_smir(sa, local_port, context.p_list,
sa->p_subn->sm_port_guid,
cl_ntoh32(sa->p_subn->p_osm->stats.
qp0_mads_sent), pri_state,
p_req_physp);
}
Remotes:
if (p_port && p_port != local_port) {
/* Find remote SM corresponding to p_port */
port_guid = osm_port_get_guid(p_port);
p_sm_guid_tbl = &sa->p_subn->sm_guid_tbl;
p_rem_sm =
(osm_remote_sm_t *) cl_qmap_get(p_sm_guid_tbl,
port_guid);
if (p_rem_sm !=
(osm_remote_sm_t *) cl_qmap_end(p_sm_guid_tbl))
sa_smir_by_comp_mask(sa, p_rem_sm, &context);
else
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 280A: "
"No remote SM for GUID 0x%016" PRIx64
"\n", cl_ntoh64(port_guid));
} else {
/* Go over all other known (remote) SMs */
cl_qmap_apply_func(&sa->p_subn->sm_guid_tbl,
sa_smir_by_comp_mask_cb, &context);
}
}
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_sminfo_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_lr_rcv_process(IN void *context, IN void *data)
{
osm_sa_t *sa = context;
osm_madw_t *p_madw = data;
const ib_link_record_t *p_lr;
const ib_sa_mad_t *p_sa_mad;
const osm_port_t *p_src_port;
const osm_port_t *p_dest_port;
cl_qlist_t lr_list;
ib_net16_t status;
osm_physp_t *p_req_physp;
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_lr = ib_sa_mad_get_payload_ptr(p_sa_mad);
CL_ASSERT(p_sa_mad->attr_id == IB_MAD_ATTR_LINK_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (p_sa_mad->method != IB_MAD_METHOD_GET &&
p_sa_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 1804: "
"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;
}
/* update the requester physical port */
p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
osm_madw_get_mad_addr_ptr
(p_madw));
if (p_req_physp == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 1805: "
"Cannot find requester physical port\n");
goto Exit;
}
if (OSM_LOG_IS_ACTIVE_V2(sa->p_log, OSM_LOG_DEBUG)) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Requester port GUID 0x%" PRIx64 "\n",
cl_ntoh64(osm_physp_get_port_guid(p_req_physp)));
osm_dump_link_record_v2(sa->p_log, p_lr, FILE_ID, OSM_LOG_DEBUG);
}
cl_qlist_init(&lr_list);
/*
Most SA functions (including this one) are read-only on the
subnet object, so we grab the lock non-exclusively.
*/
cl_plock_acquire(sa->p_lock);
status = lr_rcv_get_end_points(sa, p_madw, &p_src_port, &p_dest_port);
if (status == IB_SA_MAD_STATUS_SUCCESS)
lr_rcv_get_port_links(sa, p_lr, p_src_port, p_dest_port,
p_sa_mad->comp_mask, &lr_list,
p_req_physp);
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_link_record_t), &lr_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_sa_respond(osm_sa_t *sa, osm_madw_t *madw, size_t attr_size,
cl_qlist_t *list)
{
struct item_data {
cl_list_item_t list;
char data[0];
};
cl_list_item_t *item;
osm_madw_t *resp_madw;
ib_sa_mad_t *sa_mad, *resp_sa_mad;
unsigned num_rec, i;
#ifndef VENDOR_RMPP_SUPPORT
unsigned trim_num_rec;
#endif
unsigned char *p;
sa_mad = osm_madw_get_sa_mad_ptr(madw);
num_rec = cl_qlist_count(list);
/*
* C15-0.1.30:
* If we do a SubnAdmGet and got more than one record it is an error!
*/
if (sa_mad->method == IB_MAD_METHOD_GET && num_rec > 1) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4C05: "
"Got %u records for SubnAdmGet(%s) comp_mask 0x%016" PRIx64 "\n",
num_rec, ib_get_sa_attr_str(sa_mad->attr_id),
cl_ntoh64(sa_mad->comp_mask));
osm_sa_send_error(sa, madw, IB_SA_MAD_STATUS_TOO_MANY_RECORDS);
goto Exit;
}
#ifndef VENDOR_RMPP_SUPPORT
trim_num_rec = (MAD_BLOCK_SIZE - IB_SA_MAD_HDR_SIZE) / attr_size;
if (trim_num_rec < num_rec) {
OSM_LOG(sa->p_log, OSM_LOG_VERBOSE,
"Number of records:%u trimmed to:%u to fit in one MAD\n",
num_rec, trim_num_rec);
num_rec = trim_num_rec;
}
#endif
OSM_LOG(sa->p_log, OSM_LOG_DEBUG, "Returning %u records\n", num_rec);
if (sa_mad->method == IB_MAD_METHOD_GET && num_rec == 0) {
osm_sa_send_error(sa, madw, IB_SA_MAD_STATUS_NO_RECORDS);
goto Exit;
}
/*
* Get a MAD to reply. Address of Mad is in the received mad_wrapper
*/
resp_madw = osm_mad_pool_get(sa->p_mad_pool, madw->h_bind,
num_rec * attr_size + IB_SA_MAD_HDR_SIZE,
&madw->mad_addr);
if (!resp_madw) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4C06: "
"osm_mad_pool_get failed\n");
osm_sa_send_error(sa, madw, IB_SA_MAD_STATUS_NO_RESOURCES);
goto Exit;
}
resp_sa_mad = osm_madw_get_sa_mad_ptr(resp_madw);
/*
Copy the MAD header back into the response mad.
Set the 'R' bit and the payload length,
Then copy all records from the list into the response payload.
*/
memcpy(resp_sa_mad, sa_mad, IB_SA_MAD_HDR_SIZE);
if (resp_sa_mad->method == IB_MAD_METHOD_SET)
resp_sa_mad->method = IB_MAD_METHOD_GET;
resp_sa_mad->method |= IB_MAD_METHOD_RESP_MASK;
/* C15-0.1.5 - always return SM_Key = 0 (table 185 p 884) */
resp_sa_mad->sm_key = 0;
/* Fill in the offset (paylen will be done by the rmpp SAR) */
resp_sa_mad->attr_offset = num_rec ? ib_get_attr_offset(attr_size) : 0;
p = ib_sa_mad_get_payload_ptr(resp_sa_mad);
#ifndef VENDOR_RMPP_SUPPORT
/* we support only one packet RMPP - so we will set the first and
last flags for gettable */
if (resp_sa_mad->method == IB_MAD_METHOD_GETTABLE_RESP) {
resp_sa_mad->rmpp_type = IB_RMPP_TYPE_DATA;
resp_sa_mad->rmpp_flags =
IB_RMPP_FLAG_FIRST | IB_RMPP_FLAG_LAST |
IB_RMPP_FLAG_ACTIVE;
}
#else
/* forcefully define the packet as RMPP one */
if (resp_sa_mad->method == IB_MAD_METHOD_GETTABLE_RESP)
resp_sa_mad->rmpp_flags = IB_RMPP_FLAG_ACTIVE;
#endif
for (i = 0; i < num_rec; i++) {
item = cl_qlist_remove_head(list);
memcpy(p, ((struct item_data *)item)->data, attr_size);
p += attr_size;
free(item);
}
osm_dump_sa_mad(sa->p_log, resp_sa_mad, OSM_LOG_FRAMES);
osm_sa_send(sa, resp_madw, FALSE);
Exit:
/* need to set the mem free ... */
item = cl_qlist_remove_head(list);
while (item != cl_qlist_end(list)) {
free(item);
item = cl_qlist_remove_head(list);
}
}
