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);
}
/**********************************************************************
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);
}
static ib_api_status_t
osm_switch_init(IN osm_switch_t * const p_sw,
IN osm_node_t * const p_node,
IN const osm_madw_t * const p_madw)
{
ib_api_status_t status = IB_SUCCESS;
ib_switch_info_t *p_si;
ib_smp_t *p_smp;
uint8_t num_ports;
uint32_t port_num;
p_smp = osm_madw_get_smp_ptr(p_madw);
p_si = (ib_switch_info_t *) ib_smp_get_payload_ptr(p_smp);
num_ports = osm_node_get_num_physp(p_node);
CL_ASSERT(p_smp->attr_id == IB_MAD_ATTR_SWITCH_INFO);
p_sw->p_node = p_node;
p_sw->switch_info = *p_si;
p_sw->num_ports = num_ports;
p_sw->need_update = 2;
/* Initiate the linear forwarding table */
if (!p_si->lin_cap) {
/* This switch does not support linear forwarding tables */
status = IB_UNSUPPORTED;
goto Exit;
}
p_sw->lft = malloc(IB_LID_UCAST_END_HO + 1);
if (!p_sw->lft) {
status = IB_INSUFFICIENT_MEMORY;
goto Exit;
}
/* Initialize the table to OSM_NO_PATH, which is "invalid port" */
memset(p_sw->lft, OSM_NO_PATH, IB_LID_UCAST_END_HO + 1);
p_sw->p_prof = malloc(sizeof(*p_sw->p_prof) * num_ports);
if (p_sw->p_prof == NULL) {
status = IB_INSUFFICIENT_MEMORY;
goto Exit;
}
memset(p_sw->p_prof, 0, sizeof(*p_sw->p_prof) * num_ports);
status = osm_mcast_tbl_init(&p_sw->mcast_tbl,
osm_node_get_num_physp(p_node),
cl_ntoh16(p_si->mcast_cap));
if (status != IB_SUCCESS)
goto Exit;
for (port_num = 0; port_num < num_ports; port_num++)
osm_port_prof_construct(&p_sw->p_prof[port_num]);
Exit:
return (status);
}
static void
osm_pi_rcv_process_set(IN osm_sm_t * sm, IN osm_node_t * const p_node,
IN const uint8_t port_num, IN osm_madw_t * const p_madw)
{
osm_physp_t *p_physp;
ib_net64_t port_guid;
ib_smp_t *p_smp;
ib_port_info_t *p_pi;
osm_pi_context_t *p_context;
osm_log_level_t level;
OSM_LOG_ENTER(sm->p_log);
p_context = osm_madw_get_pi_context_ptr(p_madw);
CL_ASSERT(p_node);
p_physp = osm_node_get_physp_ptr(p_node, port_num);
CL_ASSERT(p_physp);
port_guid = osm_physp_get_port_guid(p_physp);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_pi = (ib_port_info_t *) ib_smp_get_payload_ptr(p_smp);
/* check for error */
if (cl_ntoh16(p_smp->status) & 0x7fff) {
/* If port already ACTIVE, don't treat status 7 as error */
if (p_context->active_transition &&
(cl_ntoh16(p_smp->status) & 0x7fff) == 0x1c) {
level = OSM_LOG_INFO;
OSM_LOG(sm->p_log, OSM_LOG_INFO,
"Received error status 0x%x for SetResp() during ACTIVE transition\n",
cl_ntoh16(p_smp->status) & 0x7fff);
/* Should there be a subsequent Get to validate that port is ACTIVE ? */
} else {
level = OSM_LOG_ERROR;
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F10: "
"Received error status for SetResp()\n");
}
osm_dump_port_info(sm->p_log,
osm_node_get_node_guid(p_node),
port_guid, port_num, p_pi, level);
}
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Received logical SetResp() for GUID 0x%" PRIx64
", port num %u"
"\n\t\t\t\tfor parent node GUID 0x%" PRIx64
" TID 0x%" PRIx64 "\n",
cl_ntoh64(port_guid), port_num,
cl_ntoh64(osm_node_get_node_guid(p_node)),
cl_ntoh64(p_smp->trans_id));
osm_physp_set_port_info(p_physp, p_pi);
OSM_LOG_EXIT(sm->p_log);
}
osm_node_t *osm_node_new(IN const osm_madw_t * p_madw)
{
osm_node_t *p_node;
ib_smp_t *p_smp;
ib_node_info_t *p_ni;
uint8_t i;
uint32_t size;
p_smp = osm_madw_get_smp_ptr(p_madw);
p_ni = ib_smp_get_payload_ptr(p_smp);
/*
The node object already contains one physical port object.
Therefore, subtract 1 from the number of physical ports
used by the switch. This is not done for CA's since they
need to occupy 1 more physp than they physically have since
we still reserve room for a "port 0".
*/
size = p_ni->num_ports;
p_node = malloc(sizeof(*p_node) + sizeof(osm_physp_t) * size);
if (!p_node)
return NULL;
memset(p_node, 0, sizeof(*p_node) + sizeof(osm_physp_t) * size);
p_node->node_info = *p_ni;
p_node->physp_tbl_size = size + 1;
p_node->physp_discovered = malloc(sizeof(uint8_t) * p_node->physp_tbl_size);
if (!p_node->physp_discovered) {
free(p_node);
return NULL;
}
memset(p_node->physp_discovered, 0, sizeof(uint8_t) * p_node->physp_tbl_size);
/*
Construct Physical Port objects owned by this Node.
Then, initialize the Physical Port through with we
discovered this port.
For switches, all ports have the same GUID.
For CAs and routers, each port has a different GUID, so we only
know the GUID for the port that responded to our
Get(NodeInfo).
*/
for (i = 0; i < p_node->physp_tbl_size; i++)
osm_physp_construct(&p_node->physp_table[i]);
if (p_ni->node_type == IB_NODE_TYPE_SWITCH)
for (i = 0; i <= p_ni->num_ports; i++)
osm_node_init_physp(p_node, i, p_madw);
else
osm_node_init_physp(p_node,
ib_node_info_get_local_port_num(p_ni),
p_madw);
p_node->print_desc = strdup(OSM_NODE_DESC_UNKNOWN);
return p_node;
}
static void ni_rcv_get_port_info(IN osm_sm_t * sm, IN osm_node_t * node,
IN const osm_madw_t * madw)
{
osm_madw_context_t context;
osm_physp_t *physp;
ib_node_info_t *ni;
unsigned port;
ib_api_status_t status;
int mlnx_epi_supported = 0;
ni = ib_smp_get_payload_ptr(osm_madw_get_smp_ptr(madw));
port = ib_node_info_get_local_port_num(ni);
if (sm->p_subn->opt.fdr10)
mlnx_epi_supported = is_mlnx_ext_port_info_supported(ni->device_id);
physp = osm_node_get_physp_ptr(node, port);
if (!physp) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR OD1E: "
"Failed to find physp for port %d of Node GUID 0x%"
PRIx64 "\n", port,
cl_ntoh64(osm_node_get_node_guid(node)));
return;
}
context.pi_context.node_guid = osm_node_get_node_guid(node);
context.pi_context.port_guid = osm_physp_get_port_guid(physp);
context.pi_context.set_method = FALSE;
context.pi_context.light_sweep = FALSE;
context.pi_context.active_transition = FALSE;
context.pi_context.client_rereg = FALSE;
status = osm_req_get(sm, osm_physp_get_dr_path_ptr(physp),
IB_MAD_ATTR_PORT_INFO, cl_hton32(port),
TRUE, 0, CL_DISP_MSGID_NONE, &context);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR OD02: "
"Failure initiating PortInfo request (%s)\n",
ib_get_err_str(status));
if (mlnx_epi_supported) {
status = osm_req_get(sm,
osm_physp_get_dr_path_ptr(physp),
IB_MAD_ATTR_MLNX_EXTENDED_PORT_INFO,
cl_hton32(port),
TRUE, 0, CL_DISP_MSGID_NONE, &context);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D0B: "
"Failure initiating MLNX ExtPortInfo request (%s)\n",
ib_get_err_str(status));
}
}
osm_switch_t *osm_switch_new(IN osm_node_t * p_node,
IN const osm_madw_t * p_madw)
{
osm_switch_t *p_sw;
ib_switch_info_t *p_si;
ib_smp_t *p_smp;
uint8_t num_ports;
uint32_t port_num;
CL_ASSERT(p_madw);
CL_ASSERT(p_node);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_si = ib_smp_get_payload_ptr(p_smp);
num_ports = osm_node_get_num_physp(p_node);
CL_ASSERT(p_smp->attr_id == IB_MAD_ATTR_SWITCH_INFO);
if (!p_si->lin_cap) /* The switch doesn't support LFT */
return NULL;
p_sw = malloc(sizeof(*p_sw));
if (!p_sw)
return NULL;
memset(p_sw, 0, sizeof(*p_sw));
p_sw->p_node = p_node;
p_sw->switch_info = *p_si;
p_sw->num_ports = num_ports;
p_sw->need_update = 2;
p_sw->p_prof = malloc(sizeof(*p_sw->p_prof) * num_ports);
if (!p_sw->p_prof)
goto err;
memset(p_sw->p_prof, 0, sizeof(*p_sw->p_prof) * num_ports);
osm_mcast_tbl_init(&p_sw->mcast_tbl, osm_node_get_num_physp(p_node),
cl_ntoh16(p_si->mcast_cap));
for (port_num = 0; port_num < num_ports; port_num++)
osm_port_prof_construct(&p_sw->p_prof[port_num]);
return p_sw;
err:
osm_switch_delete(&p_sw);
return NULL;
}
void osm_lft_rcv_process(IN void *context, IN void *data)
{
osm_sm_t *sm = context;
osm_madw_t *p_madw = data;
ib_smp_t *p_smp;
uint32_t block_num;
osm_switch_t *p_sw;
osm_lft_context_t *p_lft_context;
uint8_t *p_block;
ib_net64_t node_guid;
ib_api_status_t status;
CL_ASSERT(sm);
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_block = ib_smp_get_payload_ptr(p_smp);
block_num = cl_ntoh32(p_smp->attr_mod);
/*
Acquire the switch object for this switch.
*/
p_lft_context = osm_madw_get_lft_context_ptr(p_madw);
node_guid = p_lft_context->node_guid;
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
p_sw = osm_get_switch_by_guid(sm->p_subn, node_guid);
if (!p_sw) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0401: "
"LFT received for nonexistent node "
"0x%" PRIx64 "\n", cl_ntoh64(node_guid));
} else {
status = osm_switch_set_lft_block(p_sw, p_block, block_num);
if (status != IB_SUCCESS) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0402: "
"Setting forwarding table block failed (%s)"
", Switch 0x%" PRIx64 " %s\n",
ib_get_err_str(status), cl_ntoh64(node_guid),
p_sw->p_node->print_desc);
}
}
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG_EXIT(sm->p_log);
}
void osm_node_init_physp(IN osm_node_t * p_node, uint8_t port_num,
IN const osm_madw_t * p_madw)
{
ib_net64_t port_guid;
ib_smp_t *p_smp;
ib_node_info_t *p_ni;
p_smp = osm_madw_get_smp_ptr(p_madw);
p_ni = ib_smp_get_payload_ptr(p_smp);
port_guid = p_ni->port_guid;
CL_ASSERT(port_num < p_node->physp_tbl_size);
osm_physp_init(&p_node->physp_table[port_num],
port_guid, port_num, p_node,
osm_madw_get_bind_handle(p_madw),
p_smp->hop_count, p_smp->initial_path);
}
/**********************************************************************
Lock must be held on entry to this function.
Return 1 if the caller is expected to send a change_detected event.
this can not be done internally as the event needs the lock...
**********************************************************************/
static boolean_t si_rcv_process_existing(IN osm_sm_t * sm,
IN osm_node_t * p_node,
IN const osm_madw_t * p_madw)
{
osm_switch_t *p_sw = p_node->sw;
ib_switch_info_t *p_si;
osm_si_context_t *p_si_context;
ib_smp_t *p_smp;
boolean_t is_change_detected = FALSE;
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_si = ib_smp_get_payload_ptr(p_smp);
p_si_context = osm_madw_get_si_context_ptr(p_madw);
OSM_LOG(sm->p_log, OSM_LOG_DEBUG, "Received logical %cetResp()\n",
p_si_context->set_method ? 'S' : 'G');
osm_switch_set_switch_info(p_sw, p_si);
if (p_si_context->light_sweep == TRUE && !p_si_context->set_method) {
/* If state changed bit is on the mad was returned with an
error - signal a change to the state manager. */
if (ib_smp_get_status(p_smp) != 0) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"GetResp() received with error in light sweep. "
"Commencing heavy sweep\n");
is_change_detected = TRUE;
} else if (ib_switch_info_get_state_change(p_si)) {
osm_dump_switch_info_v2(sm->p_log, p_si, FILE_ID, OSM_LOG_DEBUG);
is_change_detected = TRUE;
}
}
OSM_LOG_EXIT(sm->p_log);
return is_change_detected;
}
void osm_si_rcv_process(IN void *context, IN void *data)
{
osm_sm_t *sm = context;
osm_madw_t *p_madw = data;
ib_switch_info_t *p_si;
ib_smp_t *p_smp;
osm_node_t *p_node;
ib_net64_t node_guid;
osm_si_context_t *p_context;
CL_ASSERT(sm);
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_si = ib_smp_get_payload_ptr(p_smp);
p_context = osm_madw_get_si_context_ptr(p_madw);
node_guid = p_context->node_guid;
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Switch GUID 0x%016" PRIx64 ", TID 0x%" PRIx64 "\n",
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
p_node = osm_get_node_by_guid(sm->p_subn, node_guid);
if (!p_node) {
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3606: "
"SwitchInfo received for nonexistent node "
"with GUID 0x%" PRIx64 "\n", cl_ntoh64(node_guid));
goto Exit;
}
/* Hack for bad value in Mellanox switch */
if (cl_ntoh16(p_si->lin_top) > IB_LID_UCAST_END_HO) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3610: "
"\n\t\t\t\tBad LinearFDBTop value = 0x%X "
"on switch 0x%" PRIx64
"\n\t\t\t\tForcing internal correction to 0x%X\n",
cl_ntoh16(p_si->lin_top),
cl_ntoh64(osm_node_get_node_guid(p_node)), 0);
p_si->lin_top = 0;
}
/* Acquire the switch object for this switch. */
if (!p_node->sw) {
si_rcv_process_new(sm, p_node, p_madw);
/* A new switch was found during the sweep so we need
to ignore the current LFT settings. */
sm->p_subn->ignore_existing_lfts = TRUE;
} else if (si_rcv_process_existing(sm, p_node, p_madw))
/* we might get back a request for signaling change was detected */
sm->p_subn->force_heavy_sweep = TRUE;
CL_PLOCK_RELEASE(sm->p_lock);
Exit:
OSM_LOG_EXIT(sm->p_log);
}
void osm_ni_rcv_process(IN void *context, IN void *data)
{
osm_sm_t *sm = context;
osm_madw_t *p_madw = data;
ib_node_info_t *p_ni;
ib_smp_t *p_smp;
osm_node_t *p_node;
CL_ASSERT(sm);
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_ni = ib_smp_get_payload_ptr(p_smp);
CL_ASSERT(p_smp->attr_id == IB_MAD_ATTR_NODE_INFO);
if (PF(p_ni->node_guid == 0)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D16: "
"Got Zero Node GUID! Found on the directed route:\n");
osm_dump_smp_dr_path_v2(sm->p_log, p_smp, FILE_ID, OSM_LOG_ERROR);
goto Exit;
}
if (PF(p_ni->port_guid == 0)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D17: "
"Got Zero Port GUID! Found on the directed route:\n");
osm_dump_smp_dr_path_v2(sm->p_log, p_smp, FILE_ID, OSM_LOG_ERROR);
goto Exit;
}
if (ib_smp_get_status(p_smp)) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"MAD status 0x%x received\n",
cl_ntoh16(ib_smp_get_status(p_smp)));
goto Exit;
}
/*
Determine if this node has already been discovered,
and process accordingly.
During processing of this node, hold the shared lock.
*/
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
p_node = osm_get_node_by_guid(sm->p_subn, p_ni->node_guid);
osm_dump_node_info_v2(sm->p_log, p_ni, FILE_ID, OSM_LOG_DEBUG);
if (!p_node)
ni_rcv_process_new(sm, p_madw);
else
ni_rcv_process_existing(sm, p_node, p_madw);
CL_PLOCK_RELEASE(sm->p_lock);
Exit:
OSM_LOG_EXIT(sm->p_log);
}
/**********************************************************************
The plock must be held before calling this function.
**********************************************************************/
static void ni_rcv_process_existing(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;
osm_ni_context_t *p_ni_context;
uint8_t port_num;
OSM_LOG_ENTER(sm->p_log);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_ni = ib_smp_get_payload_ptr(p_smp);
p_ni_context = osm_madw_get_ni_context_ptr(p_madw);
port_num = ib_node_info_get_local_port_num(p_ni);
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Rediscovered %s node 0x%" PRIx64 " TID 0x%" PRIx64
", discovered %u times already\n",
ib_get_node_type_str(p_ni->node_type),
cl_ntoh64(p_ni->node_guid),
cl_ntoh64(p_smp->trans_id), p_node->discovery_count);
if (PF(port_num > p_ni->num_ports)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D0C: "
"Existing %s node GUID 0x%" PRIx64 "is non-compliant "
"and is being ignored since the "
"local port num %u > num ports %u\n",
ib_get_node_type_str(p_ni->node_type),
cl_ntoh64(p_ni->node_guid), port_num,
p_ni->num_ports);
goto Exit;
}
/*
If we haven't already encountered this existing node
on this particular sweep, then process further.
*/
p_node->discovery_count++;
switch (p_ni->node_type) {
case IB_NODE_TYPE_CA:
case IB_NODE_TYPE_ROUTER:
ni_rcv_process_existing_ca_or_router(sm, p_node, p_madw);
break;
case IB_NODE_TYPE_SWITCH:
ni_rcv_process_existing_switch(sm, p_node, p_madw);
break;
default:
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D09: "
"Unknown node type %u with GUID 0x%" PRIx64 "\n",
p_ni->node_type, cl_ntoh64(p_ni->node_guid));
break;
}
if ( p_ni->sys_guid != p_node->node_info.sys_guid) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG, "Updated SysImageGUID: 0x%"
PRIx64 " for node 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->sys_guid),
cl_ntoh64(p_ni->node_guid));
}
ni_rcv_set_links(sm, p_node, port_num, p_ni_context);
p_node->node_info = *p_ni;
Exit:
OSM_LOG_EXIT(sm->p_log);
}
/**********************************************************************
The plock must NOT be held before calling this function.
**********************************************************************/
static void ni_rcv_process_new(IN osm_sm_t * sm, IN const osm_madw_t * p_madw)
{
osm_node_t *p_node;
osm_node_t *p_node_check;
osm_port_t *p_port;
osm_port_t *p_port_check;
osm_router_t *p_rtr = NULL;
osm_router_t *p_rtr_check;
cl_qmap_t *p_rtr_guid_tbl;
ib_node_info_t *p_ni;
ib_smp_t *p_smp;
osm_ni_context_t *p_ni_context;
osm_alias_guid_t *p_alias_guid, *p_alias_guid_check;
uint8_t port_num;
OSM_LOG_ENTER(sm->p_log);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_ni = ib_smp_get_payload_ptr(p_smp);
p_ni_context = osm_madw_get_ni_context_ptr(p_madw);
port_num = ib_node_info_get_local_port_num(p_ni);
osm_dump_smp_dr_path_v2(sm->p_log, p_smp, FILE_ID, OSM_LOG_VERBOSE);
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Discovered new %s node,"
"\n\t\t\t\tGUID 0x%" PRIx64 ", TID 0x%" PRIx64 "\n",
ib_get_node_type_str(p_ni->node_type),
cl_ntoh64(p_ni->node_guid), cl_ntoh64(p_smp->trans_id));
if (PF(port_num > p_ni->num_ports)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D0A: "
"New %s node GUID 0x%" PRIx64 "is non-compliant and "
"is being ignored since the "
"local port num %u > num ports %u\n",
ib_get_node_type_str(p_ni->node_type),
cl_ntoh64(p_ni->node_guid), port_num,
p_ni->num_ports);
goto Exit;
}
p_node = osm_node_new(p_madw);
if (PF(p_node == NULL)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D07: "
"Unable to create new node object\n");
goto Exit;
}
/*
Create a new port object to represent this node's physical
ports in the port table.
*/
p_port = osm_port_new(p_ni, p_node);
if (PF(p_port == NULL)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D14: "
"Unable to create new port object\n");
osm_node_delete(&p_node);
goto Exit;
}
/*
Add the new port object to the database.
*/
p_port_check =
(osm_port_t *) cl_qmap_insert(&sm->p_subn->port_guid_tbl,
p_ni->port_guid, &p_port->map_item);
if (PF(p_port_check != p_port)) {
/*
We should never be here!
Somehow, this port GUID already exists in the table.
*/
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D15: "
"Duplicate Port GUID 0x%" PRIx64
"! Found by the two directed routes:\n",
cl_ntoh64(p_ni->port_guid));
osm_dump_dr_path_v2(sm->p_log,
osm_physp_get_dr_path_ptr(p_port->p_physp),
FILE_ID, OSM_LOG_ERROR);
osm_dump_dr_path_v2(sm->p_log,
osm_physp_get_dr_path_ptr(p_port_check->
p_physp),
FILE_ID, OSM_LOG_ERROR);
osm_port_delete(&p_port);
osm_node_delete(&p_node);
goto Exit;
}
p_alias_guid = osm_alias_guid_new(p_ni->port_guid,
p_port);
if (PF(!p_alias_guid)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D18: "
"alias guid memory allocation failed"
" for port GUID 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->port_guid));
goto alias_done2;
}
/* insert into alias guid table */
p_alias_guid_check =
(osm_alias_guid_t *) cl_qmap_insert(&sm->p_subn->alias_port_guid_tbl,
p_alias_guid->alias_guid,
&p_alias_guid->map_item);
if (p_alias_guid_check != p_alias_guid) {
/* alias GUID is a duplicate */
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D19: "
"Duplicate alias port GUID 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->port_guid));
osm_alias_guid_delete(&p_alias_guid);
}
alias_done2:
/* If we are a master, then this means the port is new on the subnet.
Mark it as new - need to send trap 64 on these ports.
The condition that we are master is true, since if we are in discovering
state (meaning we woke up from standby or we are just initializing),
then these ports may be new to us, but are not new on the subnet.
If we are master, then the subnet as we know it is the updated one,
and any new ports we encounter should cause trap 64. C14-72.1.1 */
if (sm->p_subn->sm_state == IB_SMINFO_STATE_MASTER)
p_port->is_new = 1;
/* If there were RouterInfo or other router attribute,
this would be elsewhere */
if (p_ni->node_type == IB_NODE_TYPE_ROUTER) {
if (PF((p_rtr = osm_router_new(p_port)) == NULL))
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D1A: "
"Unable to create new router object\n");
else {
p_rtr_guid_tbl = &sm->p_subn->rtr_guid_tbl;
p_rtr_check =
(osm_router_t *) cl_qmap_insert(p_rtr_guid_tbl,
p_ni->port_guid,
&p_rtr->map_item);
if (PF(p_rtr_check != p_rtr))
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D1B: "
"Unable to add port GUID:0x%016" PRIx64
" to router table\n",
cl_ntoh64(p_ni->port_guid));
}
}
p_node_check =
(osm_node_t *) cl_qmap_insert(&sm->p_subn->node_guid_tbl,
p_ni->node_guid, &p_node->map_item);
if (PF(p_node_check != p_node)) {
/*
This node must have been inserted by another thread.
This is unexpected, but is not an error.
We can simply clean-up, since the other thread will
see this processing through to completion.
*/
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Discovery race detected at node 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->node_guid));
osm_node_delete(&p_node);
p_node = p_node_check;
ni_rcv_set_links(sm, p_node, port_num, p_ni_context);
goto Exit;
} else
ni_rcv_set_links(sm, p_node, port_num, p_ni_context);
p_node->discovery_count++;
ni_rcv_get_node_desc(sm, p_node, p_madw);
switch (p_ni->node_type) {
case IB_NODE_TYPE_CA:
case IB_NODE_TYPE_ROUTER:
ni_rcv_process_new_ca_or_router(sm, p_node, p_madw);
break;
case IB_NODE_TYPE_SWITCH:
ni_rcv_process_new_switch(sm, p_node, p_madw);
break;
default:
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D16: "
"Unknown node type %u with GUID 0x%" PRIx64 "\n",
p_ni->node_type, cl_ntoh64(p_ni->node_guid));
break;
}
Exit:
OSM_LOG_EXIT(sm->p_log);
}
/**********************************************************************
The plock must be held before calling this function.
**********************************************************************/
static void ni_rcv_process_existing_ca_or_router(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;
osm_port_t *p_port;
osm_port_t *p_port_check;
uint8_t port_num;
osm_dr_path_t *p_dr_path;
osm_alias_guid_t *p_alias_guid, *p_alias_guid_check;
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);
/*
Determine if we have encountered this node through a
previously undiscovered port. If so, build the new
port object.
*/
p_port = osm_get_port_by_guid(sm->p_subn, p_ni->port_guid);
if (!p_port) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Creating new port object with GUID 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->port_guid));
osm_node_init_physp(p_node, port_num, p_madw);
p_port = osm_port_new(p_ni, p_node);
if (PF(p_port == NULL)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D04: "
"Unable to create new port object\n");
goto Exit;
}
/*
Add the new port object to the database.
*/
p_port_check =
(osm_port_t *) cl_qmap_insert(&sm->p_subn->port_guid_tbl,
p_ni->port_guid,
&p_port->map_item);
if (PF(p_port_check != p_port)) {
/*
We should never be here!
Somehow, this port GUID already exists in the table.
*/
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D12: "
"Port 0x%" PRIx64 " already in the database!\n",
cl_ntoh64(p_ni->port_guid));
osm_port_delete(&p_port);
goto Exit;
}
p_alias_guid = osm_alias_guid_new(p_ni->port_guid,
p_port);
if (PF(!p_alias_guid)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D11: "
"alias guid memory allocation failed"
" for port GUID 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->port_guid));
goto alias_done;
}
/* insert into alias guid table */
p_alias_guid_check =
(osm_alias_guid_t *) cl_qmap_insert(&sm->p_subn->alias_port_guid_tbl,
p_alias_guid->alias_guid,
&p_alias_guid->map_item);
if (p_alias_guid_check != p_alias_guid) {
/* alias GUID is a duplicate */
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D13: "
"Duplicate alias port GUID 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->port_guid));
osm_alias_guid_delete(&p_alias_guid);
osm_port_delete(&p_port);
goto Exit;
}
alias_done:
/* If we are a master, then this means the port is new on the subnet.
Mark it as new - need to send trap 64 for these ports.
The condition that we are master is true, since if we are in discovering
state (meaning we woke up from standby or we are just initializing),
then these ports may be new to us, but are not new on the subnet.
If we are master, then the subnet as we know it is the updated one,
and any new ports we encounter should cause trap 64. C14-72.1.1 */
if (sm->p_subn->sm_state == IB_SMINFO_STATE_MASTER)
p_port->is_new = 1;
} else {
osm_physp_t *p_physp = osm_node_get_physp_ptr(p_node, port_num);
if (PF(p_physp == NULL)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D1C: "
"No physical port found for node GUID 0x%"
PRIx64 " port %u. Might be duplicate port GUID\n",
cl_ntoh64(p_node->node_info.node_guid),
port_num);
goto Exit;
}
/*
Update the DR Path to the port,
in case the old one is no longer available.
*/
p_dr_path = osm_physp_get_dr_path_ptr(p_physp);
osm_dr_path_init(p_dr_path, p_smp->hop_count,
p_smp->initial_path);
}
ni_rcv_get_port_info(sm, p_node, p_madw);
Exit:
OSM_LOG_EXIT(sm->p_log);
}
void osm_pi_rcv_process(IN void *context, IN void *data)
{
osm_sm_t *sm = context;
osm_madw_t *p_madw = data;
ib_port_info_t *p_pi;
ib_smp_t *p_smp;
osm_port_t *p_port;
osm_physp_t *p_physp;
osm_dr_path_t *p_dr_path;
osm_node_t *p_node;
osm_pi_context_t *p_context;
ib_net64_t port_guid;
ib_net64_t node_guid;
uint8_t port_num;
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(sm);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_context = osm_madw_get_pi_context_ptr(p_madw);
p_pi = (ib_port_info_t *) ib_smp_get_payload_ptr(p_smp);
CL_ASSERT(p_smp->attr_id == IB_MAD_ATTR_PORT_INFO);
port_num = (uint8_t) cl_ntoh32(p_smp->attr_mod);
port_guid = p_context->port_guid;
node_guid = p_context->node_guid;
osm_dump_port_info(sm->p_log,
node_guid, port_guid, port_num, p_pi, OSM_LOG_DEBUG);
/* On receipt of client reregister, clear the reregister bit so
reregistering won't be sent again and again */
if (ib_port_info_get_client_rereg(p_pi)) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Client reregister received on response\n");
ib_port_info_set_client_rereg(p_pi, 0);
}
/*
we might get a response during a light sweep looking for a change in
the status of a remote port that did not respond in earlier sweeps.
So if the context of the Get was light_sweep - we do not need to
do anything with the response - just flag that we need a heavy sweep
*/
if (p_context->light_sweep == TRUE) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Got light sweep response from remote port of parent node "
"GUID 0x%" PRIx64 " port 0x%016" PRIx64
", Commencing heavy sweep\n",
cl_ntoh64(node_guid), cl_ntoh64(port_guid));
sm->p_subn->force_heavy_sweep = TRUE;
sm->p_subn->ignore_existing_lfts = TRUE;
goto Exit;
}
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
p_port = osm_get_port_by_guid(sm->p_subn, port_guid);
if (!p_port) {
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F06: "
"No port object for port with GUID 0x%" PRIx64
"\n\t\t\t\tfor parent node GUID 0x%" PRIx64
", TID 0x%" PRIx64 "\n",
cl_ntoh64(port_guid),
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
goto Exit;
}
p_node = p_port->p_node;
CL_ASSERT(p_node);
/*
If we were setting the PortInfo, then receiving
this attribute was not part of sweeping the subnet.
In this case, just update the PortInfo attribute.
In an unfortunate blunder, the IB spec defines the
return method for Set() as a GetResp(). Thus, we can't
use the method (what would have been SetResp()) to determine
our course of action. So, we have to carry this extra
boolean around to determine if we were doing Get() or Set().
*/
if (p_context->set_method)
osm_pi_rcv_process_set(sm, p_node, port_num, p_madw);
else {
p_port->discovery_count++;
/*
This PortInfo arrived because we did a Get() method,
most likely due to a subnet sweep in progress.
*/
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Discovered port num %u with GUID 0x%" PRIx64
" for parent node GUID 0x%" PRIx64
", TID 0x%" PRIx64 "\n",
port_num, cl_ntoh64(port_guid),
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
p_physp = osm_node_get_physp_ptr(p_node, port_num);
/*
Determine if we encountered a new Physical Port.
If so, initialize the new Physical Port then
continue processing as normal.
*/
if (!p_physp) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Initializing port number %u\n", port_num);
p_physp = &p_node->physp_table[port_num];
osm_physp_init(p_physp,
port_guid,
port_num,
p_node,
osm_madw_get_bind_handle(p_madw),
p_smp->hop_count, p_smp->initial_path);
} else {
/*
Update the directed route path to this port
in case the old path is no longer usable.
*/
p_dr_path = osm_physp_get_dr_path_ptr(p_physp);
osm_dr_path_init(p_dr_path,
osm_madw_get_bind_handle(p_madw),
p_smp->hop_count, p_smp->initial_path);
}
/* if port just inited or reached INIT state (external reset)
request update for port related tables */
p_physp->need_update =
(ib_port_info_get_port_state(p_pi) == IB_LINK_INIT ||
p_physp->need_update > 1) ? 1 : 0;
switch (osm_node_get_type(p_node)) {
case IB_NODE_TYPE_CA:
case IB_NODE_TYPE_ROUTER:
__osm_pi_rcv_process_ca_or_router_port(sm,
p_node, p_physp,
p_pi);
break;
case IB_NODE_TYPE_SWITCH:
__osm_pi_rcv_process_switch_port(sm,
p_node, p_physp, p_pi);
break;
default:
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F07: "
"Unknown node type %u with GUID 0x%" PRIx64
"\n", osm_node_get_type(p_node),
cl_ntoh64(node_guid));
break;
}
/*
Get the tables on the physp.
*/
if (p_physp->need_update || sm->p_subn->need_update)
__osm_pi_rcv_get_pkey_slvl_vla_tables(sm, p_node,
p_physp);
}
CL_PLOCK_RELEASE(sm->p_lock);
Exit:
/*
Release the lock before jumping here!!
*/
OSM_LOG_EXIT(sm->p_log);
}
void osm_pi_rcv_process(IN void *context, IN void *data)
{
osm_sm_t *sm = context;
osm_madw_t *p_madw = data;
ib_port_info_t *p_pi;
ib_smp_t *p_smp;
osm_port_t *p_port;
osm_physp_t *p_physp;
osm_dr_path_t *p_dr_path;
osm_node_t *p_node;
osm_pi_context_t *p_context;
ib_net64_t port_guid, node_guid;
uint8_t port_num;
CL_ASSERT(sm);
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_context = osm_madw_get_pi_context_ptr(p_madw);
p_pi = ib_smp_get_payload_ptr(p_smp);
CL_ASSERT(p_smp->attr_id == IB_MAD_ATTR_PORT_INFO);
/*
* Attribute modifier has already been validated upon MAD receive,
* which means that port_num has to be valid - it originated from
* the request attribute modifier.
*/
port_num = (uint8_t) cl_ntoh32(p_smp->attr_mod);
port_guid = p_context->port_guid;
node_guid = p_context->node_guid;
osm_dump_port_info_v2(sm->p_log, node_guid, port_guid, port_num, p_pi,
FILE_ID, OSM_LOG_DEBUG);
/* On receipt of client reregister, clear the reregister bit so
reregistering won't be sent again and again */
if (p_context->set_method &&
(ib_port_info_get_client_rereg(p_pi) || p_context->client_rereg)) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Client reregister received on response\n");
ib_port_info_set_client_rereg(p_pi, 0);
p_context->client_rereg = FALSE;
}
/*
we might get a response during a light sweep looking for a change in
the status of a remote port that did not respond in earlier sweeps.
So if the context of the Get was light_sweep - we do not need to
do anything with the response - just flag that we need a heavy sweep
*/
if (p_context->light_sweep == TRUE) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Got light sweep response from remote port of parent node "
"GUID 0x%" PRIx64 " port 0x%016" PRIx64
", Commencing heavy sweep\n",
cl_ntoh64(node_guid), cl_ntoh64(port_guid));
sm->p_subn->force_heavy_sweep = TRUE;
sm->p_subn->ignore_existing_lfts = TRUE;
goto Exit;
}
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
p_port = osm_get_port_by_guid(sm->p_subn, port_guid);
if (PF(!p_port)) {
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F06: "
"No port object for port with GUID 0x%" PRIx64
"\n\t\t\t\tfor parent node GUID 0x%" PRIx64
", TID 0x%" PRIx64 "\n",
cl_ntoh64(port_guid),
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
goto Exit;
}
p_node = p_port->p_node;
CL_ASSERT(p_node);
if (PF(p_pi->local_port_num > p_node->node_info.num_ports)) {
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F15: "
"Received PortInfo for port GUID 0x%" PRIx64 " is "
"non-compliant and is being ignored since the "
"local port num %u > num ports %u\n",
cl_ntoh64(port_guid), p_pi->local_port_num,
p_node->node_info.num_ports);
goto Exit;
}
/*
If we were setting the PortInfo, then receiving
this attribute was not part of sweeping the subnet.
In this case, just update the PortInfo attribute.
In an unfortunate blunder, the IB spec defines the
return method for Set() as a GetResp(). Thus, we can't
use the method (what would have been SetResp()) to determine
our course of action. So, we have to carry this extra
boolean around to determine if we were doing Get() or Set().
*/
if (p_context->set_method)
pi_rcv_process_set(sm, p_node, port_num, p_madw);
else {
/*
This PortInfo arrived because we did a Get() method,
most likely due to a subnet sweep in progress.
*/
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Discovered port num %u with GUID 0x%" PRIx64
" for parent node GUID 0x%" PRIx64
", TID 0x%" PRIx64 "\n",
port_num, cl_ntoh64(port_guid),
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
p_physp = osm_node_get_physp_ptr(p_node, port_num);
CL_ASSERT(p_physp);
/* Update the directed route path to this port
in case the old path is no longer usable. */
p_dr_path = osm_physp_get_dr_path_ptr(p_physp);
osm_dr_path_init(p_dr_path, p_smp->hop_count,
p_smp->initial_path);
p_physp->need_update = osm_pi_rcv_update_self(sm, p_physp, p_pi);
switch (osm_node_get_type(p_node)) {
case IB_NODE_TYPE_CA:
case IB_NODE_TYPE_ROUTER:
if (!p_node->physp_discovered[port_num]) {
p_port->discovery_count++;
p_node->physp_discovered[port_num] = 1;
}
p_physp->need_update = osm_pi_rcv_update_neighbor(p_physp);
pi_rcv_process_ca_or_router_port(sm, p_node, p_physp,
p_pi);
break;
case IB_NODE_TYPE_SWITCH:
if (!p_node->physp_discovered[port_num]) {
p_port->discovery_count++;
p_node->physp_discovered[port_num] = 1;
}
if (port_num == 0)
pi_rcv_process_switch_port0(sm, p_node,
p_physp, p_pi);
else
pi_rcv_process_switch_ext_port(sm, p_node,
p_physp, p_pi);
break;
default:
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F07: "
"Unknown node type %u with GUID 0x%" PRIx64
"\n", osm_node_get_type(p_node),
cl_ntoh64(node_guid));
break;
}
/*
Get the tables on the physp.
*/
if (p_physp->need_update || (p_node->sw &&
p_node->sw->need_update))
pi_rcv_get_pkey_slvl_vla_tables(sm, p_node, p_physp);
}
CL_PLOCK_RELEASE(sm->p_lock);
Exit:
/*
Release the lock before jumping here!!
*/
OSM_LOG_EXIT(sm->p_log);
}
/*
* Send a trap (Subn LID Route) Trap(Notice) through the regular
* connection QP connection (targeted at QP0)
*
* Wait for the trap repress
*/
ib_api_status_t
osmt_send_trap_wait_for_forward(IN osmtest_t * const p_osmt,
IN osmt_qp_ctx_t * p_qp_ctx)
{
ib_smp_t *p_smp = (ib_smp_t *) (p_qp_ctx->p_send_buf);
ib_mad_notice_attr_t *p_ntc = ib_smp_get_payload_ptr(p_smp);
ib_sa_mad_t *p_sa_mad;
IB_MGT_ret_t mgt_res;
VAPI_ret_t vapi_ret;
VAPI_wc_desc_t wc_desc;
VAPI_ud_av_hndl_t avh;
IB_ud_av_t av;
static VAPI_wr_id_t wrid = 2222;
osm_log_t *p_log = &p_osmt->log;
ib_api_status_t status = IB_SUCCESS;
OSM_LOG_ENTER(p_log);
OSM_LOG(p_log, OSM_LOG_INFO,
"Sending Traps to QP0 of SA LID:0x%X\n",
p_osmt->local_port.sm_lid);
/* init the MAD */
memset(p_smp, 0, sizeof(ib_smp_t));
ib_mad_init_new((ib_mad_t *) p_smp,
IB_MCLASS_SUBN_LID,
(uint8_t) 2,
IB_MAD_METHOD_TRAP, cl_hton64(wrid), (ib_net16_t) 0, 0);
wrid++;
p_smp->attr_id = IB_MAD_ATTR_NOTICE;
/* prepare the notice */
p_ntc->generic_type = 0x82; /* generic, type = 2 */
ib_notice_set_prod_type_ho(p_ntc, 1);
p_ntc->g_or_v.generic.trap_num = cl_hton16(0x26);
p_ntc->issuer_lid = cl_hton16(2);
/* --------------------- PREP ------------------------- */
if (osmt_mtl_mad_post_recv_bufs(&p_qp_ctx->qp_bind_hndl, p_qp_ctx->p_recv_buf, 1, /* we need to receive both trap repress and report */
GRH_LEN + MAD_BLOCK_SIZE, wrid) != 1) {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 0127: "
"Error posting recv bufs\n");
status = IB_ERROR;
goto Exit;
}
OSM_LOG(p_log, OSM_LOG_DEBUG, "Posted recv bufs\n");
av.dlid = p_osmt->local_port.sm_lid;
av.grh_flag = FALSE;
/* EZ: returned in HACK: use constants */
av.static_rate = 0; /* p_mad_addr->static_rate; */
av.src_path_bits = 1; /* p_mad_addr->path_bits; */
av.sl = 0; /* p_mad_addr->addr_type.gsi.service_level; */
OSM_LOG(p_log, OSM_LOG_DEBUG,
"av.dlid 0x%X, av.static_rate %d, av.path_bits %d\n",
cl_ntoh16(av.dlid), av.static_rate, av.src_path_bits);
/* send it */
mgt_res = IB_MGT_send_mad(p_qp_ctx->ib_mgt_qp0_handle, p_smp, /* actual payload */
&av, /* address vector */
wrid, /* casting the mad wrapper pointer for err cb */
p_osmt->opt.transaction_timeout);
if (mgt_res != IB_MGT_OK) {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 0128: "
"Error sending mad (%d)\n", mgt_res);
status = IB_ERROR;
goto Exit;
}
vapi_ret =
osmt_mtl_create_av(&p_qp_ctx->qp_bind_hndl,
p_osmt->local_port.sm_lid, &avh);
if (vapi_ret != VAPI_OK) {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 0129: "
"Error Preparing AVH (%s)\n",
VAPI_strerror_sym(vapi_ret));
status = IB_ERROR;
goto Exit;
}
OSM_LOG(p_log, OSM_LOG_DEBUG, "Prepared AVH\n");
OSM_LOG(p_log, OSM_LOG_DEBUG, "Trap MAD Sent\n");
/* --------------------- RECV ------------------------- */
vapi_ret = osmt_mtl_mad_poll4cqe(p_qp_ctx->qp_bind_hndl.hca_hndl,
p_qp_ctx->qp_bind_hndl.rq_cq_hndl,
&wc_desc, 200, 10000, &avh);
if (vapi_ret != VAPI_SUCCESS) {
if (vapi_ret == VAPI_CQ_EMPTY) {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 0130: "
"Timeout receiving mad (%s)\n",
VAPI_strerror_sym(vapi_ret));
status = IB_TIMEOUT;
} else {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 0131: "
"Error receiving mad (%s)\n",
VAPI_strerror_sym(vapi_ret));
status = IB_ERROR;
}
goto Exit;
}
/* check to see if successful - by examination of the subscribe bit */
p_sa_mad = (ib_sa_mad_t *) (p_qp_ctx->p_recv_buf + GRH_LEN);
if (p_sa_mad->method == IB_MAD_METHOD_REPORT) {
if (p_sa_mad->attr_id == IB_MAD_ATTR_NOTICE) {
OSM_LOG(p_log, OSM_LOG_INFO, "Received the Report!\n");
status = IB_SUCCESS;
} else {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 1020"
"Did not receive a Report(Notice) but attr:%d\n",
cl_ntoh16(p_sa_mad->attr_id));
status = IB_ERROR;
}
} else {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 1020"
"Received an Unexpected Method:%d\n", p_smp->method);
status = IB_ERROR;
}
Exit:
OSM_LOG_EXIT(p_log);
return status;
}
/**********************************************************************
Lock must be held on entry to this function.
**********************************************************************/
static void si_rcv_process_new(IN osm_sm_t * sm, IN osm_node_t * p_node,
IN const osm_madw_t * p_madw)
{
osm_switch_t *p_sw;
osm_switch_t *p_check;
ib_switch_info_t *p_si;
ib_smp_t *p_smp;
cl_qmap_t *p_sw_guid_tbl;
CL_ASSERT(sm);
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(p_madw);
p_sw_guid_tbl = &sm->p_subn->sw_guid_tbl;
p_smp = osm_madw_get_smp_ptr(p_madw);
p_si = ib_smp_get_payload_ptr(p_smp);
osm_dump_switch_info_v2(sm->p_log, p_si, FILE_ID, OSM_LOG_DEBUG);
p_sw = osm_switch_new(p_node, p_madw);
if (p_sw == NULL) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3608: "
"Unable to allocate new switch object\n");
goto Exit;
}
/* set subnet max mlid to the minimum MulticastFDBCap of all switches */
if (cl_ntoh16(p_si->mcast_cap) + IB_LID_MCAST_START_HO - 1 <
sm->p_subn->max_mcast_lid_ho) {
sm->p_subn->max_mcast_lid_ho = cl_ntoh16(p_si->mcast_cap) +
IB_LID_MCAST_START_HO - 1;
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Subnet max multicast lid is 0x%X\n",
sm->p_subn->max_mcast_lid_ho);
}
/* set subnet max unicast lid to the minimum LinearFDBCap of all switches */
if (cl_ntoh16(p_si->lin_cap) < sm->p_subn->max_ucast_lid_ho) {
sm->p_subn->max_ucast_lid_ho = cl_ntoh16(p_si->lin_cap);
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Subnet max unicast lid is 0x%X\n",
sm->p_subn->max_ucast_lid_ho);
}
p_check = (osm_switch_t *) cl_qmap_insert(p_sw_guid_tbl,
osm_node_get_node_guid
(p_node), &p_sw->map_item);
if (p_check != p_sw) {
/* This shouldn't happen since we hold the lock! */
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3605: "
"Unable to add new switch object to database\n");
osm_switch_delete(&p_sw);
goto Exit;
}
p_node->sw = p_sw;
/* Update the switch info according to the info we just received. */
osm_switch_set_switch_info(p_sw, p_si);
#if 0
/* Don't bother retrieving the current unicast and multicast tables
from the switches. The current version of SM does
not support silent take-over of an existing multicast
configuration.
Gathering the multicast tables can also generate large amounts
of extra subnet-init traffic.
The code to retrieve the tables was fully debugged. */
si_rcv_get_fwd_tbl(sm, p_sw);
if (!sm->p_subn->opt.disable_multicast)
si_rcv_get_mcast_fwd_tbl(sm, p_sw);
#endif
Exit:
OSM_LOG_EXIT(sm->p_log);
}
