/*

 * 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;

}