/*
* Copyright (c) 2004-2009 Voltaire, Inc. All rights reserved.
* Copyright (c) 2002-2005 Mellanox Technologies LTD. All rights reserved.
* Copyright (c) 1996-2003 Intel Corporation. All rights reserved.
* Copyright (c) 2009 HNR Consulting. All rights reserved.
*
* This software is available to you under a choice of one of two
* licenses. You may choose to be licensed under the terms of the GNU
* General Public License (GPL) Version 2, available from the file
* COPYING in the main directory of this source tree, or the
* OpenIB.org BSD license below:
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above
* copyright notice, this list of conditions and the following
* disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
/*
* Abstract:
* Implementation of osm_sa_mad_ctrl_t.
* This object is part of the SA object.
*/
#if HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#include <string.h>
#include <complib/cl_debug.h>
#include <iba/ib_types.h>
#include <opensm/osm_file_ids.h>
#define FILE_ID OSM_FILE_SA_MAD_CTRL_C
#include <vendor/osm_vendor_api.h>
#include <opensm/osm_sa_mad_ctrl.h>
#include <opensm/osm_msgdef.h>
#include <opensm/osm_helper.h>
#include <opensm/osm_sa.h>
#include <opensm/osm_opensm.h>
/****f* opensm: SA/sa_mad_ctrl_disp_done_callback
* NAME
* sa_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 sa_mad_ctrl_disp_done_callback(IN void *context, IN void *p_data)
{
osm_sa_mad_ctrl_t *p_ctrl = context;
osm_madw_t *p_madw = p_data;
OSM_LOG_ENTER(p_ctrl->p_log);
CL_ASSERT(p_madw);
/*
Return the MAD & wrapper to the pool.
*/
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
OSM_LOG_EXIT(p_ctrl->p_log);
}
/************/
/****f* opensm: SA/sa_mad_ctrl_process
* NAME
* sa_mad_ctrl_process
*
* DESCRIPTION
* This function handles known methods for received MADs.
*
* SYNOPSIS
*/
static void sa_mad_ctrl_process(IN osm_sa_mad_ctrl_t * p_ctrl,
IN osm_madw_t * p_madw,
IN boolean_t is_get_request)
{
ib_sa_mad_t *p_sa_mad;
cl_disp_reg_handle_t h_disp;
cl_status_t status;
cl_disp_msgid_t msg_id = CL_DISP_MSGID_NONE;
uint64_t last_dispatched_msg_queue_time_msec;
uint32_t num_messages;
OSM_LOG_ENTER(p_ctrl->p_log);
p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
/*
If the dispatcher is showing us that it is overloaded
there is no point in placing the request in. We should instead
provide immediate response - IB_RESOURCE_BUSY
But how do we know?
The dispatcher reports back the number of outstanding messages and
the time the last message stayed in the queue.
HACK: Actually, we cannot send a mad from within the receive callback;
thus - we will just drop it.
*/
if (!is_get_request && p_ctrl->p_set_disp) {
h_disp = p_ctrl->h_set_disp;
goto SKIP_QUEUE_CHECK;
}
h_disp = p_ctrl->h_disp;
cl_disp_get_queue_status(h_disp, &num_messages,
&last_dispatched_msg_queue_time_msec);
if (num_messages > 1 && p_ctrl->p_subn->opt.max_msg_fifo_timeout &&
last_dispatched_msg_queue_time_msec >
p_ctrl->p_subn->opt.max_msg_fifo_timeout) {
OSM_LOG(p_ctrl->p_log, OSM_LOG_INFO,
/* "Responding BUSY status since the dispatcher is already" */
"Dropping MAD since the dispatcher is already"
" overloaded with %u messages and queue time of:"
"%" PRIu64 "[msec]\n",
num_messages, last_dispatched_msg_queue_time_msec);
/* send a busy response */
/* osm_sa_send_error(p_ctrl->p_resp, p_madw, IB_RESOURCE_BUSY); */
/* return the request to the pool */
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
goto Exit;
}
SKIP_QUEUE_CHECK:
/*
Note that attr_id (like the rest of the MAD) is in
network byte order.
*/
switch (p_sa_mad->attr_id) {
case IB_MAD_ATTR_CLASS_PORT_INFO:
msg_id = OSM_MSG_MAD_CLASS_PORT_INFO;
break;
case IB_MAD_ATTR_NODE_RECORD:
msg_id = OSM_MSG_MAD_NODE_RECORD;
break;
case IB_MAD_ATTR_PORTINFO_RECORD:
msg_id = OSM_MSG_MAD_PORTINFO_RECORD;
break;
case IB_MAD_ATTR_LINK_RECORD:
msg_id = OSM_MSG_MAD_LINK_RECORD;
break;
case IB_MAD_ATTR_SMINFO_RECORD:
msg_id = OSM_MSG_MAD_SMINFO_RECORD;
break;
case IB_MAD_ATTR_SERVICE_RECORD:
msg_id = OSM_MSG_MAD_SERVICE_RECORD;
break;
case IB_MAD_ATTR_PATH_RECORD:
msg_id = OSM_MSG_MAD_PATH_RECORD;
break;
case IB_MAD_ATTR_MCMEMBER_RECORD:
msg_id = OSM_MSG_MAD_MCMEMBER_RECORD;
break;
case IB_MAD_ATTR_INFORM_INFO:
msg_id = OSM_MSG_MAD_INFORM_INFO;
break;
case IB_MAD_ATTR_VLARB_RECORD:
msg_id = OSM_MSG_MAD_VL_ARB_RECORD;
break;
case IB_MAD_ATTR_SLVL_RECORD:
msg_id = OSM_MSG_MAD_SLVL_TBL_RECORD;
break;
case IB_MAD_ATTR_PKEY_TBL_RECORD:
msg_id = OSM_MSG_MAD_PKEY_TBL_RECORD;
break;
case IB_MAD_ATTR_LFT_RECORD:
msg_id = OSM_MSG_MAD_LFT_RECORD;
break;
case IB_MAD_ATTR_GUIDINFO_RECORD:
msg_id = OSM_MSG_MAD_GUIDINFO_RECORD;
break;
case IB_MAD_ATTR_INFORM_INFO_RECORD:
msg_id = OSM_MSG_MAD_INFORM_INFO_RECORD;
break;
case IB_MAD_ATTR_SWITCH_INFO_RECORD:
msg_id = OSM_MSG_MAD_SWITCH_INFO_RECORD;
break;
case IB_MAD_ATTR_MFT_RECORD:
msg_id = OSM_MSG_MAD_MFT_RECORD;
break;
#if defined (VENDOR_RMPP_SUPPORT) && defined (DUAL_SIDED_RMPP)
case IB_MAD_ATTR_MULTIPATH_RECORD:
msg_id = OSM_MSG_MAD_MULTIPATH_RECORD;
break;
#endif
default:
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A01: "
"Unsupported attribute 0x%X (%s)\n",
cl_ntoh16(p_sa_mad->attr_id),
ib_get_sa_attr_str(p_sa_mad->attr_id));
osm_dump_sa_mad_v2(p_ctrl->p_log, p_sa_mad, FILE_ID, OSM_LOG_ERROR);
}
if (msg_id != CL_DISP_MSGID_NONE) {
/*
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(h_disp, msg_id, p_madw,
sa_mad_ctrl_disp_done_callback, p_ctrl);
if (status != CL_SUCCESS) {
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A02: "
"Dispatcher post message failed (%s) for attribute 0x%X (%s)\n",
CL_STATUS_MSG(status),
cl_ntoh16(p_sa_mad->attr_id),
ib_get_sa_attr_str(p_sa_mad->attr_id));
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
goto Exit;
}
} else {
/*
There is an unknown MAD attribute type for which there is
no recipient. Simply retire the MAD here.
*/
cl_atomic_inc(&p_ctrl->p_stats->sa_mads_rcvd_unknown);
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
}
Exit:
OSM_LOG_EXIT(p_ctrl->p_log);
}
/*
* PARAMETERS
*
* RETURN VALUES
*
* NOTES
*
* SEE ALSO
*********/
/****f* opensm: SA/sa_mad_ctrl_rcv_callback
* NAME
* sa_mad_ctrl_rcv_callback
*
* DESCRIPTION
* This is the callback from the transport layer for received MADs.
*
* SYNOPSIS
*/
static void sa_mad_ctrl_rcv_callback(IN osm_madw_t * p_madw, IN void *context,
IN osm_madw_t * p_req_madw)
{
osm_sa_mad_ctrl_t *p_ctrl = context;
ib_sa_mad_t *p_sa_mad;
boolean_t is_get_request = FALSE;
OSM_LOG_ENTER(p_ctrl->p_log);
CL_ASSERT(p_madw);
/*
A MAD was received from the wire, possibly in response to a request.
*/
cl_atomic_inc(&p_ctrl->p_stats->sa_mads_rcvd);
OSM_LOG(p_ctrl->p_log, OSM_LOG_DEBUG,
"%u SA MADs received\n", p_ctrl->p_stats->sa_mads_rcvd);
/*
* C15-0.1.3 requires not responding to any MAD if the SM is
* not in active state!
* We will not respond if the sm_state is not MASTER, or if the
* first_time_master_sweep flag (of the subnet) is TRUE - this
* flag indicates that the master still didn't finish its first
* sweep, so the subnet is not up and stable yet.
*/
if (p_ctrl->p_subn->sm_state != IB_SMINFO_STATE_MASTER) {
cl_atomic_inc(&p_ctrl->p_stats->sa_mads_ignored);
OSM_LOG(p_ctrl->p_log, OSM_LOG_VERBOSE,
"Received SA MAD while SM not MASTER. MAD ignored\n");
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
goto Exit;
}
if (p_ctrl->p_subn->first_time_master_sweep == TRUE) {
cl_atomic_inc(&p_ctrl->p_stats->sa_mads_ignored);
OSM_LOG(p_ctrl->p_log, OSM_LOG_VERBOSE,
"Received SA MAD while SM in first sweep. MAD ignored\n");
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
goto Exit;
}
p_sa_mad = osm_madw_get_sa_mad_ptr(p_madw);
if (OSM_LOG_IS_ACTIVE_V2(p_ctrl->p_log, OSM_LOG_FRAMES))
osm_dump_sa_mad_v2(p_ctrl->p_log, p_sa_mad, FILE_ID, OSM_LOG_FRAMES);
/*
* C15-0.1.5 - Table 185: SA Header - p884
* SM_key should be either 0 or match the current SM_Key
* otherwise discard the MAD.
*/
if (p_sa_mad->sm_key != 0 &&
p_sa_mad->sm_key != p_ctrl->p_subn->opt.sa_key) {
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A04: "
"Non-Zero MAD SM_Key: 0x%" PRIx64 " != SM_Key: 0x%"
PRIx64 "; SA MAD ignored for method 0x%X attribute 0x%X (%s)\n",
cl_ntoh64(p_sa_mad->sm_key),
cl_ntoh64(p_ctrl->p_subn->opt.sa_key),
p_sa_mad->method, cl_ntoh16(p_sa_mad->attr_id),
ib_get_sa_attr_str(p_sa_mad->attr_id));
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
goto Exit;
}
switch (p_sa_mad->method) {
case IB_MAD_METHOD_REPORT_RESP:
/* we do not really do anything with report responses -
just retire the transaction */
OSM_LOG(p_ctrl->p_log, OSM_LOG_DEBUG,
"Received Report Response. Retiring the transaction\n");
if (p_req_madw)
osm_mad_pool_put(p_ctrl->p_mad_pool, p_req_madw);
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
break;
case IB_MAD_METHOD_GET:
case IB_MAD_METHOD_GETTABLE:
#if defined (VENDOR_RMPP_SUPPORT) && defined (DUAL_SIDED_RMPP)
case IB_MAD_METHOD_GETMULTI:
#endif
is_get_request = TRUE;
case IB_MAD_METHOD_SET:
case IB_MAD_METHOD_DELETE:
/* if we are closing down simply do nothing */
if (osm_exit_flag)
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
else
sa_mad_ctrl_process(p_ctrl, p_madw, is_get_request);
break;
default:
cl_atomic_inc(&p_ctrl->p_stats->sa_mads_rcvd_unknown);
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A05: "
"Unsupported method = 0x%X\n", p_sa_mad->method);
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
goto Exit;
}
Exit:
OSM_LOG_EXIT(p_ctrl->p_log);
}
/*
* PARAMETERS
*
* RETURN VALUES
*
* NOTES
*
* SEE ALSO
*********/
/****f* opensm: SA/sa_mad_ctrl_send_err_callback
* NAME
* sa_mad_ctrl_send_err_callback
*
* DESCRIPTION
* This is the callback from the transport layer for send errors
* on MADs that were expecting a response.
*
* SYNOPSIS
*/
static void sa_mad_ctrl_send_err_callback(IN void *context,
IN osm_madw_t * p_madw)
{
osm_sa_mad_ctrl_t *p_ctrl = context;
cl_status_t status;
OSM_LOG_ENTER(p_ctrl->p_log);
/*
We should never be here since the SA never originates a request.
Unless we generated a Report(Notice)
*/
CL_ASSERT(p_madw);
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A06: "
"MAD completed in error (%s): "
"%s(%s), attr_mod 0x%x, LID %u, TID 0x%" PRIx64 "\n",
ib_get_err_str(p_madw->status),
ib_get_sa_method_str(p_madw->p_mad->method),
ib_get_sa_attr_str(p_madw->p_mad->attr_id),
cl_ntoh32(p_madw->p_mad->attr_mod),
cl_ntoh16(p_madw->mad_addr.dest_lid),
cl_ntoh64(p_madw->p_mad->trans_id));
osm_dump_sa_mad_v2(p_ctrl->p_log, osm_madw_get_sa_mad_ptr(p_madw),
FILE_ID, OSM_LOG_ERROR);
/*
An error occurred. No response was received to a request MAD.
Retire the original request MAD.
*/
if (osm_madw_get_err_msg(p_madw) != CL_DISP_MSGID_NONE) {
OSM_LOG(p_ctrl->p_log, OSM_LOG_DEBUG,
"Posting Dispatcher message %s\n",
osm_get_disp_msg_str(osm_madw_get_err_msg(p_madw)));
if (p_ctrl->p_set_disp &&
(p_madw->p_mad->method == IB_MAD_METHOD_SET ||
p_madw->p_mad->method == IB_MAD_METHOD_DELETE))
status = cl_disp_post(p_ctrl->h_set_disp,
osm_madw_get_err_msg(p_madw),
p_madw,
sa_mad_ctrl_disp_done_callback,
p_ctrl);
else
status = cl_disp_post(p_ctrl->h_disp,
osm_madw_get_err_msg(p_madw),
p_madw,
sa_mad_ctrl_disp_done_callback,
p_ctrl);
if (status != CL_SUCCESS) {
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A07: "
"Dispatcher post message failed (%s)\n",
CL_STATUS_MSG(status));
}
} else /* No error message was provided, just retire the MAD. */
osm_mad_pool_put(p_ctrl->p_mad_pool, p_madw);
OSM_LOG_EXIT(p_ctrl->p_log);
}
/*
* PARAMETERS
*
* RETURN VALUES
*
* NOTES
*
* SEE ALSO
*********/
void osm_sa_mad_ctrl_construct(IN osm_sa_mad_ctrl_t * p_ctrl)
{
CL_ASSERT(p_ctrl);
memset(p_ctrl, 0, sizeof(*p_ctrl));
p_ctrl->h_disp = CL_DISP_INVALID_HANDLE;
p_ctrl->h_set_disp = CL_DISP_INVALID_HANDLE;
}
void osm_sa_mad_ctrl_destroy(IN osm_sa_mad_ctrl_t * p_ctrl)
{
CL_ASSERT(p_ctrl);
cl_disp_unregister(p_ctrl->h_disp);
cl_disp_unregister(p_ctrl->h_set_disp);
}
ib_api_status_t osm_sa_mad_ctrl_init(IN osm_sa_mad_ctrl_t * p_ctrl,
IN osm_sa_t * sa,
IN osm_mad_pool_t * p_mad_pool,
IN osm_vendor_t * p_vendor,
IN osm_subn_t * p_subn,
IN osm_log_t * p_log,
IN osm_stats_t * p_stats,
IN cl_dispatcher_t * p_disp,
IN cl_dispatcher_t * p_set_disp)
{
ib_api_status_t status = IB_SUCCESS;
OSM_LOG_ENTER(p_log);
osm_sa_mad_ctrl_construct(p_ctrl);
p_ctrl->sa = sa;
p_ctrl->p_log = p_log;
p_ctrl->p_disp = p_disp;
p_ctrl->p_set_disp = p_set_disp;
p_ctrl->p_mad_pool = p_mad_pool;
p_ctrl->p_vendor = p_vendor;
p_ctrl->p_stats = p_stats;
p_ctrl->p_subn = p_subn;
p_ctrl->h_disp = cl_disp_register(p_disp, CL_DISP_MSGID_NONE, NULL,
p_ctrl);
if (p_ctrl->h_disp == CL_DISP_INVALID_HANDLE) {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 1A08: "
"Dispatcher registration failed\n");
status = IB_INSUFFICIENT_RESOURCES;
goto Exit;
}
if (p_set_disp) {
p_ctrl->h_set_disp =
cl_disp_register(p_set_disp, CL_DISP_MSGID_NONE, NULL,
p_ctrl);
if (p_ctrl->h_set_disp == CL_DISP_INVALID_HANDLE) {
OSM_LOG(p_log, OSM_LOG_ERROR, "ERR 1A0A: "
"SA set dispatcher registration failed\n");
status = IB_INSUFFICIENT_RESOURCES;
goto Exit;
}
}
Exit:
OSM_LOG_EXIT(p_log);
return status;
}
ib_api_status_t osm_sa_mad_ctrl_bind(IN osm_sa_mad_ctrl_t * p_ctrl,
IN ib_net64_t port_guid)
{
osm_bind_info_t bind_info;
ib_api_status_t status = IB_SUCCESS;
OSM_LOG_ENTER(p_ctrl->p_log);
if (p_ctrl->h_bind != OSM_BIND_INVALID_HANDLE) {
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A09: "
"Multiple binds not allowed\n");
status = IB_ERROR;
goto Exit;
}
bind_info.class_version = 2;
bind_info.is_responder = TRUE;
bind_info.is_report_processor = FALSE;
bind_info.is_trap_processor = FALSE;
bind_info.mad_class = IB_MCLASS_SUBN_ADM;
bind_info.port_guid = port_guid;
bind_info.recv_q_size = OSM_SM_DEFAULT_QP1_RCV_SIZE;
bind_info.send_q_size = OSM_SM_DEFAULT_QP1_SEND_SIZE;
bind_info.timeout = p_ctrl->sa->p_subn->opt.transaction_timeout;
bind_info.retries = p_ctrl->sa->p_subn->opt.transaction_retries;
OSM_LOG(p_ctrl->p_log, OSM_LOG_VERBOSE,
"Binding to port GUID 0x%" PRIx64 "\n", cl_ntoh64(port_guid));
p_ctrl->h_bind = osm_vendor_bind(p_ctrl->p_vendor, &bind_info,
p_ctrl->p_mad_pool,
sa_mad_ctrl_rcv_callback,
sa_mad_ctrl_send_err_callback, p_ctrl);
if (p_ctrl->h_bind == OSM_BIND_INVALID_HANDLE) {
status = IB_ERROR;
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A10: "
"Vendor specific bind failed (%s)\n",
ib_get_err_str(status));
goto Exit;
}
Exit:
OSM_LOG_EXIT(p_ctrl->p_log);
return status;
}
ib_api_status_t osm_sa_mad_ctrl_unbind(IN osm_sa_mad_ctrl_t * p_ctrl)
{
ib_api_status_t status = IB_SUCCESS;
OSM_LOG_ENTER(p_ctrl->p_log);
if (p_ctrl->h_bind == OSM_BIND_INVALID_HANDLE) {
OSM_LOG(p_ctrl->p_log, OSM_LOG_ERROR, "ERR 1A11: "
"No previous bind\n");
status = IB_ERROR;
goto Exit;
}
osm_vendor_unbind(p_ctrl->h_bind);
Exit:
OSM_LOG_EXIT(p_ctrl->p_log);
return status;
}