/*

 * Copyright (c) 2009 Sun Microsystems, Inc. All rights reserved.

 * Copyright (c) 2004-2009 Voltaire, Inc. All rights reserved.

 * Copyright (c) 2002-2015 Mellanox Technologies LTD. All rights reserved.

 * Copyright (c) 1996-2003 Intel Corporation. All rights reserved.

 * Copyright (c) 2009 HNR Consulting. All rights reserved.

 * Copyright (c) 2013 Oracle and/or its affiliates. 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_state_mgr_t.

 * This file implements the State Manager object.

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <iba/ib_types.h>

#include <complib/cl_passivelock.h>

#include <complib/cl_debug.h>

#include <complib/cl_qmap.h>

#include <opensm/osm_file_ids.h>

#define FILE_ID OSM_FILE_STATE_MGR_C

#include <opensm/osm_sm.h>

#include <opensm/osm_madw.h>

#include <opensm/osm_switch.h>

#include <opensm/osm_log.h>

#include <opensm/osm_subnet.h>

#include <opensm/osm_helper.h>

#include <opensm/osm_msgdef.h>

#include <opensm/osm_node.h>

#include <opensm/osm_port.h>

#include <vendor/osm_vendor_api.h>

#include <opensm/osm_inform.h>

#include <opensm/osm_opensm.h>

#include <opensm/osm_congestion_control.h>

#include <opensm/osm_db.h>

#include <opensm/osm_service.h>

#include <opensm/osm_guid.h>

extern void osm_drop_mgr_process(IN osm_sm_t * sm);

extern int osm_qos_setup(IN osm_opensm_t * p_osm);

extern int osm_pkey_mgr_process(IN osm_opensm_t * p_osm);

extern int osm_mcast_mgr_process(IN osm_sm_t * sm, boolean_t config_all);

extern int osm_link_mgr_process(IN osm_sm_t * sm, IN uint8_t state);

extern void osm_guid_mgr_process(IN osm_sm_t * sm);

static void state_mgr_up_msg(IN const osm_sm_t * sm)

{

	/*

	 * This message should be written only once - when the

	 * SM moves to Master state and the subnet is up for

	 * the first time.

	 */

	osm_log_v2(sm->p_log, sm->p_subn->first_time_master_sweep ?

		   OSM_LOG_SYS : OSM_LOG_INFO, FILE_ID, "SUBNET UP\n");

	OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,

			sm->p_subn->opt.sweep_interval ?

			"SUBNET UP" : "SUBNET UP (sweep disabled)");

}

static void state_mgr_reset_node_count(IN cl_map_item_t * p_map_item,

				       IN void *context)

{

	osm_node_t *p_node = (osm_node_t *) p_map_item;

	p_node->discovery_count = 0;

	memset(p_node->physp_discovered, 0, sizeof(uint8_t) * p_node->physp_tbl_size);

}

static void state_mgr_reset_port_count(IN cl_map_item_t * p_map_item,

				       IN void *context)

{

	osm_port_t *p_port = (osm_port_t *) p_map_item;

	p_port->discovery_count = 0;

}

static void state_mgr_reset_switch_count(IN cl_map_item_t * p_map_item,

					 IN void *context)

{

	osm_switch_t *p_sw = (osm_switch_t *) p_map_item;

	if (p_sw->max_lid_ho != 0)

		p_sw->need_update = 1;

}

static void state_mgr_get_sw_info(IN cl_map_item_t * p_object, IN void *context)

{

	osm_node_t *p_node;

	osm_physp_t *p_physp;

	osm_dr_path_t *p_dr_path;

	osm_madw_context_t mad_context;

	osm_switch_t *const p_sw = (osm_switch_t *) p_object;

	osm_sm_t *sm = context;

	ib_api_status_t status;

	OSM_LOG_ENTER(sm->p_log);

	p_node = p_sw->p_node;

	p_physp = osm_node_get_physp_ptr(p_node, 0);

	p_dr_path = osm_physp_get_dr_path_ptr(p_physp);

	memset(&mad_context, 0, sizeof(mad_context));

	mad_context.si_context.node_guid = osm_node_get_node_guid(p_node);

	mad_context.si_context.set_method = FALSE;

	mad_context.si_context.light_sweep = TRUE;

	mad_context.si_context.lft_top_change = FALSE;

	status = osm_req_get(sm, p_dr_path, IB_MAD_ATTR_SWITCH_INFO, 0,

			     FALSE, ib_port_info_get_m_key(&p_physp->port_info),

			     0, OSM_MSG_LIGHT_SWEEP_FAIL, &mad_context);

	if (status != IB_SUCCESS)

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3304: "

			"Request for SwitchInfo from 0x%" PRIx64 " failed (%s)\n",

			cl_ntoh64(osm_node_get_node_guid(p_node)),

			ib_get_err_str(status));

	OSM_LOG_EXIT(sm->p_log);

}

/**********************************************************************

 Initiate a remote port info request for the given physical port

 **********************************************************************/

static void state_mgr_get_remote_port_info(IN osm_sm_t * sm,

					   IN osm_physp_t * p_physp)

{

	osm_dr_path_t *p_dr_path;

	osm_dr_path_t rem_node_dr_path;

	osm_madw_context_t mad_context;

	ib_api_status_t status;

	OSM_LOG_ENTER(sm->p_log);

	/* generate a dr path leaving on the physp to the remote node */

	p_dr_path = osm_physp_get_dr_path_ptr(p_physp);

	memcpy(&rem_node_dr_path, p_dr_path, sizeof(osm_dr_path_t));

	if (osm_dr_path_extend(&rem_node_dr_path, osm_physp_get_port_num(p_physp))) {

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 332D: "

			"DR path with hop count %d couldn't be extended "

			"so skipping PortInfo query\n",

			p_dr_path->hop_count);

		goto Exit;

	}

	memset(&mad_context, 0, sizeof(mad_context));

	mad_context.pi_context.node_guid =

	    osm_node_get_node_guid(osm_physp_get_node_ptr(p_physp));

	mad_context.pi_context.port_guid = p_physp->port_guid;

	mad_context.pi_context.set_method = FALSE;

	mad_context.pi_context.light_sweep = TRUE;

	mad_context.pi_context.active_transition = FALSE;

	mad_context.pi_context.client_rereg = FALSE;

	/* note that with some negative logic - if the query failed it means

	 * that there is no point in going to heavy sweep */

	status = osm_req_get(sm, &rem_node_dr_path, IB_MAD_ATTR_PORT_INFO, 0,

			     TRUE, 0, 0, CL_DISP_MSGID_NONE, &mad_context);

	if (status != IB_SUCCESS)

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 332E: "

			"Request for remote PortInfo from 0x%" PRIx64 " failed (%s)\n",

			cl_ntoh64(p_physp->port_guid), ib_get_err_str(status));

Exit:

	OSM_LOG_EXIT(sm->p_log);

}

/**********************************************************************

 Initiates a thorough sweep of the subnet.

 Used when there is suspicion that something on the subnet has changed.

**********************************************************************/

static ib_api_status_t state_mgr_sweep_hop_0(IN osm_sm_t * sm)

{

	ib_api_status_t status;

	osm_dr_path_t dr_path;

	osm_bind_handle_t h_bind;

	uint8_t path_array[IB_SUBNET_PATH_HOPS_MAX];

	OSM_LOG_ENTER(sm->p_log);

	memset(path_array, 0, sizeof(path_array));

	/*

	 * First, get the bind handle.

	 */

	h_bind = osm_sm_mad_ctrl_get_bind_handle(&sm->mad_ctrl);

	if (h_bind != OSM_BIND_INVALID_HANDLE) {

		OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,

				"INITIATING HEAVY SWEEP");

		/*

		 * Start the sweep by clearing the port counts, then

		 * get our own NodeInfo at 0 hops.

		 */

		CL_PLOCK_ACQUIRE(sm->p_lock);

		cl_qmap_apply_func(&sm->p_subn->node_guid_tbl,

				   state_mgr_reset_node_count, sm);

		cl_qmap_apply_func(&sm->p_subn->port_guid_tbl,

				   state_mgr_reset_port_count, sm);

		cl_qmap_apply_func(&sm->p_subn->sw_guid_tbl,

				   state_mgr_reset_switch_count, sm);

		/* Set the in_sweep_hop_0 flag in subn to be TRUE.

		 * This will indicate the sweeping not to continue beyond the

		 * the current node.

		 * This is relevant for the case of SM on switch, since in the

		 * switch info we need to signal somehow not to continue

		 * the sweeping. */

		sm->p_subn->in_sweep_hop_0 = TRUE;

		CL_PLOCK_RELEASE(sm->p_lock);

		osm_dr_path_init(&dr_path, 0, path_array);

		CL_PLOCK_ACQUIRE(sm->p_lock);

		status = osm_req_get(sm, &dr_path, IB_MAD_ATTR_NODE_INFO, 0,

				     TRUE, 0, 0, CL_DISP_MSGID_NONE, NULL);

		CL_PLOCK_RELEASE(sm->p_lock);

		if (status != IB_SUCCESS)

			OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3305: "

				"Request for NodeInfo failed (%s)\n",

				ib_get_err_str(status));

	} else {

		OSM_LOG(sm->p_log, OSM_LOG_DEBUG,

			"No bound ports. Deferring sweep...\n");

		status = IB_INVALID_STATE;

	}

	OSM_LOG_EXIT(sm->p_log);

	return status;

}

/**********************************************************************

 Clear out all existing port lid assignments

**********************************************************************/

static ib_api_status_t state_mgr_clean_known_lids(IN osm_sm_t * sm)

{

	ib_api_status_t status = IB_SUCCESS;

	cl_ptr_vector_t *p_vec = &(sm->p_subn->port_lid_tbl);

	uint32_t i;

	OSM_LOG_ENTER(sm->p_log);

	/* we need a lock here! */

	CL_PLOCK_ACQUIRE(sm->p_lock);

	for (i = 0; i < cl_ptr_vector_get_size(p_vec); i++)

		cl_ptr_vector_set(p_vec, i, NULL);

	CL_PLOCK_RELEASE(sm->p_lock);

	OSM_LOG_EXIT(sm->p_log);

	return status;

}

/**********************************************************************

 Clear SA cache

**********************************************************************/

static ib_api_status_t state_mgr_sa_clean(IN osm_sm_t * sm)

{

	ib_api_status_t status = IB_SUCCESS;

	cl_qmap_t *p_port_guid_tbl;

	osm_assigned_guids_t *p_assigned_guids, *p_next_assigned_guids;

	osm_alias_guid_t *p_alias_guid, *p_next_alias_guid;

	osm_mcm_port_t *mcm_port;

	osm_subn_t * p_subn;

	osm_port_t *p_port;

	osm_infr_t *p_infr;

	osm_svcr_t *p_svcr;

	OSM_LOG_ENTER(sm->p_log);

	p_subn = sm->p_subn;

	/* we need a lock here! */

	CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);

	if (p_subn->opt.drop_event_subscriptions) {

		/* Clean InformInfo records */

		p_infr = (osm_infr_t *) cl_qlist_remove_head(&p_subn->sa_infr_list);

		while (p_infr !=

		       (osm_infr_t *) cl_qlist_end(&p_subn->sa_infr_list)) {

			osm_infr_delete(p_infr);

			p_infr = (osm_infr_t *) cl_qlist_remove_head(&p_subn->sa_infr_list);

		}

		/* For now, treat Service Records in same category as InformInfos */

		/* Clean Service records */

		p_svcr = (osm_svcr_t *) cl_qlist_remove_head(&p_subn->sa_sr_list);

		while (p_svcr !=

		       (osm_svcr_t *) cl_qlist_end(&p_subn->sa_sr_list)) {

			osm_svcr_delete(p_svcr);

			p_svcr = (osm_svcr_t *) cl_qlist_remove_head(&p_subn->sa_sr_list);

		}

	}

	/* Clean Multicast member list on each port */

	p_port_guid_tbl = &p_subn->port_guid_tbl;

	for (p_port = (osm_port_t *) cl_qmap_head(p_port_guid_tbl);

	     p_port != (osm_port_t *) cl_qmap_end(p_port_guid_tbl);

	     p_port = (osm_port_t *) cl_qmap_next(&p_port->map_item)) {

		while (!cl_is_qlist_empty(&p_port->mcm_list)) {

			mcm_port = cl_item_obj(cl_qlist_head(&p_port->mcm_list),

					       mcm_port, list_item);

			osm_mgrp_delete_port(p_subn, sm->p_log, mcm_port->mgrp,

					     p_port);

		}

		/* Hack - clean alias guid table from physp */

		free(p_port->p_physp->p_guids);

		p_port->p_physp->p_guids = NULL;

	}

	/* Clean Alias Guid work objects */

	while (cl_qlist_count(&p_subn->alias_guid_list))

		osm_guid_work_obj_delete((osm_guidinfo_work_obj_t *)

			cl_qlist_remove_head(&p_subn->alias_guid_list));

	/* Clean Assigned GUIDs table */

	p_next_assigned_guids = (osm_assigned_guids_t *)

				cl_qmap_head(&p_subn->assigned_guids_tbl);

	while (p_next_assigned_guids !=

	       (osm_assigned_guids_t *) cl_qmap_end(&p_subn->assigned_guids_tbl)) {

		p_assigned_guids = p_next_assigned_guids;

		p_next_assigned_guids = (osm_assigned_guids_t *)

					cl_qmap_next(&p_assigned_guids->map_item);

		cl_qmap_remove_item(&p_subn->assigned_guids_tbl,

				    &p_assigned_guids->map_item);

		osm_assigned_guids_delete(&p_assigned_guids);

        }

	/* Clean Alias GUIDs table */

	p_next_alias_guid = (osm_alias_guid_t *)

			    cl_qmap_head(&p_subn->alias_port_guid_tbl);

	while (p_next_alias_guid !=

	       (osm_alias_guid_t *) cl_qmap_end(&p_subn->alias_port_guid_tbl)) {

		p_alias_guid = p_next_alias_guid;

		p_next_alias_guid = (osm_alias_guid_t *)

				    cl_qmap_next(&p_alias_guid->map_item);

		if (osm_alias_guid_get_alias_guid(p_alias_guid) !=

		    osm_alias_guid_get_base_guid(p_alias_guid)) {

			/* Clean if it's not base port GUID */

			cl_qmap_remove_item(&p_subn->alias_port_guid_tbl,

					    &p_alias_guid->map_item);

			osm_alias_guid_delete(&p_alias_guid);

		}

	}

	p_subn->p_osm->sa.dirty = TRUE;

	CL_PLOCK_RELEASE(sm->p_lock);

	OSM_LOG_EXIT(sm->p_log);

	return status;

}

/**********************************************************************

 Notifies the transport layer that the local LID has changed,

 which give it a chance to update address vectors, etc..

**********************************************************************/

static ib_api_status_t state_mgr_notify_lid_change(IN osm_sm_t * sm)

{

	ib_api_status_t status;

	osm_bind_handle_t h_bind;

	OSM_LOG_ENTER(sm->p_log);

	/*

	 * First, get the bind handle.

	 */

	h_bind = osm_sm_mad_ctrl_get_bind_handle(&sm->mad_ctrl);

	if (h_bind == OSM_BIND_INVALID_HANDLE) {

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3306: "

			"No bound ports\n");

		status = IB_ERROR;

		goto Exit;

	}

	/*

	 * Notify the transport layer that we changed the local LID.

	 */

	status = osm_vendor_local_lid_change(h_bind);

	if (status != IB_SUCCESS)

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3307: "

			"Vendor LID update failed (%s)\n",

			ib_get_err_str(status));

Exit:

	OSM_LOG_EXIT(sm->p_log);

	return status;

}

/**********************************************************************

 Returns true if the SM port is down.

 The SM's port object must exist in the port_guid table.

**********************************************************************/

static boolean_t state_mgr_is_sm_port_down(IN osm_sm_t * sm)

{

	ib_net64_t port_guid;

	osm_port_t *p_port;

	osm_physp_t *p_physp;

	uint8_t state;

	OSM_LOG_ENTER(sm->p_log);

	port_guid = sm->p_subn->sm_port_guid;

	/*

	 * If we don't know our own port guid yet, assume the port is down.

	 */

	if (port_guid == 0) {

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3308: "

			"SM port GUID unknown\n");

		state = IB_LINK_DOWN;

		goto Exit;

	}

	CL_ASSERT(port_guid);

	CL_PLOCK_ACQUIRE(sm->p_lock);

	p_port = osm_get_port_by_guid(sm->p_subn, port_guid);

	if (!p_port) {

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3309: "

			"SM port with GUID:%016" PRIx64 " is unknown\n",

			cl_ntoh64(port_guid));

		state = IB_LINK_DOWN;

		CL_PLOCK_RELEASE(sm->p_lock);

		goto Exit;

	}

	p_physp = p_port->p_physp;

	CL_ASSERT(p_physp);

	if (p_port->p_node->sw &&

	    !ib_switch_info_is_enhanced_port0(&p_port->p_node->sw->switch_info))

		state = IB_LINK_ACTIVE;	/* base SP0 */

	else

		state = osm_physp_get_port_state(p_physp);

	if (!p_port->discovery_count) {

		OSM_LOG(sm->p_log, OSM_LOG_ERROR,

			"ERR 330A: Failed to discover SM port\n");

		state = IB_LINK_DOWN;

	}

	CL_PLOCK_RELEASE(sm->p_lock);

Exit:

	OSM_LOG_EXIT(sm->p_log);

	return (state == IB_LINK_DOWN);

}

/**********************************************************************

 Sweeps the node 1 hop away.

 This sets off a "chain reaction" that causes discovery of the subnet.

 Used when there is suspicion that something on the subnet has changed.

**********************************************************************/

static ib_api_status_t state_mgr_sweep_hop_1(IN osm_sm_t * sm)

{

	ib_api_status_t status = IB_SUCCESS;

	osm_madw_context_t context;

	osm_node_t *p_node;

	osm_port_t *p_port;

	osm_dr_path_t hop_1_path;

	ib_net64_t port_guid;

	uint8_t port_num;

	uint8_t path_array[IB_SUBNET_PATH_HOPS_MAX];

	uint8_t num_ports;

	osm_physp_t *p_ext_physp;

	OSM_LOG_ENTER(sm->p_log);

	/*

	 * First, get our own port and node objects.

	 */

	port_guid = sm->p_subn->sm_port_guid;

	CL_ASSERT(port_guid);

	/* Set the in_sweep_hop_0 flag in subn to be FALSE.

	 * This will indicate the sweeping to continue beyond the

	 * the current node.

	 * This is relevant for the case of SM on switch, since in the

	 * switch info we need to signal that the sweeping should

	 * continue through the switch. */

	sm->p_subn->in_sweep_hop_0 = FALSE;

	p_port = osm_get_port_by_guid(sm->p_subn, port_guid);

	if (!p_port) {

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3310: "

			"No SM port object\n");

		status = IB_ERROR;

		goto Exit;

	}

	p_node = p_port->p_node;

	CL_ASSERT(p_node);

	port_num = ib_node_info_get_local_port_num(&p_node->node_info);

	OSM_LOG(sm->p_log, OSM_LOG_DEBUG,

		"Probing hop 1 on local port %u\n", port_num);

	memset(path_array, 0, sizeof(path_array));

	/* the hop_1 operations depend on the type of our node.

	 * Currently - legal nodes that can host SM are SW and CA */

	switch (osm_node_get_type(p_node)) {

	case IB_NODE_TYPE_CA:

	case IB_NODE_TYPE_ROUTER:

		memset(&context, 0, sizeof(context));

		context.ni_context.node_guid = osm_node_get_node_guid(p_node);

		context.ni_context.port_num = port_num;

		path_array[1] = port_num;

		osm_dr_path_init(&hop_1_path, 1, path_array);

		CL_PLOCK_ACQUIRE(sm->p_lock);

		status = osm_req_get(sm, &hop_1_path, IB_MAD_ATTR_NODE_INFO, 0,

				     TRUE, 0, 0, CL_DISP_MSGID_NONE, &context);

		CL_PLOCK_RELEASE(sm->p_lock);

		if (status != IB_SUCCESS)

			OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3311: "

				"Request for NodeInfo failed (%s)\n",

				ib_get_err_str(status));

		break;

	case IB_NODE_TYPE_SWITCH:

		/* Need to go over all the ports of the switch, and send a

		 * node_info from them. This doesn't include the port 0 of the

		 * switch, which hosts the SM.

		 * Note: We'll send another switchInfo on port 0, since if no

		 * ports are connected, we still want to get some response, and

		 * have the subnet come up.

		 */

		num_ports = osm_node_get_num_physp(p_node);

		for (port_num = 1; port_num < num_ports; port_num++) {

			/* go through the port only if the port is not DOWN */

			p_ext_physp = osm_node_get_physp_ptr(p_node, port_num);

			if (p_ext_physp && ib_port_info_get_port_state

			    (&(p_ext_physp->port_info)) > IB_LINK_DOWN) {

				memset(&context, 0, sizeof(context));

				context.ni_context.node_guid =

				    osm_node_get_node_guid(p_node);

				context.ni_context.port_num = port_num;

				path_array[1] = port_num;

				osm_dr_path_init(&hop_1_path, 1, path_array);

				CL_PLOCK_ACQUIRE(sm->p_lock);

				status = osm_req_get(sm, &hop_1_path,

						     IB_MAD_ATTR_NODE_INFO, 0,

						     TRUE, 0, 0,

						     CL_DISP_MSGID_NONE,

						     &context);

				CL_PLOCK_RELEASE(sm->p_lock);

				if (status != IB_SUCCESS)

					OSM_LOG(sm->p_log, OSM_LOG_ERROR,

						"ERR 3312: "

						"Request for NodeInfo failed (%s)\n",

						ib_get_err_str(status));

			}

		}

		break;

	default:

		OSM_LOG(sm->p_log, OSM_LOG_ERROR,

			"ERR 3313: Unknown node type %d (%s)\n",

			osm_node_get_type(p_node), p_node->print_desc);

	}

Exit:

	OSM_LOG_EXIT(sm->p_log);

	return status;

}

static void query_sm_info(cl_map_item_t * item, void *cxt)

{

	osm_madw_context_t context;

	osm_remote_sm_t *r_sm = cl_item_obj(item, r_sm, map_item);

	osm_sm_t *sm = cxt;

	ib_api_status_t ret;

	osm_port_t *p_port;

	p_port= osm_get_port_by_guid(sm->p_subn, r_sm->smi.guid);

	if (p_port == NULL) {

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3340: "

			"No port object on given sm object\n");

		return;

        }

	context.smi_context.port_guid = r_sm->smi.guid;

	context.smi_context.set_method = FALSE;

	context.smi_context.light_sweep = TRUE;

	ret = osm_req_get(sm, osm_physp_get_dr_path_ptr(p_port->p_physp),

			  IB_MAD_ATTR_SM_INFO, 0, FALSE,

			  ib_port_info_get_m_key(&p_port->p_physp->port_info),

			  0, CL_DISP_MSGID_NONE, &context);

	if (ret != IB_SUCCESS)

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3314: "

			"Failure requesting SMInfo (%s)\n",

			ib_get_err_str(ret));

}

static void state_mgr_reset_state_change_bit(IN cl_map_item_t * obj,

					     IN void *context)

{

	osm_madw_context_t mad_context;

	osm_switch_t *p_sw = (osm_switch_t *) obj;

	osm_sm_t *sm = context;

	osm_node_t *p_node;

	osm_physp_t *p_physp;

	osm_dr_path_t *p_path;

	ib_api_status_t status;

	ib_switch_info_t si;

	OSM_LOG_ENTER(sm->p_log);

	CL_ASSERT(p_sw);

	p_node = p_sw->p_node;

	CL_ASSERT(p_node);

	p_physp = osm_node_get_physp_ptr(p_node, 0);

	p_path = osm_physp_get_dr_path_ptr(p_physp);

	if (!ib_switch_info_get_state_change(&p_sw->switch_info))

		goto exit;

	si = p_sw->switch_info;

	ib_switch_info_state_change_set(&si);

	OSM_LOG(sm->p_log, OSM_LOG_DEBUG,

		"Resetting PortStateChange on switch GUID 0x%016" PRIx64 "\n",

		cl_ntoh64(osm_node_get_node_guid(p_node)));

	mad_context.si_context.light_sweep = FALSE;

	mad_context.si_context.node_guid = osm_node_get_node_guid(p_node);

	mad_context.si_context.set_method = TRUE;

	mad_context.si_context.lft_top_change = FALSE;

	status = osm_req_set(sm, p_path, (uint8_t *) &si,

			     sizeof(si), IB_MAD_ATTR_SWITCH_INFO,

			     0, FALSE,

			     ib_port_info_get_m_key(&p_physp->port_info),

			     0, CL_DISP_MSGID_NONE, &mad_context);

	if (status != IB_SUCCESS)

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 332A: "

			"Sending SwitchInfo attribute failed (%s)\n",

			ib_get_err_str(status));

exit:

	OSM_LOG_EXIT(sm->p_log);

}

static void state_mgr_update_node_desc(IN cl_map_item_t * obj, IN void *context)

{

	osm_madw_context_t mad_context;

	osm_node_t *p_node = (osm_node_t *) obj;

	osm_sm_t *sm = context;

	osm_physp_t *p_physp = NULL;

	unsigned i, num_ports;

	ib_api_status_t status;

	OSM_LOG_ENTER(sm->p_log);

	CL_ASSERT(p_node);

	OSM_LOG(sm->p_log, OSM_LOG_DEBUG,

		"Updating NodeDesc for 0x%016" PRIx64 "\n",

		cl_ntoh64(osm_node_get_node_guid(p_node)));

	/* get a physp to request from. */

	num_ports = osm_node_get_num_physp(p_node);

	for (i = 0; i < num_ports; i++)

		if ((p_physp = osm_node_get_physp_ptr(p_node, i)))

			break;

	if (!p_physp) {

		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 331C: "

			"Failed to find any valid physical port object.\n");

		goto exit;

	}

	mad_context.nd_context.node_guid = osm_node_get_node_guid(p_node);

	status = osm_req_get(sm, osm_physp_get_dr_path_ptr(p_physp),

			     IB_MAD_ATTR_NODE_DESC, 0, FALSE,

			     ib_port_info_get_m_key(&p_physp->port_info),

			     0, CL_DISP_MSGID_NONE, &mad_context);

	if (status != IB_SUCCESS)

		OSM_LOG(sm->p_log, OSM_LOG_ERROR,

			"ERR 331B: Failure initiating NodeDescription request "

			"(%s) to 0x%016" PRIx64 "\n", ib_get_err_str(status),

			cl_ntoh64(osm_node_get_node_guid(p_node)));

exit:

	OSM_LOG_EXIT(sm->p_log);

}

void osm_reset_switch_state_change_bit(IN osm_opensm_t *osm)

{

	CL_PLOCK_ACQUIRE(&osm->lock);

	cl_qmap_apply_func(&osm->subn.sw_guid_tbl, state_mgr_reset_state_change_bit,

			   &osm->sm);

	CL_PLOCK_RELEASE(&osm->lock);

}

void osm_update_node_desc(IN osm_opensm_t *osm)

{

	CL_PLOCK_ACQUIRE(&osm->lock);

	cl_qmap_apply_func(&osm->subn.node_guid_tbl, state_mgr_update_node_desc,

			   &osm->sm);

	CL_PLOCK_RELEASE(&osm->lock);

}

/**********************************************************************

 During a light sweep, check each node to see if the node description

 is valid and if not issue a ND query.

**********************************************************************/

static void state_mgr_get_node_desc(IN cl_map_item_t * obj, IN void *context)

{

	osm_node_t *p_node = (osm_node_t *) obj;

	osm_sm_t *sm = context;

	OSM_LOG_ENTER(sm->p_log);

	CL_ASSERT(p_node);

	if (p_node->print_desc

	    && strcmp(p_node->print_desc, OSM_NODE_DESC_UNKNOWN))

		/* if ND is valid, do nothing */

		goto exit;

	OSM_LOG(sm->p_log, OSM_LOG_ERROR,

		"ERR 3319: Unknown node description for node GUID "

		"0x%016" PRIx64 ".  Reissuing ND query\n",

		cl_ntoh64(osm_node_get_node_guid(p_node)));

	state_mgr_update_node_desc(obj, context);

exit:

	OSM_LOG_EXIT(sm->p_log);

}

/**********************************************************************

 Initiates a lightweight sweep of the subnet.

 Used during normal sweeps after the subnet is up.

**********************************************************************/

static ib_api_status_t state_mgr_light_sweep_start(IN osm_sm_t * sm)

{

	ib_api_status_t status = IB_SUCCESS;

	osm_bind_handle_t h_bind;

	cl_qmap_t *p_sw_tbl;

	cl_map_item_t *p_next;

	osm_node_t *p_node;

	osm_physp_t *p_physp;

	uint8_t port_num;

	OSM_LOG_ENTER(sm->p_log);

	p_sw_tbl = &sm->p_subn->sw_guid_tbl;

	/*

	 * First, get the bind handle.

	 */

	h_bind = osm_sm_mad_ctrl_get_bind_handle(&sm->mad_ctrl);

	if (h_bind == OSM_BIND_INVALID_HANDLE) {

		OSM_LOG(sm->p_log, OSM_LOG_DEBUG,

			"No bound ports. Deferring sweep...\n");

		status = IB_INVALID_STATE;

		goto _exit;

	}

	OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE, "INITIATING LIGHT SWEEP");

	CL_PLOCK_ACQUIRE(sm->p_lock);

	cl_qmap_apply_func(p_sw_tbl, state_mgr_get_sw_info, sm);

	CL_PLOCK_RELEASE(sm->p_lock);

	CL_PLOCK_ACQUIRE(sm->p_lock);

	cl_qmap_apply_func(&sm->p_subn->node_guid_tbl, state_mgr_get_node_desc,

			   sm);

	CL_PLOCK_RELEASE(sm->p_lock);

	/* now scan the list of physical ports that were not down but have no remote port */

	CL_PLOCK_ACQUIRE(sm->p_lock);

	p_next = cl_qmap_head(&sm->p_subn->node_guid_tbl);

	while (p_next != cl_qmap_end(&sm->p_subn->node_guid_tbl)) {

		p_node = (osm_node_t *) p_next;

		p_next = cl_qmap_next(p_next);

		for (port_num = 1; port_num < osm_node_get_num_physp(p_node);

		     port_num++) {

			p_physp = osm_node_get_physp_ptr(p_node, port_num);

			if (p_physp && (osm_physp_get_port_state(p_physp) !=

					IB_LINK_DOWN)

			    && !osm_physp_get_remote(p_physp)) {

				OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3315: "

					"Unknown remote side for node 0x%016"

					PRIx64

					" (%s) port %u. Adding to light sweep sampling list\n",

					cl_ntoh64(osm_node_get_node_guid

						  (p_node)),

					p_node->print_desc, port_num);

				osm_dump_dr_path_v2(sm->p_log,

						    osm_physp_get_dr_path_ptr

						    (p_physp), FILE_ID, OSM_LOG_ERROR);

				state_mgr_get_remote_port_info(sm, p_physp);

			}

		}

	}

	cl_qmap_apply_func(&sm->p_subn->sm_guid_tbl, query_sm_info, sm);

	CL_PLOCK_RELEASE(sm->p_lock);

_exit:

	OSM_LOG_EXIT(sm->p_log);

	return status;

}

/**********************************************************************

 * Go over all the remote SMs (as updated in the sm_guid_tbl).

 * Find if there is a remote sm that is a master SM.

 * If there is a remote master SM - return a pointer to it,

 * else - return NULL.

 **********************************************************************/

static osm_remote_sm_t *state_mgr_exists_other_master_sm(IN osm_sm_t * sm)

{

	cl_qmap_t *p_sm_tbl;

	osm_remote_sm_t *p_sm;

	osm_remote_sm_t *p_sm_res = NULL;

	osm_node_t *p_node;

	OSM_LOG_ENTER(sm->p_log);

	p_sm_tbl = &sm->p_subn->sm_guid_tbl;