/*

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

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

 * Copyright (c) 1996-2003 Intel Corporation. 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_lid_mgr_t.

 * This file implements the LID Manager object which is responsible for

 * assigning LIDs to all ports on the subnet.

 *

 * DATA STRUCTURES:

 *  p_subn->port_lid_tbl : a vector pointing from lid to its port.

 *  osm db guid2lid domain : a hash from guid to lid (min lid).

 *  p_subn->port_guid_tbl : a map from guid to discovered port obj.

 *

 * ALGORITHM:

 *

 * 0. we define a function to obtain the correct port lid:

 *    lid_mgr_get_port_lid( p_mgr, port, &min_lid, &max_lid ):

 *    0.1 if the port info lid matches the guid2lid return 0

 *    0.2 if the port info has a lid and that range is empty in

 *        port_lid_tbl, return 0 and update the port_lid_tbl and

 *        guid2lid

 *    0.3 else find an empty space in port_lid_tbl, update the

 *    port_lid_tbl and guid2lid, return 1 to flag a change required.

 *

 * 1. During initialization:

 *   1.1 initialize the guid2lid database domain.

 *   1.2 if reassign_lid is not set:

 *   1.2.1 read the persistent data for the domain.

 *   1.2.2 validate no duplicate use of lids and lids are 2^(lmc-1)

 *

 * 2. During SM port lid assignment:

 *   2.1 if reassign_lids is set, make it 2^lmc

 *   2.2 cleanup all port_lid_tbl and re-fill it according to guid2lid

 *   2.3 call lid_mgr_get_port_lid for the SM port

 *   2.4 set the port info

 *

 * 3. During all other ports lid assignment:

 *   3.1 go through all ports in the subnet

 *   3.1.1 call lid_mgr_get_port_lid

 *   3.1.2 if a change required send the port info

 *   3.2 if any change send the signal PENDING...

 *

 * 4. Store the guid2lid

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#include <stdlib.h>

#include <string.h>

#include <iba/ib_types.h>

#include <complib/cl_qmap.h>

#include <complib/cl_debug.h>

#include <opensm/osm_file_ids.h>

#define FILE_ID OSM_FILE_LID_MGR_C

#include <opensm/osm_lid_mgr.h>

#include <opensm/osm_sm.h>

#include <opensm/osm_log.h>

#include <opensm/osm_node.h>

#include <opensm/osm_switch.h>

#include <opensm/osm_helper.h>

#include <opensm/osm_msgdef.h>

#include <vendor/osm_vendor_api.h>

#include <opensm/osm_db_pack.h>

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

  lid range item of qlist

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

typedef struct osm_lid_mgr_range {

	cl_list_item_t item;

	uint16_t min_lid;

	uint16_t max_lid;

} osm_lid_mgr_range_t;

void osm_lid_mgr_construct(IN osm_lid_mgr_t * p_mgr)

{

	memset(p_mgr, 0, sizeof(*p_mgr));

}

void osm_lid_mgr_destroy(IN osm_lid_mgr_t * p_mgr)

{

	cl_list_item_t *p_item;

	OSM_LOG_ENTER(p_mgr->p_log);

	while ((p_item = cl_qlist_remove_head(&p_mgr->free_ranges)) !=

	       cl_qlist_end(&p_mgr->free_ranges))

		free((osm_lid_mgr_range_t *) p_item);

	OSM_LOG_EXIT(p_mgr->p_log);

}

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

Validate the guid to lid data by making sure that under the current

LMC we did not get duplicates. If we do flag them as errors and remove

the entry.

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

static void lid_mgr_validate_db(IN osm_lid_mgr_t * p_mgr)

{

	cl_qlist_t guids;

	osm_db_guid_elem_t *p_item;

	uint16_t lid;

	uint16_t min_lid;

	uint16_t max_lid;

	uint16_t lmc_mask;

	boolean_t lids_ok;

	uint8_t lmc_num_lids = (uint8_t) (1 << p_mgr->p_subn->opt.lmc);

	OSM_LOG_ENTER(p_mgr->p_log);

	lmc_mask = ~(lmc_num_lids - 1);

	cl_qlist_init(&guids);

	if (osm_db_guid2lid_guids(p_mgr->p_g2l, &guids)) {

		OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 0310: "

			"could not get guid list\n");

		goto Exit;

	}

	while ((p_item = (osm_db_guid_elem_t *) cl_qlist_remove_head(&guids))

	       != (osm_db_guid_elem_t *) cl_qlist_end(&guids)) {

		if (osm_db_guid2lid_get(p_mgr->p_g2l, p_item->guid,

					&min_lid, &max_lid))

			OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 0311: "

				"could not get lid for guid:0x%016" PRIx64 "\n",

				p_item->guid);

		else {

			lids_ok = TRUE;

			if (min_lid > max_lid || min_lid == 0

			    || p_item->guid == 0

			    || max_lid > p_mgr->p_subn->max_ucast_lid_ho) {

				OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR,

					"ERR 0312: "

					"Illegal LID range [%u:%u] for "

					"guid:0x%016" PRIx64 "\n", min_lid,

					max_lid, p_item->guid);

				lids_ok = FALSE;

			} else if (min_lid != max_lid

				   && (min_lid & lmc_mask) != min_lid) {

				/* check that if the lids define a range that is

				   valid for the current LMC mask */

				OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR,

					"ERR 0313: "

					"LID range [%u:%u] for guid:0x%016"

					PRIx64

					" is not aligned according to mask:0x%04x\n",

					min_lid, max_lid, p_item->guid,

					lmc_mask);

				lids_ok = FALSE;

			} else {

				/* check if the lids were not previously assigned */

				for (lid = min_lid; lid <= max_lid; lid++) {

					if (p_mgr->used_lids[lid]) {

						OSM_LOG(p_mgr->p_log,

							OSM_LOG_ERROR,

							"ERR 0314: "

							"0x%04x for guid:0x%016"

							PRIx64

							" was previously used\n",

							lid, p_item->guid);

						lids_ok = FALSE;

					}

				}

			}

			if (lids_ok)

				/* mark that it was visited */

				for (lid = min_lid; lid <= max_lid; lid++) {

					if (lid < min_lid + lmc_num_lids)

						p_mgr->used_lids[lid] = 1;

				}

			else if (osm_db_guid2lid_delete(p_mgr->p_g2l,

							p_item->guid))

				OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR,

					"ERR 0315: failed to delete entry for "

					"guid:0x%016" PRIx64 "\n",

					p_item->guid);

		}		/* got a lid */

		free(p_item);

	}			/* all guids */

Exit:

	OSM_LOG_EXIT(p_mgr->p_log);

}

ib_api_status_t osm_lid_mgr_init(IN osm_lid_mgr_t * p_mgr, IN osm_sm_t * sm)

{

	ib_api_status_t status = IB_SUCCESS;

	OSM_LOG_ENTER(sm->p_log);

	osm_lid_mgr_construct(p_mgr);

	p_mgr->sm = sm;

	p_mgr->p_log = sm->p_log;

	p_mgr->p_subn = sm->p_subn;

	p_mgr->p_db = sm->p_db;

	p_mgr->p_lock = sm->p_lock;

	/* we initialize and restore the db domain of guid to lid map */

	p_mgr->p_g2l = osm_db_domain_init(p_mgr->p_db, "guid2lid");

	if (!p_mgr->p_g2l) {

		OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 0316: "

			"Error initializing Guid-to-Lid persistent database\n");

		status = IB_ERROR;

		goto Exit;

	}

	cl_qlist_init(&p_mgr->free_ranges);

	/* we use the stored guid to lid table if not forced to reassign */

	if (!p_mgr->p_subn->opt.reassign_lids) {

		if (osm_db_restore(p_mgr->p_g2l)) {

#ifndef __WIN__

			/*

			 * When Windows is BSODing, it might corrupt files that

			 * were previously opened for writing, even if the files

			 * are closed, so we might see corrupted guid2lid file.

			 */

			if (p_mgr->p_subn->opt.exit_on_fatal) {

				osm_log_v2(p_mgr->p_log, OSM_LOG_SYS, FILE_ID,

					   "FATAL: Error restoring Guid-to-Lid "

					   "persistent database\n");

				status = IB_ERROR;

				goto Exit;

			} else

#endif

				OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR,

					"ERR 0317: Error restoring Guid-to-Lid "

					"persistent database\n");

		}

		/* we need to make sure we did not get duplicates with

		   current lmc */

		lid_mgr_validate_db(p_mgr);

	}

Exit:

	OSM_LOG_EXIT(p_mgr->p_log);

	return status;

}

static uint16_t trim_lid(IN uint16_t lid)

{

	if (lid > IB_LID_UCAST_END_HO || lid < IB_LID_UCAST_START_HO)

		return 0;

	return lid;

}

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

 initialize the manager for a new sweep:

 scans the known persistent assignment and port_lid_tbl

 re-calculate all empty ranges.

 cleanup invalid port_lid_tbl entries

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

static int lid_mgr_init_sweep(IN osm_lid_mgr_t * p_mgr)

{

	cl_ptr_vector_t *p_discovered_vec = &p_mgr->p_subn->port_lid_tbl;

	uint16_t max_defined_lid, max_persistent_lid, max_discovered_lid;

	uint16_t disc_min_lid, disc_max_lid, db_min_lid, db_max_lid;

	int status = 0;

	cl_list_item_t *p_item;

	boolean_t is_free;

	osm_lid_mgr_range_t *p_range = NULL;

	osm_port_t *p_port;

	cl_qmap_t *p_port_guid_tbl;

	uint8_t lmc_num_lids = (uint8_t) (1 << p_mgr->p_subn->opt.lmc);

	uint16_t lmc_mask, req_lid, num_lids, lid;

	OSM_LOG_ENTER(p_mgr->p_log);

	lmc_mask = ~((1 << p_mgr->p_subn->opt.lmc) - 1);

	/* We must discard previous guid2lid db if this is the first master

	 * sweep and reassign_lids option is TRUE.

	 * If we came out of standby and honor_guid2lid_file option is TRUE, we

	 * must restore guid2lid db. Otherwise if honor_guid2lid_file option is

	 * FALSE we must discard previous guid2lid db.

	 */

	if (p_mgr->p_subn->first_time_master_sweep == TRUE &&

	    p_mgr->p_subn->opt.reassign_lids == TRUE) {

		osm_db_clear(p_mgr->p_g2l);

		memset(p_mgr->used_lids, 0, sizeof(p_mgr->used_lids));

	} else if (p_mgr->p_subn->coming_out_of_standby == TRUE) {

		osm_db_clear(p_mgr->p_g2l);

		memset(p_mgr->used_lids, 0, sizeof(p_mgr->used_lids));

		if (p_mgr->p_subn->opt.honor_guid2lid_file == FALSE)

			OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

				"Ignore guid2lid file when coming out of standby\n");

		else {

			OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

				"Honor current guid2lid file when coming out "

				"of standby\n");

			if (osm_db_restore(p_mgr->p_g2l))

				OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR,

					"ERR 0306: "

					"Error restoring Guid-to-Lid "

					"persistent database. Ignoring it\n");

			lid_mgr_validate_db(p_mgr);

		}

	}

	/* we need to cleanup the empty ranges list */

	while ((p_item = cl_qlist_remove_head(&p_mgr->free_ranges)) !=

	       cl_qlist_end(&p_mgr->free_ranges))

		free((osm_lid_mgr_range_t *) p_item);

	/* first clean up the port_by_lid_tbl */

	for (lid = 0; lid < cl_ptr_vector_get_size(p_discovered_vec); lid++)

		cl_ptr_vector_set(p_discovered_vec, lid, NULL);

	/* we if are in the first sweep and in reassign lids mode

	   we should ignore all the available info and simply define one

	   huge empty range */

	if (p_mgr->p_subn->first_time_master_sweep == TRUE &&

	    p_mgr->p_subn->opt.reassign_lids == TRUE) {

		OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

			"Skipping all lids as we are reassigning them\n");

		p_range = malloc(sizeof(osm_lid_mgr_range_t));

		if (p_range)

			p_range->min_lid = 1;

		goto AfterScanningLids;

	}

	/* go over all discovered ports and mark their entries */

	p_port_guid_tbl = &p_mgr->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)) {

		osm_port_get_lid_range_ho(p_port, &disc_min_lid, &disc_max_lid);

		disc_min_lid = trim_lid(disc_min_lid);

		disc_max_lid = trim_lid(disc_max_lid);

		for (lid = disc_min_lid; lid <= disc_max_lid; lid++) {

			if (lid < disc_min_lid + lmc_num_lids)

				cl_ptr_vector_set(p_discovered_vec, lid, p_port);

			else

				cl_ptr_vector_set(p_discovered_vec, lid, NULL);

		}

		/* make sure the guid2lid entry is valid. If not, clean it. */

		if (osm_db_guid2lid_get(p_mgr->p_g2l,

					cl_ntoh64(osm_port_get_guid(p_port)),

					&db_min_lid, &db_max_lid))

			continue;

		if (!p_port->p_node->sw ||

		    osm_switch_sp0_is_lmc_capable(p_port->p_node->sw,

						  p_mgr->p_subn))

			num_lids = lmc_num_lids;

		else

			num_lids = 1;

		if (num_lids != 1 &&

		    ((db_min_lid & lmc_mask) != db_min_lid ||

		     db_max_lid - db_min_lid + 1 < num_lids)) {

			/* Not aligned, or not wide enough, then remove the entry */

			OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

				"Cleaning persistent entry for guid:"

				"0x%016" PRIx64 " illegal range:[0x%x:0x%x]\n",

				cl_ntoh64(osm_port_get_guid(p_port)),

				db_min_lid, db_max_lid);

			osm_db_guid2lid_delete(p_mgr->p_g2l,

					       cl_ntoh64

					       (osm_port_get_guid(p_port)));

			for (lid = db_min_lid; lid <= db_max_lid; lid++)

				p_mgr->used_lids[lid] = 0;

		}

	}

	/*

	   Our task is to find free lid ranges.

	   A lid can be used if

	   1. a persistent assignment exists

	   2. the lid is used by a discovered port that does not have a

	   persistent assignment.

	   scan through all lid values of both the persistent table and

	   discovered table.

	   If the lid has an assigned port in the discovered table:

	   * make sure the lid matches the persistent table, or

	   * there is no other persistent assignment for that lid.

	   * else cleanup the port_by_lid_tbl, mark this as empty range.

	   Else if the lid does not have an entry in the persistent table

	   mark it as free.

	 */

	/* find the range of lids to scan */

	max_discovered_lid =

	    (uint16_t) cl_ptr_vector_get_size(p_discovered_vec);

	max_persistent_lid = sizeof(p_mgr->used_lids) - 1;

	/* but the vectors have one extra entry for lid=0 */

	if (max_discovered_lid)

		max_discovered_lid--;

	if (max_persistent_lid > max_discovered_lid)

		max_defined_lid = max_persistent_lid;

	else

		max_defined_lid = max_discovered_lid;

	for (lid = 1; lid <= max_defined_lid; lid++) {

		is_free = TRUE;

		/* first check to see if the lid is used by a persistent assignment */

		if (lid <= max_persistent_lid && p_mgr->used_lids[lid]) {

			OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

				"0x%04x is not free as its mapped by the "

				"persistent db\n", lid);

			is_free = FALSE;

			/* check this is a discovered port */

		} else if (lid <= max_discovered_lid &&

			   (p_port = cl_ptr_vector_get(p_discovered_vec,

						       lid))) {

			/* we have a port. Now lets see if we can preserve its lid range. */

			/* For that, we need to make sure:

			   1. The port has a (legal) persistency entry. Then the

			   local lid is free (we will use the persistency value).

			   2. Can the port keep its local assignment?

			   a. Make sure the lid is aligned.

			   b. Make sure all needed lids (for the lmc) are free

			   according to persistency table.

			 */

			/* qualify the guid of the port is not persistently

			   mapped to another range */

			if (!osm_db_guid2lid_get(p_mgr->p_g2l,

						 cl_ntoh64

						 (osm_port_get_guid(p_port)),

						 &db_min_lid, &db_max_lid)) {

				OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

					"0x%04x is free as it was "

					"discovered but mapped by the "

					"persistent db to [0x%04x:0x%04x]\n",

					lid, db_min_lid, db_max_lid);

			} else {

				/* can the port keep its assignment ? */

				/* get the lid range of that port, and the

				   required number of lids we are about to

				   assign to it */

				osm_port_get_lid_range_ho(p_port,

							  &disc_min_lid,

							  &disc_max_lid);

				if (!p_port->p_node->sw ||

				    osm_switch_sp0_is_lmc_capable

				    (p_port->p_node->sw, p_mgr->p_subn)) {

					disc_max_lid =

					    disc_min_lid + lmc_num_lids - 1;

					num_lids = lmc_num_lids;

				} else

					num_lids = 1;

				/* Make sure the lid is aligned */

				if (num_lids != 1

				    && (disc_min_lid & lmc_mask) !=

				    disc_min_lid) {

					/* The lid cannot be used */

					OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

						"0x%04x is free as it was "

						"discovered but not aligned\n",

						lid);

				} else {

					/* check that all needed lids are not persistently mapped */

					is_free = FALSE;

					for (req_lid = disc_min_lid + 1;

					     req_lid <= disc_max_lid;

					     req_lid++) {

						if (req_lid <=

						    max_persistent_lid &&

						    p_mgr->used_lids[req_lid]) {

							OSM_LOG(p_mgr->p_log,

								OSM_LOG_DEBUG,

								"0x%04x is free as it was discovered "

								"but mapped\n",

								lid);

							is_free = TRUE;

							break;

						}

					}

					if (is_free == FALSE) {

						/* This port will use its local lid, and consume the entire required lid range.

						   Thus we can skip that range. */

						/* If the disc_max_lid is greater then lid, we can skip right to it,

						   since we've done all neccessary checks on the lids in between. */

						if (disc_max_lid > lid)

							lid = disc_max_lid;

					}

				}

			}

		}

		if (is_free) {

			if (p_range)

				p_range->max_lid = lid;

			else {

				p_range = malloc(sizeof(osm_lid_mgr_range_t));

				if (p_range) {

					p_range->min_lid = lid;

					p_range->max_lid = lid;

				}

			}

		/* this lid is used so we need to finalize the previous free range */

		} else if (p_range) {

			cl_qlist_insert_tail(&p_mgr->free_ranges,

					     &p_range->item);

			OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

				"new free lid range [%u:%u]\n",

				p_range->min_lid, p_range->max_lid);

			p_range = NULL;

		}

	}

AfterScanningLids:

	/* after scanning all known lids we need to extend the last range

	   to the max allowed lid */

	if (!p_range) {

		p_range = malloc(sizeof(osm_lid_mgr_range_t));

		/*

		   The p_range can be NULL in one of 2 cases:

		   1. If max_defined_lid == 0. In this case, we want the

		   entire range.

		   2. If all lids discovered in the loop where mapped. In this

		   case, no free range exists and we want to define it after the

		   last mapped lid.

		 */

		if (p_range)

			p_range->min_lid = lid;

	}

	if (p_range) {

		p_range->max_lid = p_mgr->p_subn->max_ucast_lid_ho;

		cl_qlist_insert_tail(&p_mgr->free_ranges, &p_range->item);

		OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

			"final free lid range [%u:%u]\n",

			p_range->min_lid, p_range->max_lid);

	}

	OSM_LOG_EXIT(p_mgr->p_log);

	return status;

}

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

 check if the given range of lids is free

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

static boolean_t lid_mgr_is_range_not_persistent(IN osm_lid_mgr_t * p_mgr,

						 IN uint16_t lid,

						 IN uint16_t num_lids)

{

	uint16_t i;

	for (i = lid; i < lid + num_lids; i++)

		if (p_mgr->used_lids[i])

			return FALSE;

	return TRUE;

}

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

find a free lid range

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

static void lid_mgr_find_free_lid_range(IN osm_lid_mgr_t * p_mgr,

					IN uint8_t num_lids,

					OUT uint16_t * p_min_lid,

					OUT uint16_t * p_max_lid)

{

	uint16_t lid;

	cl_list_item_t *p_item;

	cl_list_item_t *p_next_item;

	osm_lid_mgr_range_t *p_range = NULL;

	uint8_t lmc_num_lids;

	uint16_t lmc_mask;

	OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG, "LMC = %u, number LIDs = %u\n",

		p_mgr->p_subn->opt.lmc, num_lids);

	lmc_num_lids = (1 << p_mgr->p_subn->opt.lmc);

	lmc_mask = ~((1 << p_mgr->p_subn->opt.lmc) - 1);

	/*

	   Search the list of free lid ranges for a range which is big enough

	 */

	p_item = cl_qlist_head(&p_mgr->free_ranges);

	while (p_item != cl_qlist_end(&p_mgr->free_ranges)) {

		p_next_item = cl_qlist_next(p_item);

		p_range = (osm_lid_mgr_range_t *) p_item;

		lid = p_range->min_lid;

		/* if we require more then one lid we must align to LMC */

		if (num_lids > 1) {

			if ((lid & lmc_mask) != lid)

				lid = (lid + lmc_num_lids) & lmc_mask;

		}

		/* but we can be out of the range */

		if (lid + num_lids - 1 <= p_range->max_lid) {

			/* ok let us use that range */

			if (lid + num_lids - 1 == p_range->max_lid) {

				/* we consumed the entire range */

				cl_qlist_remove_item(&p_mgr->free_ranges,

						     p_item);

				free(p_item);

			} else

				/* only update the available range */

				p_range->min_lid = lid + num_lids;

			*p_min_lid = lid;

			*p_max_lid = (uint16_t) (lid + num_lids - 1);

			return;

		}

		p_item = p_next_item;

	}

	/*

	   Couldn't find a free range of lids.

	 */

	*p_min_lid = *p_max_lid = 0;

	/* if we run out of lids, give an error and abort! */

	OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 0307: "

		"OPENSM RAN OUT OF LIDS!!!\n");

	CL_ASSERT(0);

}

static void lid_mgr_cleanup_discovered_port_lid_range(IN osm_lid_mgr_t * p_mgr,

						      IN osm_port_t * p_port)

{

	cl_ptr_vector_t *p_discovered_vec = &p_mgr->p_subn->port_lid_tbl;

	uint16_t lid, min_lid, max_lid;

	uint16_t max_tbl_lid =

	    (uint16_t) (cl_ptr_vector_get_size(p_discovered_vec));

	osm_port_get_lid_range_ho(p_port, &min_lid, &max_lid);

	min_lid = trim_lid(min_lid);

	max_lid = trim_lid(max_lid);

	for (lid = min_lid; lid <= max_lid; lid++)

		if (lid < max_tbl_lid &&

		    p_port == cl_ptr_vector_get(p_discovered_vec, lid))

			cl_ptr_vector_set(p_discovered_vec, lid, NULL);

}

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

 0.1 if the port info lid matches the guid2lid return 0

 0.2 if the port info has a lid and that range is empty in

     port_lid_tbl, return 0 and update the port_lid_tbl and

     guid2lid

 0.3 else find an empty space in port_lid_tbl, update the

 port_lid_tbl and guid2lid, return 1 to flag a change required.

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

static int lid_mgr_get_port_lid(IN osm_lid_mgr_t * p_mgr,

				IN osm_port_t * p_port,

				OUT uint16_t * p_min_lid,

				OUT uint16_t * p_max_lid)

{

	uint16_t lid, min_lid, max_lid;

	uint64_t guid;

	uint8_t num_lids = (1 << p_mgr->p_subn->opt.lmc);

	int lid_changed = 0;

	uint16_t lmc_mask;

	OSM_LOG_ENTER(p_mgr->p_log);

	/* get the lid from the guid2lid */

	guid = cl_ntoh64(osm_port_get_guid(p_port));

	/* if the port is a base switch port 0 then we only need one lid */

	if (p_port->p_node->sw &&

	    !osm_switch_sp0_is_lmc_capable(p_port->p_node->sw, p_mgr->p_subn))

		num_lids = 1;

	if (p_mgr->p_subn->first_time_master_sweep == TRUE &&

	    p_mgr->p_subn->opt.reassign_lids == TRUE)

		goto AssignLid;

	lmc_mask = ~(num_lids - 1);

	/* if the port matches the guid2lid */

	if (!osm_db_guid2lid_get(p_mgr->p_g2l, guid, &min_lid, &max_lid)) {

		*p_min_lid = min_lid;

		*p_max_lid = min_lid + num_lids - 1;

		if (min_lid == cl_ntoh16(osm_port_get_base_lid(p_port)))

			OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG, "0x%016" PRIx64

				" matches its known lid:%u\n", guid, min_lid);

		else {

			OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

				"0x%016" PRIx64 " with lid:%u "

				"does not match its known lid:%u\n",

				guid, cl_ntoh16(osm_port_get_base_lid(p_port)),

				min_lid);

			lid_mgr_cleanup_discovered_port_lid_range(p_mgr,

								  p_port);

			/* we still need to send the setting to the target port */

			lid_changed = 1;

		}

		goto NewLidSet;

	} else

		OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

			"0x%016" PRIx64 " has no persistent lid assigned\n",

			guid);

	/* if the port info carries a lid it must be lmc aligned and not mapped

	   by the persistent storage  */

	min_lid = cl_ntoh16(osm_port_get_base_lid(p_port));

	/* we want to ignore the discovered lid if we are also on first sweep of

	   reassign lids flow */

	if (min_lid) {

		/* make sure lid is valid */

		if ((min_lid & lmc_mask) == min_lid) {

			/* is it free */

			if (lid_mgr_is_range_not_persistent

			    (p_mgr, min_lid, num_lids)) {

				*p_min_lid = min_lid;

				*p_max_lid = min_lid + num_lids - 1;

				OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

					"0x%016" PRIx64

					" lid range:[%u-%u] is free\n",

					guid, *p_min_lid, *p_max_lid);

				goto NewLidSet;

			} else

				OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

					"0x%016" PRIx64 " existing lid "

					"range:[%u:%u] is not free\n",

					guid, min_lid, min_lid + num_lids - 1);

		} else

			OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

				"0x%016" PRIx64 " existing lid range:"

				"[%u:%u] is not lmc aligned\n",

				guid, min_lid, min_lid + num_lids - 1);

	}

AssignLid:

	/* first cleanup the existing discovered lid range */

	lid_mgr_cleanup_discovered_port_lid_range(p_mgr, p_port);

	/* find an empty space */

	lid_mgr_find_free_lid_range(p_mgr, num_lids, p_min_lid, p_max_lid);

	OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

		"0x%016" PRIx64 " assigned a new lid range:[%u-%u]\n",

		guid, *p_min_lid, *p_max_lid);

	lid_changed = 1;

NewLidSet:

	/* update the guid2lid db and used_lids */

	osm_db_guid2lid_set(p_mgr->p_g2l, guid, *p_min_lid, *p_max_lid);

	for (lid = *p_min_lid; lid <= *p_max_lid; lid++)

		p_mgr->used_lids[lid] = 1;

	/* make sure the assigned lids are marked in port_lid_tbl */

	for (lid = *p_min_lid; lid <= *p_max_lid; lid++)

		cl_ptr_vector_set(&p_mgr->p_subn->port_lid_tbl, lid, p_port);

	OSM_LOG_EXIT(p_mgr->p_log);

	return lid_changed;

}

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

 Set to INIT the remote port of the given physical port

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

static void lid_mgr_set_remote_pi_state_to_init(IN osm_lid_mgr_t * p_mgr,

						IN osm_physp_t * p_physp)

{

	osm_physp_t *p_rem_physp = osm_physp_get_remote(p_physp);

	if (p_rem_physp == NULL)

		return;

	/* but in some rare cases the remote side might be non responsive */

	ib_port_info_set_port_state(&p_rem_physp->port_info, IB_LINK_INIT);

}

static int lid_mgr_set_physp_pi(IN osm_lid_mgr_t * p_mgr,

				IN osm_port_t * p_port,

				IN osm_physp_t * p_physp, IN ib_net16_t lid)

{

	uint8_t payload[IB_SMP_DATA_SIZE];

	ib_port_info_t *p_pi = (ib_port_info_t *) payload;

	const ib_port_info_t *p_old_pi;

	osm_madw_context_t context;

	osm_node_t *p_node;

	ib_api_status_t status;

	uint8_t mtu;

	uint8_t op_vls;

	uint8_t port_num;

	boolean_t send_set = FALSE;

	boolean_t send_client_rereg = FALSE;

	boolean_t update_mkey = FALSE;

	int ret = 0;

	OSM_LOG_ENTER(p_mgr->p_log);

	/*

	   Don't bother doing anything if this Physical Port is not valid.

	   This allows simplified code in the caller.

	 */

	if (!p_physp)

		goto Exit;

	port_num = osm_physp_get_port_num(p_physp);

	p_node = osm_physp_get_node_ptr(p_physp);

	if (osm_node_get_type(p_node) == IB_NODE_TYPE_SWITCH && port_num != 0) {

		/*

		   Switch ports that are not numbered 0 should not be set

		   with the following attributes as they are set later

		   (during NO_CHANGE state in link mgr).

		 */

		OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,

			"Skipping switch port %u, GUID 0x%016" PRIx64 "\n",

			port_num, cl_ntoh64(osm_physp_get_port_guid(p_physp)));

		goto Exit;

	}

	p_old_pi = &p_physp->port_info;

	/*

	   First, copy existing parameters from the PortInfo attribute we

	   already have for this node.

	   Second, update with default values that we know must be set for

	   every Physical Port and the LID and set the neighbor MTU field

	   appropriately.

	   Third, send the SMP to this physical port.

	 */

	memcpy(payload, p_old_pi, sizeof(ib_port_info_t));

	/*

	   Should never write back a value that is bigger then 3 in

	   the PortPhysicalState field, so cannot simply copy!

	   Actually we want to write there:

	   port physical state - no change

	   link down default state = polling

	   port state - no change

	 */

	p_pi->state_info2 = 0x02;

	ib_port_info_set_port_state(p_pi, IB_LINK_NO_CHANGE);

	if (ib_port_info_get_link_down_def_state(p_pi) !=

	    ib_port_info_get_link_down_def_state(p_old_pi))

		send_set = TRUE;

	/* didn't get PortInfo before */

	if (!ib_port_info_get_port_state(p_old_pi))

		send_set = TRUE;

	p_pi->m_key = p_mgr->p_subn->opt.m_key;

	if (memcmp(&p_pi->m_key, &p_old_pi->m_key, sizeof(p_pi->m_key))) {