path: root/usr/src/lib/libsrpt/common/libsrpt.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>
#include <ctype.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <strings.h>
#include <libintl.h>
#include <libscf.h>
#include <libnvpair.h>

#include <libstmf.h>
#include <libsrpt.h>

#include "srpt_common.h"

#define	SRPT_PROV_NAME	"srpt"

/*
 * Function:  srpt_GetConfig()
 *
 * Parameters:
 *    cfg	Current SRPT configuration in nvlist form
 *    token	Configuration generation number.  Use this token
 *		if updating the configuration with srpt_SetConfig.
 *
 * Return Values:
 *    0		Success
 *    ENOMEM	Could not allocate resources
 *    EINVAL	Invalid parameter
 */
int
srpt_GetConfig(nvlist_t **cfg, uint64_t *token)
{
	int		ret = 0;
	nvlist_t	*cfg_nv = NULL;
	uint64_t	stmf_token = 0;
	nvlist_t	*hcanv = NULL;

	if (!cfg) {
		return (EINVAL);
	}

	*cfg = NULL;

	ret = stmfGetProviderDataProt(SRPT_PROV_NAME, &cfg_nv,
	    STMF_PORT_PROVIDER_TYPE, &stmf_token);

	if (ret == STMF_STATUS_SUCCESS) {
		ret = 0;
	} else if (ret == STMF_ERROR_NOT_FOUND) {
		/* Not initialized yet */
		ret = nvlist_alloc(&cfg_nv, NV_UNIQUE_NAME, 0);
		if (ret != 0) {
			return (ret);
		}
		/* create the HCA list */
		ret = nvlist_alloc(&hcanv, NV_UNIQUE_NAME, 0);
		if (ret == 0) {
			ret = nvlist_add_nvlist(cfg_nv, SRPT_PROP_HCALIST,
			    hcanv);
			if (ret != 0) {
				nvlist_free(hcanv);
			}
		}
		if (ret != 0) {
			nvlist_free(cfg_nv);
			cfg_nv = NULL;
		}
	} else if (ret == STMF_ERROR_NOMEM) {
		ret = ENOMEM;
	} else {
		ret = EINVAL;
	}

	*cfg = cfg_nv;
	*token = stmf_token;

	return (ret);
}

/*
 * Function:  srpt_SetConfig()
 *
 * Parameters:
 *    cfg	SRPT configuration in nvlist form
 *    token	Configuration generation number from srpt_GetConfig.
 *		Use this token to ensure the configuration hasn't been
 *		updated by another user since the time it was fetched.
 *
 * Return Values:
 *    0		Success
 *    ENOMEM	Could not allocate resources
 *    EINVAL	Invalid parameter
 *    ECANCELED Configuration updated by another user
 */
int
srpt_SetConfig(nvlist_t *cfg, uint64_t token)
{
	int		ret = 0;

	ret = stmfSetProviderDataProt(SRPT_PROV_NAME, cfg,
	    STMF_PORT_PROVIDER_TYPE, &token);

	if (ret == STMF_STATUS_SUCCESS) {
		ret = 0;
	} else if (ret == STMF_ERROR_NOMEM) {
		ret = ENOMEM;
	} else if (ret == STMF_ERROR_PROV_DATA_STALE) {
		ret = ECANCELED;  /* could be a better errno */
	} else {
		ret = EINVAL;
	}

	return (ret);
}

/*
 * Function:  srpt_GetDefaultState()
 *
 * Parameters:
 *    enabled	If B_TRUE, indicates that targets will be created for all
 *		discovered HCAs that have not been specifically disabled.
 *		If B_FALSE, targets will not be created unless the HCA has
 *		been specifically enabled.  See also srpt_SetDefaultState().
 *
 * Return Values:
 *    0		Success
 *    ENOMEM	Could not allocate resources
 *    EINVAL	Invalid parameter
 */
int
srpt_GetDefaultState(boolean_t *enabled)
{
	int		ret;
	nvlist_t	*cfgnv;
	uint64_t	token;
	boolean_t	val = B_TRUE;

	if (enabled == NULL) {
		return (EINVAL);
	}

	ret = srpt_GetConfig(&cfgnv, &token);
	if (ret != 0) {
		return (ret);
	}

	if (cfgnv != NULL) {
		ret = nvlist_lookup_boolean_value(cfgnv,
		    SRPT_PROP_DEFAULT_ENABLED, &val);

		if (ret == ENOENT) {
			ret = 0;
		}
	}

	*enabled = val;
	return (ret);
}

/*
 * Function:  srpt_SetDefaultState()
 *
 * Parameters:
 *    enabled	If B_TRUE, indicates that targets will be created for all
 *		discovered HCAs that have not been specifically disabled.
 *		If B_FALSE, targets will not be created unless the HCA has
 *		been specifically enabled.  See also srpt_SetDefaultState().
 *
 * Return Values:
 *    0		Success
 *    ENOMEM	Could not allocate resources
 *    EINVAL	Invalid parameter
 */
int
srpt_SetDefaultState(boolean_t enabled)
{
	int		ret;
	nvlist_t	*cfgnv;
	uint64_t	token;

	ret = srpt_GetConfig(&cfgnv, &token);
	if (ret != 0) {
		return (ret);
	}

	if (cfgnv == NULL) {
		ret = nvlist_alloc(&cfgnv, NV_UNIQUE_NAME, 0);
		if (ret != 0) {
			return (ret);
		}
	}

	ret = nvlist_add_boolean_value(cfgnv, SRPT_PROP_DEFAULT_ENABLED,
	    enabled);

	if (ret == 0) {
		ret = srpt_SetConfig(cfgnv, token);
	}

	nvlist_free(cfgnv);

	return (ret);
}

/*
 * Function:  srpt_SetTargetState()
 *
 * Parameters:
 *    hca_guid	HCA GUID.  See description of srpt_NormalizeGuid
 *    enabled	If B_TRUE, indicates that a target will be created for
 *		this HCA when the SRPT SMF service is enabled.  If B_FALSE,
 *		a target will not be created
 *
 * Return Values:
 *    0		Success
 *    ENOMEM	Could not allocate resources
 *    EINVAL	Invalid parameter
 */
int
srpt_SetTargetState(char *hca_guid, boolean_t enabled)
{
	int		ret;
	nvlist_t	*cfgnv;
	uint64_t	token;
	nvlist_t	*hcalist;
	nvlist_t	*hcanv;
	char		guid[32];
	uint64_t	hcaguid;

	if (hca_guid == NULL) {
		return (EINVAL);
	}

	ret = srpt_NormalizeGuid(hca_guid, guid, sizeof (guid), &hcaguid);
	if (ret != 0) {
		return (ret);
	}

	ret = srpt_GetConfig(&cfgnv, &token);
	if (ret != 0) {
		return (ret);
	}

	/* get the list of HCAs */
	ret = nvlist_lookup_nvlist(cfgnv, SRPT_PROP_HCALIST, &hcalist);
	if (ret != 0) {
		nvlist_free(cfgnv);
		return (ret);
	}

	ret = nvlist_lookup_nvlist(hcalist, guid, &hcanv);
	if (ret == ENOENT) {
		/* no entry yet */
		ret = nvlist_alloc(&hcanv, NV_UNIQUE_NAME, 0);
		if (ret == 0) {
			ret = nvlist_add_uint64(hcanv, SRPT_PROP_GUID, hcaguid);
		}
	}

	if (ret == 0) {
		ret = nvlist_add_boolean_value(hcanv, SRPT_PROP_ENABLED,
		    enabled);
	}

	if (ret == 0) {
		ret = nvlist_add_nvlist(hcalist, guid, hcanv);
	}

	if (ret == 0) {
		ret = srpt_SetConfig(cfgnv, token);
	}

	nvlist_free(cfgnv);

	return (ret);
}

/*
 * Function:  srpt_GetTargetState()
 *
 * Parameters:
 *    hca_guid	HCA GUID.  See description of srpt_NormalizeGuid
 *    enabled	If B_TRUE, indicates that a target will be created for
 *		this HCA when the SRPT SMF service is enabled.  If B_FALSE,
 *		a target will not be created
 *
 * Return Values:
 *    0		Success
 *    ENOMEM	Could not allocate resources
 *    EINVAL	Invalid parameter
 */
int
srpt_GetTargetState(char *hca_guid, boolean_t *enabled)
{
	int		ret;
	nvlist_t	*cfgnv;
	uint64_t	token;
	nvlist_t	*hcalist;
	nvlist_t	*hcanv;
	boolean_t	defaultState = B_TRUE;
	char		guid[32];

	if (hca_guid == NULL) {
		return (EINVAL);
	}

	ret = srpt_NormalizeGuid(hca_guid, guid, sizeof (guid), NULL);
	if (ret != 0) {
		return (ret);
	}

	ret = srpt_GetConfig(&cfgnv, &token);
	if (ret != 0) {
		return (ret);
	}

	/* get the list of HCAs */
	ret = nvlist_lookup_nvlist(cfgnv, SRPT_PROP_HCALIST, &hcalist);
	if (ret != 0) {
		nvlist_free(cfgnv);
		return (ret);
	}

	/*
	 * Find the default, for the likely case that this HCA isn't
	 * explicitly set.
	 */
	(void) nvlist_lookup_boolean_value(cfgnv, SRPT_PROP_DEFAULT_ENABLED,
	    &defaultState);

	ret = nvlist_lookup_nvlist(hcalist, guid, &hcanv);
	if (ret == 0) {
		ret = nvlist_lookup_boolean_value(hcanv, SRPT_PROP_ENABLED,
		    enabled);
	}

	if (ret == ENOENT) {
		/* not explicitly set, use the default */
		*enabled = defaultState;
		ret = 0;
	}

	nvlist_free(cfgnv);

	return (ret);

}

/*
 * Function:  srpt_ResetTarget()
 *
 * Clears the HCA-specific configuration.  Target creation will revert to
 * the default.
 *
 * Parameters:
 *    hca_guid	HCA GUID.  See description of srpt_NormalizeGuid
 *
 * Return Values:
 *    0		Success
 *    ENOMEM	Could not allocate resources
 *    EINVAL	Invalid parameter
 */
int
srpt_ResetTarget(char *hca_guid)
{
	int		ret;
	nvlist_t	*cfgnv;
	nvlist_t	*hcalist;
	uint64_t	token;
	char		guid[32];

	if (hca_guid == NULL) {
		return (EINVAL);
	}

	ret = srpt_NormalizeGuid(hca_guid, guid, sizeof (guid), NULL);
	if (ret != 0) {
		return (ret);
	}

	ret = srpt_GetConfig(&cfgnv, &token);
	if (ret != 0) {
		return (ret);
	}

	/* get the list of HCAs */
	ret = nvlist_lookup_nvlist(cfgnv, SRPT_PROP_HCALIST, &hcalist);
	if (ret != 0) {
		nvlist_free(cfgnv);
		return (ret);
	}

	/* don't set config if we don't actually change anything */
	if (nvlist_exists(hcalist, guid)) {
		(void) nvlist_remove_all(hcalist, guid);

		if (ret == 0) {
			ret = srpt_SetConfig(cfgnv, token);
		}
	}

	nvlist_free(cfgnv);

	return (ret);
}

/*
 * srpt_NormalizeGuid()
 *
 * Parameters:
 *    in	HCA GUID.  Must be in one of the following forms:
 *		    3BA000100CD18	- base hex form
 *		    0003BA000100CD18	- base hex form with leading zeroes
 *		    hca:3BA000100CD18	- form from cfgadm and/or /dev/cfg
 *		    eui.0003BA000100CD18 - EUI form
 *
 *    buf	Buffer to hold normalized guid string.  Must be at least
 *		17 chars long.
 *    buflen	Length of provided buffer
 *    int_guid	Optional.  If not NULL, the integer form of the GUID will also
 *		be returned.
 * Return Values:
 *    0		Success
 *    EINVAL	Invalid HCA GUID or invalid parameter.
 */
int
srpt_NormalizeGuid(char *in, char *buf, size_t buflen, uint64_t *int_guid)
{
	uint64_t	guid;
	char		*bufp = in;
	char		*end = NULL;

	if ((in == NULL) || (buf == NULL)) {
		return (EINVAL);
	}

	if (strncasecmp(bufp, "eui.", 4) == 0) {
		/* EUI form */
		bufp += 4;
	} else if (strncasecmp(bufp, "hca:", 4) == 0) {
		/* cfgadm and /dev/hca form */
		bufp += 4;
	}

	/*
	 * strtoull() does not return EINVAL as documented.  Lucky
	 * for us, neither 0 nor ULLONG_MAX will be valid.  Trap on
	 * those and fail.
	 */
	guid = strtoull(bufp, &end, 16);
	if ((guid == 0) || (guid == ULLONG_MAX) ||
	    ((end != NULL) && (strlen(end) > 0))) {
		return (EINVAL);
	}

#if 0
	(void) snprintf(buf, buflen, "%llX", guid);
#endif
	SRPT_FORMAT_HCAKEY(buf, buflen, guid);

	if (int_guid) {
		*int_guid = guid;
	}

	return (0);
}