/*

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

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

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

 * Copyright (c) 2008 Xsigo Systems Inc.  All rights reserved.

 * Copyright (c) 2009 System Fabric Works, Inc. All rights reserved.

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

 * Copyright (c) 2009-2015 ZIH, TU Dresden, Federal Republic of Germany. All rights reserved.

 * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.

 * Copyright (C) 2012-2017 Tokyo Institute of Technology. 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_subn_t.

 * This object represents an IBA subnet.

 * This object is part of the opensm family of objects.

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#include <string.h>

#include <stdio.h>

#include <stdarg.h>

#include <limits.h>

#include <errno.h>

#include <ctype.h>

#include <complib/cl_debug.h>

#include <complib/cl_log.h>

#include <opensm/osm_file_ids.h>

#define FILE_ID OSM_FILE_SUBNET_C

#include <opensm/osm_subnet.h>

#include <opensm/osm_opensm.h>

#include <opensm/osm_log.h>

#include <opensm/osm_madw.h>

#include <opensm/osm_port.h>

#include <opensm/osm_switch.h>

#include <opensm/osm_remote_sm.h>

#include <opensm/osm_partition.h>

#include <opensm/osm_node.h>

#include <opensm/osm_guid.h>

#include <opensm/osm_multicast.h>

#include <opensm/osm_inform.h>

#include <opensm/osm_console.h>

#include <opensm/osm_perfmgr.h>

#include <opensm/osm_congestion_control.h>

#include <opensm/osm_event_plugin.h>

#include <opensm/osm_qos_policy.h>

#include <opensm/osm_service.h>

#include <opensm/osm_db.h>

#include <opensm/osm_db_pack.h>

static const char null_str[] = "(null)";

#define OPT_OFFSET(opt) offsetof(osm_subn_opt_t, opt)

#define ARR_SIZE(a) (sizeof(a)/sizeof((a)[0]))

typedef struct opt_rec {

	const char *name;

	unsigned long opt_offset;

	void (*parse_fn)(osm_subn_t *p_subn, char *p_key, char *p_val_str,

			 void *p_val1, void *p_val2,

			 void (*)(osm_subn_t *, void *));

	void (*setup_fn)(osm_subn_t *p_subn, void *p_val);

	int  can_update;

} opt_rec_t;

static const char *module_name_str[] = {

	"main.c",

	"osm_console.c",

	"osm_console_io.c",

	"osm_db_files.c",

	"osm_db_pack.c",

	"osm_drop_mgr.c",

	"osm_dump.c",

	"osm_event_plugin.c",

	"osm_guid_info_rcv.c",

	"osm_guid_mgr.c",

	"osm_helper.c",

	"osm_inform.c",

	"osm_lid_mgr.c",

	"osm_lin_fwd_rcv.c",

	"osm_link_mgr.c",

	"osm_log.c",

	"osm_mad_pool.c",

	"osm_mcast_fwd_rcv.c",

	"osm_mcast_mgr.c",

	"osm_mcast_tbl.c",

	"osm_mcm_port.c",

	"osm_mesh.c",

	"osm_mlnx_ext_port_info_rcv.c",

	"osm_mtree.c",

	"osm_multicast.c",

	"osm_node.c",

	"osm_node_desc_rcv.c",

	"osm_node_info_rcv.c",

	"osm_opensm.c",

	"osm_perfmgr.c",

	"osm_perfmgr_db.c",

	"osm_pkey.c",

	"osm_pkey_mgr.c",

	"osm_pkey_rcv.c",

	"osm_port.c",

	"osm_port_info_rcv.c",

	"osm_prtn.c",

	"osm_prtn_config.c",

	"osm_qos.c",

	"osm_qos_parser_l.c",

	"osm_qos_parser_y.c",

	"osm_qos_policy.c",

	"osm_remote_sm.c",

	"osm_req.c",

	"osm_resp.c",

	"osm_router.c",

	"osm_sa.c",

	"osm_sa_class_port_info.c",

	"osm_sa_guidinfo_record.c",

	"osm_sa_informinfo.c",

	"osm_sa_lft_record.c",

	"osm_sa_link_record.c",

	"osm_sa_mad_ctrl.c",

	"osm_sa_mcmember_record.c",

	"osm_sa_mft_record.c",

	"osm_sa_multipath_record.c",

	"osm_sa_node_record.c",

	"osm_sa_path_record.c",

	"osm_sa_pkey_record.c",

	"osm_sa_portinfo_record.c",

	"osm_sa_service_record.c",

	"osm_sa_slvl_record.c",

	"osm_sa_sminfo_record.c",

	"osm_sa_sw_info_record.c",

	"osm_sa_vlarb_record.c",

	"osm_service.c",

	"osm_slvl_map_rcv.c",

	"osm_sm.c",

	"osm_sminfo_rcv.c",

	"osm_sm_mad_ctrl.c",

	"osm_sm_state_mgr.c",

	"osm_state_mgr.c",

	"osm_subnet.c",

	"osm_sw_info_rcv.c",

	"osm_switch.c",

	"osm_torus.c",

	"osm_trap_rcv.c",

	"osm_ucast_cache.c",

	"osm_ucast_dnup.c",

	"osm_ucast_file.c",

	"osm_ucast_ftree.c",

	"osm_ucast_lash.c",

	"osm_ucast_mgr.c",

	"osm_ucast_updn.c",

	"osm_vendor_ibumad.c",

	"osm_vl15intf.c",

	"osm_vl_arb_rcv.c",

	"st.c",

	"osm_ucast_dfsssp.c",

	"osm_congestion_control.c",

	"osm_ucast_nue.c",

	/* Add new module names here ... */

	/* FILE_ID define in those modules must be identical to index here */

	/* last FILE_ID is currently 90 */

};

#define MOD_NAME_STR_UNKNOWN_VAL (ARR_SIZE(module_name_str))

static int find_module_name(const char *name, uint8_t *file_id)

{

	uint8_t i;

	for (i = 0; i < MOD_NAME_STR_UNKNOWN_VAL; i++) {

		if (strcmp(name, module_name_str[i]) == 0) {

			if (file_id)

				*file_id = i;

			return 0;

		}

	}

	return 1;

}

static void log_report(const char *fmt, ...)

{

	char buf[128];

	va_list args;

	va_start(args, fmt);

	vsnprintf(buf, sizeof(buf), fmt, args);

	va_end(args);

	printf("%s", buf);

	cl_log_event("OpenSM", CL_LOG_INFO, buf, NULL, 0);

}

static void log_config_value(char *name, const char *fmt, ...)

{

	char buf[128];

	va_list args;

	unsigned n;

	va_start(args, fmt);

	n = snprintf(buf, sizeof(buf), " Loading Cached Option:%s = ", name);

	if (n > sizeof(buf))

		n = sizeof(buf);

	n += vsnprintf(buf + n, sizeof(buf) - n, fmt, args);

	if (n > sizeof(buf) - 2)

		n = sizeof(buf) - 2;

	snprintf(buf + n, sizeof(buf) - n, "\n");

	va_end(args);

	printf("%s", buf);

	cl_log_event("OpenSM", CL_LOG_INFO, buf, NULL, 0);

}

static void opts_setup_log_flags(osm_subn_t *p_subn, void *p_val)

{

	p_subn->p_osm->log.level = *((uint8_t *) p_val);

}

static void opts_setup_force_log_flush(osm_subn_t *p_subn, void *p_val)

{

	p_subn->p_osm->log.flush = *((boolean_t *) p_val);

}

static void opts_setup_accum_log_file(osm_subn_t *p_subn, void *p_val)

{

	p_subn->p_osm->log.accum_log_file = *((boolean_t *) p_val);

}

static void opts_setup_log_max_size(osm_subn_t *p_subn, void *p_val)

{

	uint32_t log_max_size = *((uint32_t *) p_val);

	p_subn->p_osm->log.max_size = (unsigned long)log_max_size << 20; /* convert from MB to bytes */

}

static void opts_setup_sminfo_polling_timeout(osm_subn_t *p_subn, void *p_val)

{

	osm_sm_t *p_sm = &p_subn->p_osm->sm;

	uint32_t sminfo_polling_timeout = *((uint32_t *) p_val);

	cl_timer_stop(&p_sm->polling_timer);

	cl_timer_start(&p_sm->polling_timer, sminfo_polling_timeout);

}

static void opts_setup_sm_priority(osm_subn_t *p_subn, void *p_val)

{

	osm_sm_t *p_sm = &p_subn->p_osm->sm;

	uint8_t sm_priority = *((uint8_t *) p_val);

	osm_set_sm_priority(p_sm, sm_priority);

}

static int opts_strtoul(uint32_t *val, IN char *p_val_str,

			IN char *p_key, uint32_t max_value)

{

	char *endptr;

	unsigned long int tmp_val;

	errno = 0;

	tmp_val = strtoul(p_val_str, &endptr, 0);

	*val = tmp_val;

	if (*p_val_str == '\0' || *endptr != '\0') {

		log_report("-E- Parsing error in field %s, expected "

			   "numeric input received: %s\n", p_key, p_val_str);

		return -1;

	}

	if (tmp_val > max_value ||

	    ((tmp_val == ULONG_MAX) && errno == ERANGE)) {

		log_report("-E- Parsing error in field %s, value out of range\n", p_key);

		return -1;

	}

	return 0;

}

static int opts_strtoull(uint64_t *val, IN char *p_val_str,

			 IN char *p_key, uint64_t max_value)

{

	char *endptr;

	unsigned long long int tmp_val;

	errno = 0;

	tmp_val = strtoull(p_val_str, &endptr, 0);

	*val = tmp_val;

	if (*p_val_str == '\0' || *endptr != '\0') {

		log_report("-E- Parsing error in field %s, expected "

			   "numeric input received: %s\n", p_key, p_val_str);

		return -1;

	}

	if (tmp_val > max_value || (tmp_val == ULLONG_MAX && errno == ERANGE)) {

		log_report("-E- Parsing error in field %s, value out of range\n", p_key);

		return -1;

	}

	return 0;

}

static void opts_parse_net64(IN osm_subn_t *p_subn, IN char *p_key,

			     IN char *p_val_str, void *p_v1, void *p_v2,

			     void (*pfn)(osm_subn_t *, void *))

{

	uint64_t *p_val1 = p_v1, *p_val2 = p_v2;

	uint64_t val;

	if (opts_strtoull(&val, p_val_str, p_key, UINT64_MAX))

		return;

	if (cl_hton64(val) != *p_val1) {

		log_config_value(p_key, "0x%016" PRIx64, val);

		if (pfn)

			pfn(p_subn, &val;;

		*p_val1 = *p_val2 = cl_ntoh64(val);

	}

}

static void opts_parse_uint32(IN osm_subn_t *p_subn, IN char *p_key,

			      IN char *p_val_str, void *p_v1, void *p_v2,

			      void (*pfn)(osm_subn_t *, void *))

{

	uint32_t *p_val1 = p_v1, *p_val2 = p_v2;

	uint32_t val;

	if (opts_strtoul(&val, p_val_str, p_key, UINT32_MAX))

		return;

	if (val != *p_val1) {

		log_config_value(p_key, "%u", val);

		if (pfn)

			pfn(p_subn, &val;;

		*p_val1 = *p_val2 = val;

	}

}

static void opts_parse_net32(IN osm_subn_t *p_subn, IN char *p_key,

			     IN char *p_val_str, void *p_v1, void *p_v2,

			     void (*pfn)(osm_subn_t *, void *))

{

	uint32_t *p_val1 = p_v1, *p_val2 = p_v2;

	uint32_t val;

	if (opts_strtoul(&val, p_val_str, p_key, UINT32_MAX))

		return;

	if (cl_hton32(val) != *p_val1) {

		log_config_value(p_key, "%u", val);

		if (pfn)

			pfn(p_subn, &val;;

		*p_val1 = *p_val2 = cl_hton32(val);

	}

}

static void opts_parse_int32(IN osm_subn_t *p_subn, IN char *p_key,

			     IN char *p_val_str, void *p_v1, void *p_v2,

			     void (*pfn)(osm_subn_t *, void *))

{

	int32_t *p_val1 = p_v1, *p_val2 = p_v2;

	int32_t val = strtol(p_val_str, NULL, 0);

	if (val != *p_val1) {

		log_config_value(p_key, "%d", val);

		if (pfn)

			pfn(p_subn, &val;;

		*p_val1 = *p_val2 = val;

	}

}

static void opts_parse_uint16(IN osm_subn_t *p_subn, IN char *p_key,

			      IN char *p_val_str, void *p_v1, void *p_v2,

			      void (*pfn)(osm_subn_t *, void *))

{

	uint16_t *p_val1 = p_v1, *p_val2 = p_v2;

	uint32_t tmp_val;

	if (opts_strtoul(&tmp_val, p_val_str, p_key, UINT16_MAX))

		return;

	uint16_t val = (uint16_t) tmp_val;

	if (val != *p_val1) {

		log_config_value(p_key, "%u", val);

		if (pfn)

			pfn(p_subn, &val;;

		*p_val1 = *p_val2 = val;

	}

}

static void opts_parse_net16(IN osm_subn_t *p_subn, IN char *p_key,

			     IN char *p_val_str, void *p_v1, void *p_v2,

			     void (*pfn)(osm_subn_t *, void *))

{

	uint16_t *p_val1 = p_v1, *p_val2 = p_v2;

	uint32_t tmp_val;

	if (opts_strtoul(&tmp_val, p_val_str, p_key, UINT16_MAX))

		return;

	uint16_t val = (uint16_t) tmp_val;

	if (cl_hton16(val) != *p_val1) {

		log_config_value(p_key, "0x%04x", val);

		if (pfn)

			pfn(p_subn, &val;;

		*p_val1 = *p_val2 = cl_hton16(val);

	}

}

static void opts_parse_uint8(IN osm_subn_t *p_subn, IN char *p_key,

			     IN char *p_val_str, void *p_v1, void *p_v2,

			     void (*pfn)(osm_subn_t *, void *))

{

	uint8_t *p_val1 = p_v1, *p_val2 = p_v2;

	uint32_t tmp_val;

	if (opts_strtoul(&tmp_val, p_val_str, p_key, UINT8_MAX))

		return;

	uint8_t val = (uint8_t) tmp_val;

	if (val != *p_val1) {

		log_config_value(p_key, "%u", val);

		if (pfn)

			pfn(p_subn, &val;;

		*p_val1 = *p_val2 = val;

	}

}

static void opts_parse_boolean(IN osm_subn_t *p_subn, IN char *p_key,

			       IN char *p_val_str, void *p_v1, void *p_v2,

			       void (*pfn)(osm_subn_t *, void *))

{

	boolean_t *p_val1 = p_v1, *p_val2 = p_v2;

	boolean_t val;

	if (!p_val_str)

		return;

	if (strcmp("TRUE", p_val_str))

		val = FALSE;

	else

		val = TRUE;

	if (val != *p_val1) {

		log_config_value(p_key, "%s", p_val_str);

		if (pfn)

			pfn(p_subn, &val;;

		*p_val1 = *p_val2 = val;

	}

}

static void opts_parse_charp(IN osm_subn_t *p_subn, IN char *p_key,

			     IN char *p_val_str, void *p_v1, void *p_v2,

			     void (*pfn)(osm_subn_t *, void *))

{

	char **p_val1 = p_v1, **p_val2 = p_v2;

	const char *current_str = *p_val1 ? *p_val1 : null_str;

	if (p_val_str && strcmp(p_val_str, current_str)) {

		char *new;

		log_config_value(p_key, "%s", p_val_str);

		/* special case the "(null)" string */

		new = strcmp(null_str, p_val_str) ? strdup(p_val_str) : NULL;

		if (pfn)

			pfn(p_subn, new);

		if (*p_val1 && *p_val1 != *p_val2)

			free(*p_val1);

		if (*p_val2)

			free(*p_val2);

		*p_val1 = *p_val2 = new;

	}

}

static void opts_parse_256bit(IN osm_subn_t *p_subn, IN char *p_key,

			      IN char *p_val_str, void *p_v1, void *p_v2,

			      void (*pfn)(osm_subn_t *, void *))

{

	uint8_t *p_val1 = p_v1, *p_val2 = p_v2;

	uint8_t val[IB_CC_PORT_MASK_DATA_SIZE] = { 0 };

	char tmpbuf[3] = { 0 };

	uint8_t tmpint;

	int numdigits = 0;

	int startindex;

	char *strptr = p_val_str;

	char *ptr;

	int i;

	/* parse like it's hypothetically a 256 bit integer code

	 *

	 * store "big endian"

	 */

	if (!strncmp(strptr, "0x", 2) || !strncmp(strptr, "0X", 2))

		strptr+=2;

	for (ptr = strptr; *ptr; ptr++) {

		if (!isxdigit(*ptr)) {

			log_report("invalid hex digit in bitmask\n");

			return;

		}

		numdigits++;

	}

	if (!numdigits) {

		log_report("invalid length bitmask\n");

		return;

	}

	/* max of 2 hex chars per byte */

	if (numdigits > IB_CC_PORT_MASK_DATA_SIZE * 2)

		numdigits = IB_CC_PORT_MASK_DATA_SIZE * 2;

	startindex = IB_CC_PORT_MASK_DATA_SIZE - ((numdigits - 1) / 2) - 1;

	if (numdigits % 2) {

		memcpy(tmpbuf, strptr, 1);

		strptr += 1;

	}

	else {

		memcpy(tmpbuf, strptr, 2);

		strptr += 2;

	}

	tmpint = strtoul(tmpbuf, NULL, 16);

	val[startindex] = tmpint;

	for (i = (startindex + 1); i < IB_CC_PORT_MASK_DATA_SIZE; i++) {

		memcpy(tmpbuf, strptr, 2);

		strptr += 2;

		tmpint = strtoul(tmpbuf, NULL, 16);

		val[i] = tmpint;

	}

	if (memcmp(val, p_val1, IB_CC_PORT_MASK_DATA_SIZE)) {

		log_config_value(p_key, "%s", p_val_str);

		if (pfn)

			pfn(p_subn, val);

		memcpy(p_val1, val, IB_CC_PORT_MASK_DATA_SIZE);

		memcpy(p_val2, val, IB_CC_PORT_MASK_DATA_SIZE);

	}

}

static void opts_parse_cct_entry(IN osm_subn_t *p_subn, IN char *p_key,

				 IN char *p_val_str, void *p_v1, void *p_v2,

				 void (*pfn)(osm_subn_t *, void *))

{

	osm_cct_entry_t *p_cct1 = p_v1, *p_cct2 = p_v2;

	osm_cct_entry_t cct;

	char buf[512] = { 0 };

	char *ptr;

	strncpy(buf, p_val_str, 511);

	if (!(ptr = strchr(buf, ':'))) {

		log_report("invalid CCT entry\n");

		return;

	}

	*ptr = '\0';

	ptr++;

	cct.shift = strtoul(buf, NULL, 0);

	cct.multiplier = strtoul(ptr, NULL, 0);

	if (cct.shift != p_cct1->shift

	    || cct.multiplier != p_cct1->multiplier) {

		log_config_value(p_key, "%s", p_val_str);

		if (pfn)

			pfn(p_subn, &cct;;

		p_cct1->shift = p_cct2->shift = cct.shift;

		p_cct1->multiplier = p_cct2->multiplier = cct.multiplier;

	}

}

static void opts_parse_cc_cct(IN osm_subn_t *p_subn, IN char *p_key,

			      IN char *p_val_str, void *p_v1, void *p_v2,

			      void (*pfn)(osm_subn_t *, void *))

{

	osm_cct_t *p_val1 = p_v1, *p_val2 = p_v2;

	const char *current_str = p_val1->input_str ? p_val1->input_str : null_str;

	if (p_val_str && strcmp(p_val_str, current_str)) {

		osm_cct_t newcct;

		char *new;

		unsigned int len = 0;

		char *lasts;

		char *tok;

		char *ptr;

		/* special case the "(null)" string */

		new = strcmp(null_str, p_val_str) ? strdup(p_val_str) : NULL;

		if (!new) {

			log_config_value(p_key, "%s", p_val_str);

			if (pfn)

				pfn(p_subn, NULL);

			memset(p_val1->entries, '\0', sizeof(p_val1->entries));

			memset(p_val2->entries, '\0', sizeof(p_val2->entries));

			p_val1->entries_len = p_val2->entries_len = 0;

			p_val1->input_str = p_val2->input_str = NULL;

			return;

		}

		memset(&newcct, '\0', sizeof(newcct));

		tok = strtok_r(new, ",", &lasts);

		while (tok && len < OSM_CCT_ENTRY_MAX) {

			if (!(ptr = strchr(tok, ':'))) {

				log_report("invalid CCT entry\n");

				free(new);

				return;

			}

			*ptr = '\0';

			ptr++;

			newcct.entries[len].shift = strtoul(tok, NULL, 0);

			newcct.entries[len].multiplier = strtoul(ptr, NULL, 0);

			len++;

			tok = strtok_r(NULL, ",", &lasts);

		}

		free(new);

		newcct.entries_len = len;

		newcct.input_str = strdup(p_val_str);

		log_config_value(p_key, "%s", p_val_str);

		if (pfn)

			pfn(p_subn, &newcct);

		if (p_val1->input_str && p_val1->input_str != p_val2->input_str)

			free(p_val1->input_str);

		if (p_val2->input_str)

			free(p_val2->input_str);

		memcpy(p_val1->entries, newcct.entries, sizeof(newcct.entries));

		memcpy(p_val2->entries, newcct.entries, sizeof(newcct.entries));

		p_val1->entries_len = p_val2->entries_len = newcct.entries_len;

		p_val1->input_str = p_val2->input_str = newcct.input_str;

	}

}

static int parse_ca_cong_common(char *p_val_str, uint8_t *sl, unsigned int *val_offset) {

	char *new, *lasts, *sl_str, *val_str;

	uint8_t sltmp;

	new = strcmp(null_str, p_val_str) ? strdup(p_val_str) : NULL;

	if (!new)

		return -1;

	sl_str = strtok_r(new, " \t", &lasts);

	val_str = strtok_r(NULL, " \t", &lasts);

	if (!val_str) {

		log_report("value must be specified in addition to SL\n");

		free(new);

		return -1;

	}

	sltmp = strtoul(sl_str, NULL, 0);

	if (sltmp >= IB_CA_CONG_ENTRY_DATA_SIZE) {

		log_report("invalid SL specified\n");

		free(new);

		return -1;

	}

	*sl = sltmp;

	*val_offset = (unsigned int)(val_str - new);

	free(new);

	return 0;

}

static void opts_parse_ccti_timer(IN osm_subn_t *p_subn, IN char *p_key,

				  IN char *p_val_str, void *p_v1, void *p_v2,

				  void (*pfn)(osm_subn_t *, void *))

{

	osm_cacongestion_entry_t *p_val1 = p_v1, *p_val2 = p_v2;

	unsigned int val_offset = 0;

	uint8_t sl = 0;

	if (parse_ca_cong_common(p_val_str, &sl, &val_offset) < 0)

		return;

	opts_parse_net16(p_subn, p_key, p_val_str + val_offset,

			 &p_val1[sl].ccti_timer,

			 &p_val2[sl].ccti_timer,

			 pfn);

}

static void opts_parse_ccti_increase(IN osm_subn_t *p_subn, IN char *p_key,

				     IN char *p_val_str, void *p_v1, void *p_v2,

				     void (*pfn)(osm_subn_t *, void *))

{

	osm_cacongestion_entry_t *p_val1 = p_v1, *p_val2 = p_v2;

	unsigned int val_offset = 0;

	uint8_t sl = 0;

	if (parse_ca_cong_common(p_val_str, &sl, &val_offset) < 0)

		return;

	opts_parse_uint8(p_subn, p_key, p_val_str + val_offset,

			 &p_val1[sl].ccti_increase,

			 &p_val2[sl].ccti_increase,

			 pfn);

}

static void opts_parse_trigger_threshold(IN osm_subn_t *p_subn, IN char *p_key,

					 IN char *p_val_str, void *p_v1, void *p_v2,

					 void (*pfn)(osm_subn_t *, void *))

{

	osm_cacongestion_entry_t *p_val1 = p_v1, *p_val2 = p_v2;

	unsigned int val_offset = 0;

	uint8_t sl = 0;

	if (parse_ca_cong_common(p_val_str, &sl, &val_offset) < 0)

		return;

	opts_parse_uint8(p_subn, p_key, p_val_str + val_offset,

			 &p_val1[sl].trigger_threshold,

			 &p_val2[sl].trigger_threshold,

			 pfn);

}

static void opts_parse_ccti_min(IN osm_subn_t *p_subn, IN char *p_key,

				IN char *p_val_str, void *p_v1, void *p_v2,

				void (*pfn)(osm_subn_t *, void *))

{

	osm_cacongestion_entry_t *p_val1 = p_v1, *p_val2 = p_v2;

	unsigned int val_offset = 0;

	uint8_t sl = 0;

	if (parse_ca_cong_common(p_val_str, &sl, &val_offset) < 0)

		return;

	opts_parse_uint8(p_subn, p_key, p_val_str + val_offset,

			 &p_val1[sl].ccti_min,

			 &p_val2[sl].ccti_min,

			 pfn);

}

static const opt_rec_t opt_tbl[] = {

	{ "guid", OPT_OFFSET(guid), opts_parse_net64, NULL, 0 },

	{ "m_key", OPT_OFFSET(m_key), opts_parse_net64, NULL, 1 },

	{ "sm_key", OPT_OFFSET(sm_key), opts_parse_net64, NULL, 1 },

	{ "sa_key", OPT_OFFSET(sa_key), opts_parse_net64, NULL, 1 },

	{ "subnet_prefix", OPT_OFFSET(subnet_prefix), opts_parse_net64, NULL, 0 },

	{ "m_key_lease_period", OPT_OFFSET(m_key_lease_period), opts_parse_net16, NULL, 1 },

	{ "m_key_protection_level", OPT_OFFSET(m_key_protect_bits), opts_parse_uint8, NULL, 1 },

	{ "m_key_lookup", OPT_OFFSET(m_key_lookup), opts_parse_boolean, NULL, 1 },

	{ "sweep_interval", OPT_OFFSET(sweep_interval), opts_parse_uint32, NULL, 1 },

	{ "max_wire_smps", OPT_OFFSET(max_wire_smps), opts_parse_uint32, NULL, 1 },

	{ "max_wire_smps2", OPT_OFFSET(max_wire_smps2), opts_parse_uint32, NULL, 1 },

	{ "max_smps_timeout", OPT_OFFSET(max_smps_timeout), opts_parse_uint32, NULL, 1 },

	{ "console", OPT_OFFSET(console), opts_parse_charp, NULL, 0 },

	{ "console_port", OPT_OFFSET(console_port), opts_parse_uint16, NULL, 0 },

	{ "transaction_timeout", OPT_OFFSET(transaction_timeout), opts_parse_uint32, NULL, 0 },

	{ "transaction_retries", OPT_OFFSET(transaction_retries), opts_parse_uint32, NULL, 0 },

	{ "long_transaction_timeout", OPT_OFFSET(long_transaction_timeout), opts_parse_uint32, NULL, 0 },

	{ "max_msg_fifo_timeout", OPT_OFFSET(max_msg_fifo_timeout), opts_parse_uint32, NULL, 1 },

	{ "sm_priority", OPT_OFFSET(sm_priority), opts_parse_uint8, opts_setup_sm_priority, 1 },

	{ "lmc", OPT_OFFSET(lmc), opts_parse_uint8, NULL, 0 },

	{ "lmc_esp0", OPT_OFFSET(lmc_esp0), opts_parse_boolean, NULL, 0 },

	{ "max_op_vls", OPT_OFFSET(max_op_vls), opts_parse_uint8, NULL, 1 },

	{ "force_link_speed", OPT_OFFSET(force_link_speed), opts_parse_uint8, NULL, 1 },

	{ "force_link_speed_ext", OPT_OFFSET(force_link_speed_ext), opts_parse_uint8, NULL, 1 },

	{ "force_link_width", OPT_OFFSET(force_link_width), opts_parse_uint8, NULL, 1 },

	{ "fdr10", OPT_OFFSET(fdr10), opts_parse_uint8, NULL, 1 },

	{ "reassign_lids", OPT_OFFSET(reassign_lids), opts_parse_boolean, NULL, 1 },

	{ "ignore_other_sm", OPT_OFFSET(ignore_other_sm), opts_parse_boolean, NULL, 1 },

	{ "single_thread", OPT_OFFSET(single_thread), opts_parse_boolean, NULL, 0 },

	{ "disable_multicast", OPT_OFFSET(disable_multicast), opts_parse_boolean, NULL, 1 },

	{ "subnet_timeout", OPT_OFFSET(subnet_timeout), opts_parse_uint8, NULL, 1 },

	{ "packet_life_time", OPT_OFFSET(packet_life_time), opts_parse_uint8, NULL, 1 },

	{ "vl_stall_count", OPT_OFFSET(vl_stall_count), opts_parse_uint8, NULL, 1 },

	{ "leaf_vl_stall_count", OPT_OFFSET(leaf_vl_stall_count), opts_parse_uint8, NULL, 1 },

	{ "head_of_queue_lifetime", OPT_OFFSET(head_of_queue_lifetime), opts_parse_uint8, NULL, 1 },

	{ "leaf_head_of_queue_lifetime", OPT_OFFSET(leaf_head_of_queue_lifetime), opts_parse_uint8, NULL, 1 },

	{ "local_phy_errors_threshold", OPT_OFFSET(local_phy_errors_threshold), opts_parse_uint8, NULL, 1 },

	{ "overrun_errors_threshold", OPT_OFFSET(overrun_errors_threshold), opts_parse_uint8, NULL, 1 },

	{ "use_mfttop", OPT_OFFSET(use_mfttop), opts_parse_boolean, NULL, 1},

	{ "sminfo_polling_timeout", OPT_OFFSET(sminfo_polling_timeout), opts_parse_uint32, opts_setup_sminfo_polling_timeout, 1 },

	{ "polling_retry_number", OPT_OFFSET(polling_retry_number), opts_parse_uint32, NULL, 1 },

	{ "force_heavy_sweep", OPT_OFFSET(force_heavy_sweep), opts_parse_boolean, NULL, 1 },

	{ "port_prof_ignore_file", OPT_OFFSET(port_prof_ignore_file), opts_parse_charp, NULL, 0 },

	{ "hop_weights_file", OPT_OFFSET(hop_weights_file), opts_parse_charp, NULL, 0 },

	{ "dimn_ports_file", OPT_OFFSET(port_search_ordering_file), opts_parse_charp, NULL, 0 },

	{ "port_search_ordering_file", OPT_OFFSET(port_search_ordering_file), opts_parse_charp, NULL, 0 },

	{ "port_profile_switch_nodes", OPT_OFFSET(port_profile_switch_nodes), opts_parse_boolean, NULL, 1 },

	{ "sweep_on_trap", OPT_OFFSET(sweep_on_trap), opts_parse_boolean, NULL, 1 },

	{ "routing_engine", OPT_OFFSET(routing_engine_names), opts_parse_charp, NULL, 0 },

	{ "avoid_throttled_links", OPT_OFFSET(avoid_throttled_links), opts_parse_boolean, NULL, 0 },

	{ "connect_roots", OPT_OFFSET(connect_roots), opts_parse_boolean, NULL, 1 },

	{ "use_ucast_cache", OPT_OFFSET(use_ucast_cache), opts_parse_boolean, NULL, 0 },

	{ "log_file", OPT_OFFSET(log_file), opts_parse_charp, NULL, 0 },

	{ "log_max_size", OPT_OFFSET(log_max_size), opts_parse_uint32, opts_setup_log_max_size, 1 },

	{ "log_flags", OPT_OFFSET(log_flags), opts_parse_uint8, opts_setup_log_flags, 1 },

	{ "force_log_flush", OPT_OFFSET(force_log_flush), opts_parse_boolean, opts_setup_force_log_flush, 1 },

	{ "accum_log_file", OPT_OFFSET(accum_log_file), opts_parse_boolean, opts_setup_accum_log_file, 1 },

	{ "partition_config_file", OPT_OFFSET(partition_config_file), opts_parse_charp, NULL, 0 },

	{ "no_partition_enforcement", OPT_OFFSET(no_partition_enforcement), opts_parse_boolean, NULL, 1 },

	{ "part_enforce", OPT_OFFSET(part_enforce), opts_parse_charp, NULL, 1 },

	{ "allow_both_pkeys", OPT_OFFSET(allow_both_pkeys), opts_parse_boolean, NULL, 0 },

	{ "keep_pkey_indexes", OPT_OFFSET(keep_pkey_indexes), opts_parse_boolean, NULL, 1 },

	{ "sm_assigned_guid", OPT_OFFSET(sm_assigned_guid), opts_parse_uint8, NULL, 1 },

	{ "qos", OPT_OFFSET(qos), opts_parse_boolean, NULL, 1 },

	{ "qos_policy_file", OPT_OFFSET(qos_policy_file), opts_parse_charp, NULL, 0 },

	{ "suppress_sl2vl_mad_status_errors", OPT_OFFSET(suppress_sl2vl_mad_status_errors), opts_parse_boolean, NULL, 1 },

	{ "dump_files_dir", OPT_OFFSET(dump_files_dir), opts_parse_charp, NULL, 0 },

	{ "lid_matrix_dump_file", OPT_OFFSET(lid_matrix_dump_file), opts_parse_charp, NULL, 0 },

	{ "lfts_file", OPT_OFFSET(lfts_file), opts_parse_charp, NULL, 0 },

	{ "root_guid_file", OPT_OFFSET(root_guid_file), opts_parse_charp, NULL, 0 },

	{ "cn_guid_file", OPT_OFFSET(cn_guid_file), opts_parse_charp, NULL, 0 },

	{ "io_guid_file", OPT_OFFSET(io_guid_file), opts_parse_charp, NULL, 0 },

	{ "port_shifting", OPT_OFFSET(port_shifting), opts_parse_boolean, NULL, 1 },

	{ "scatter_ports", OPT_OFFSET(scatter_ports), opts_parse_uint32, NULL, 1 },

	{ "max_reverse_hops", OPT_OFFSET(max_reverse_hops), opts_parse_uint16, NULL, 0 },

	{ "ids_guid_file", OPT_OFFSET(ids_guid_file), opts_parse_charp, NULL, 0 },

	{ "guid_routing_order_file", OPT_OFFSET(guid_routing_order_file), opts_parse_charp, NULL, 0 },

	{ "guid_routing_order_no_scatter", OPT_OFFSET(guid_routing_order_no_scatter), opts_parse_boolean, NULL, 0 },

	{ "sa_db_file", OPT_OFFSET(sa_db_file), opts_parse_charp, NULL, 0 },

	{ "sa_db_dump", OPT_OFFSET(sa_db_dump), opts_parse_boolean, NULL, 1 },

	{ "torus_config", OPT_OFFSET(torus_conf_file), opts_parse_charp, NULL, 1 },

	{ "do_mesh_analysis", OPT_OFFSET(do_mesh_analysis), opts_parse_boolean, NULL, 1 },

	{ "exit_on_fatal", OPT_OFFSET(exit_on_fatal), opts_parse_boolean, NULL, 1 },

	{ "honor_guid2lid_file", OPT_OFFSET(honor_guid2lid_file), opts_parse_boolean, NULL, 1 },

	{ "daemon", OPT_OFFSET(daemon), opts_parse_boolean, NULL, 0 },

	{ "sm_inactive", OPT_OFFSET(sm_inactive), opts_parse_boolean, NULL, 1 },

	{ "babbling_port_policy", OPT_OFFSET(babbling_port_policy), opts_parse_boolean, NULL, 1 },

	{ "drop_event_subscriptions", OPT_OFFSET(drop_event_subscriptions), opts_parse_boolean, NULL, 1 },

	{ "ipoib_mcgroup_creation_validation", OPT_OFFSET(ipoib_mcgroup_creation_validation), opts_parse_boolean, NULL, 1 },

	{ "mcgroup_join_validation", OPT_OFFSET(mcgroup_join_validation), opts_parse_boolean, NULL, 1 },

	{ "use_original_extended_sa_rates_only", OPT_OFFSET(use_original_extended_sa_rates_only), opts_parse_boolean, NULL, 1 },

	{ "use_optimized_slvl", OPT_OFFSET(use_optimized_slvl), opts_parse_boolean, NULL, 1 },

	{ "fsync_high_avail_files", OPT_OFFSET(fsync_high_avail_files), opts_parse_boolean, NULL, 1 },

#ifdef ENABLE_OSM_PERF_MGR

	{ "perfmgr", OPT_OFFSET(perfmgr), opts_parse_boolean, NULL, 0 },

	{ "perfmgr_redir", OPT_OFFSET(perfmgr_redir), opts_parse_boolean, NULL, 0 },

	{ "perfmgr_sweep_time_s", OPT_OFFSET(perfmgr_sweep_time_s), opts_parse_uint16, NULL, 0 },

	{ "perfmgr_max_outstanding_queries", OPT_OFFSET(perfmgr_max_outstanding_queries), opts_parse_uint32, NULL, 0 },

	{ "perfmgr_ignore_cas", OPT_OFFSET(perfmgr_ignore_cas), opts_parse_boolean, NULL, 0 },

	{ "event_db_dump_file", OPT_OFFSET(event_db_dump_file), opts_parse_charp, NULL, 0 },

	{ "perfmgr_rm_nodes", OPT_OFFSET(perfmgr_rm_nodes), opts_parse_boolean, NULL, 0 },

	{ "perfmgr_log_errors", OPT_OFFSET(perfmgr_log_errors), opts_parse_boolean, NULL, 0 },

	{ "perfmgr_query_cpi", OPT_OFFSET(perfmgr_query_cpi), opts_parse_boolean, NULL, 0 },

	{ "perfmgr_xmit_wait_log", OPT_OFFSET(perfmgr_xmit_wait_log), opts_parse_boolean, NULL, 0 },

	{ "perfmgr_xmit_wait_threshold", OPT_OFFSET(perfmgr_xmit_wait_threshold), opts_parse_uint32, NULL, 0 },

#endif				/* ENABLE_OSM_PERF_MGR */

	{ "event_plugin_name", OPT_OFFSET(event_plugin_name), opts_parse_charp, NULL, 0 },

	{ "event_plugin_options", OPT_OFFSET(event_plugin_options), opts_parse_charp, NULL, 0 },

	{ "node_name_map_name", OPT_OFFSET(node_name_map_name), opts_parse_charp, NULL, 0 },

	{ "qos_max_vls", OPT_OFFSET(qos_options.max_vls), opts_parse_uint32, NULL, 1 },

	{ "qos_high_limit", OPT_OFFSET(qos_options.high_limit), opts_parse_int32, NULL, 1 },

	{ "qos_vlarb_high", OPT_OFFSET(qos_options.vlarb_high), opts_parse_charp, NULL, 1 },

	{ "qos_vlarb_low", OPT_OFFSET(qos_options.vlarb_low), opts_parse_charp, NULL, 1 },

	{ "qos_sl2vl", OPT_OFFSET(qos_options.sl2vl), opts_parse_charp, NULL, 1 },

	{ "qos_ca_max_vls", OPT_OFFSET(qos_ca_options.max_vls), opts_parse_uint32, NULL, 1 },

	{ "qos_ca_high_limit", OPT_OFFSET(qos_ca_options.high_limit), opts_parse_int32, NULL, 1 },

	{ "qos_ca_vlarb_high", OPT_OFFSET(qos_ca_options.vlarb_high), opts_parse_charp, NULL, 1 },

	{ "qos_ca_vlarb_low", OPT_OFFSET(qos_ca_options.vlarb_low), opts_parse_charp, NULL, 1 },