/**********************************************************************
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 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 Get(InformInfoRecord) or GetTable(InformInfoRecord) MAD
**********************************************************************/
static void
osm_infr_rcv_process_get_method(IN osm_sa_t * sa,
IN osm_madw_t * const p_madw)
{
char gid_str[INET6_ADDRSTRLEN];
ib_sa_mad_t *p_rcvd_mad;
const ib_inform_info_record_t *p_rcvd_rec;
cl_qlist_t rec_list;
osm_iir_search_ctxt_t context;
osm_physp_t *p_req_physp;
osm_iir_item_t *item;
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_inform_info_record_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
/* 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 4309: "
"Cannot find requester physical port\n");
goto Exit;
}
if (osm_log_is_active(sa->p_log, OSM_LOG_DEBUG))
osm_dump_inform_info_record(sa->p_log, p_rcvd_rec,
OSM_LOG_DEBUG);
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.subscriber_gid = p_rcvd_rec->subscriber_gid;
context.subscriber_enum = p_rcvd_rec->subscriber_enum;
context.sa = sa;
context.p_req_physp = p_req_physp;
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Query Subscriber GID:%s(%02X) Enum:0x%X(%02X)\n",
inet_ntop(AF_INET6, p_rcvd_rec->subscriber_gid.raw,
gid_str, sizeof gid_str),
(p_rcvd_mad->comp_mask & IB_IIR_COMPMASK_SUBSCRIBERGID) != 0,
cl_ntoh16(p_rcvd_rec->subscriber_enum),
(p_rcvd_mad->comp_mask & IB_IIR_COMPMASK_ENUM) != 0);
cl_plock_acquire(sa->p_lock);
cl_qlist_apply_func(&sa->p_subn->sa_infr_list,
__osm_sa_inform_info_rec_by_comp_mask_cb, &context);
cl_plock_release(sa->p_lock);
/* clear reserved and pad fields in InformInfoRecord */
for (item = (osm_iir_item_t *) cl_qlist_head(&rec_list);
item != (osm_iir_item_t *) cl_qlist_end(&rec_list);
item = (osm_iir_item_t *)cl_qlist_next(&item->list_item)) {
memset(item->rec.reserved, 0, sizeof(item->rec.reserved));
memset(item->rec.pad, 0, sizeof(item->rec.pad));
}
osm_sa_respond(sa, p_madw, sizeof(ib_inform_info_record_t), &rec_list);
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);
}