/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/sunddi.h>
#include <sys/note.h>
#include <sys/promif.h>
#include <sys/sbdp_error.h>
#include <sys/sbdp_priv.h>

/*
 * The purpose if this model is to make it easy to inject error at all
 * decision making points, such that all code paths can be tested, and
 * states arrived are expected and recoverable.
 *
 * Passthru command "inject-error" will be used for injecting
 * errors.  A typical error injection command will look like the
 * following:
 *
 * cfgadm -x passthru -o inject-error=func_name:entry_point:value N0.SB0
 *
 * where "func_name" is the name of the function where error will be
 * injected, "entry_point" is a number in the function to identify which
 * decision making point it is that we are injecting error, and "value"
 * is what we want the check to return.  The last field is ignored,
 * so it can be any valid attachment point.
 *
 * For example, if we want to inject error at the 3rd entry in function
 * sbdp_disconnect_cpu (we start counting at 0), we will issue the
 * following command:
 *
 * cfgadm -x passthru -o inject-error=sbdp_disconnect_cpu:3:-1 N0.SB0
 *
 * To clear the error, change the value to 0, or whatever success
 * corresponds to in the particular function.
 *
 * cfgadm -x passthru -o inject-error=sbdp_disconnect_cpu:3:0 N0.SB0
 *
 * Since this command is mainly for debugging, not all illegal options
 * are rejected.  Non-digit strings are accepted for entry point and
 * value.  They will be translated to 0.
 *
 * Another passthru command "reset-error" is used to clear all errors
 * that have been injected.  The only argument it needs is a valid
 * attachment point as the last field.
 *
 * NOTE: Once implemented, the error injection points should remain
 * relatively stable as QA will be using them for testing.
 */


/*
 * Variable that controls if error injection should be done or not
 */
#ifdef DEBUG
uint_t sbdp_do_inject = 1;

/*
 * Different error injection types that sbdp_ie_type can be
 */
#define	SBDP_IE_RANDOM	0	/* Returns randomly 0 or -1 */
#define	SBDP_IE_FAILURE	1	/* Returns -1 */
#define	SBDP_IE_DEFINED	2	/* Returns value from sbdp_error_matrix */

/*
 * Variable that controls what type of error injection to do
 */
int sbdp_ie_type = SBDP_IE_DEFINED;

/*
 * Basic return values from sbdp_inject_error
 */
#define	SUCCESS	0
#define	FAILURE	-1

/*
 * Maximum number of error injection entry points
 */
#define	SBDP_IE_MAX_ENTRIES		4

typedef struct error_matrix {
	const char	*func_name;
	uint_t		num_entries;
	int		entries[SBDP_IE_MAX_ENTRIES];
} error_matrix_t;

static error_matrix_t sbdp_error_matrix[] =  {
	{ "sbdp_disconnect_cpu",	3,	0, 0, 0, 0 },
	{ "sbdp_connect_cpu",		3,	0, 0, 0, 0 },
	{ "sbdp_cpu_poweron",		2,	0, 0, 0, 0 },
	{ "sbdp_cpu_poweroff",		4,	0, 0, 0, 0 },
	/* Termination entry, must exist */
	{ NULL,				0,	0, 0, 0, 0 },
};

static int sbdp_func_lookup(const char *func_name);

extern int sbdp_strtoi(char *p, char **pos);

/*
 * sbdp error injector.  The argument should be of the following format:
 *
 *	inject_error=func_str:entry_str:value_str
 *
 * Returns ESBD_INVAL if arg is not of the above format,
 * or if any of the fields are invalid.
 *
 * Returns ESBD_NOERROR after setting the correct entry in the error
 * matrix to the value passed in.
 */
int
sbdp_passthru_inject_error(sbdp_handle_t *hp, void *arg)
{
	_NOTE(ARGUNUSED(hp))

	char	*arg_str, *func_str, *entry_str, *value_str;
	int	index, value;
	size_t	len = strlen(arg) + 1;
	uint_t	entry;
	int	rv = ESBD_NOERROR;
	static char *f = "sbdp_passthru_inject_error";

	arg_str = kmem_alloc(len, KM_SLEEP);
	(void) strcpy(arg_str, arg);

	/*
	 * Find '=' in the argument.  Return ESBD_INVAL if '=' is
	 * not found.
	 */
	if ((func_str = strchr(arg_str, '=')) == NULL) {
		rv = ESBD_INVAL;
		goto out;
	}

	/*
	 * Now func_str points to '=' in arg_str.  Increment the pointer
	 * so it points to the begining of the function string.
	 * Find the first ':' in the argument.  Return ESBD_INVAL if
	 * not found.
	 */
	if ((entry_str = strchr(++func_str, ':')) == NULL) {
		rv = ESBD_INVAL;
		goto out;
	}

	/*
	 * Now entry_str points to the first ':' in arg_str.  Set it
	 * to '\0' to NULL terminate func_str.  Increment the
	 * pointer so it points to the begining of the entry string.
	 */
	*entry_str++ = '\0';

	/*
	 * Now entry_str points to the begining of the entry string.
	 * Find the next ':' in the argument.  Return ESBD_INVAL if
	 * ':' is not found.
	 */
	if ((value_str = strchr(entry_str, ':')) == NULL) {
		rv = ESBD_INVAL;
		goto out;
	}

	/*
	 * Now value_str points to the second ':' in arg_str.  Set it
	 * to '\0' to NULL terminate entry_str.  Increment the
	 * pointer so it points to the begining of the value string.
	 * The rest of the arg_str is taken as the value string.
	 */
	*value_str++ = '\0';

	/*
	 * Find this function in the matrix.  Return ESBD_INVAL if
	 * the function name is not found.
	 */
	if ((index = sbdp_func_lookup(func_str)) == -1) {
		rv = ESBD_INVAL;
		goto out;
	}

	/*
	 * To reduce the amount of code we have to write, we tolerate
	 * non-number input for entry point, and translate it to 0.
	 */
	entry = (uint_t)sbdp_strtoi(entry_str, NULL);

	if (entry >= sbdp_error_matrix[index].num_entries) {
		rv = ESBD_INVAL;
		goto out;
	}

	/*
	 * No checking for value.  Non-number string will be translated
	 * to 0.
	 */
	value = sbdp_strtoi(value_str, NULL);

	SBDP_DBG_ERR("%s: index = %d, entry = %d, value = %d\n",
	    f, index, entry, value);

	/*
	 * Set value at the right entry.
	 */
	sbdp_error_matrix[index].entries[entry] = value;

out:
	kmem_free(arg_str, len);
	return (rv);
}

/*
 * Reset all entries to 0.
 */
int
sbdp_passthru_reset_error(sbdp_handle_t *hp, void *arg)
{
	_NOTE(ARGUNUSED(hp))
	_NOTE(ARGUNUSED(arg))

	uint_t	i, j;

	for (i = 0; sbdp_error_matrix[i].func_name != NULL; i++)
		for (j = 0; j < SBDP_IE_MAX_ENTRIES; j++)
			sbdp_error_matrix[i].entries[j] = 0;

	return (ESBD_NOERROR);
}

int
sbdp_inject_error(const char *func_name, uint_t entry)
{
	extern clock_t ddi_get_lbolt(void);
	int	index;
	int	value;
	static char *f = "sbdp_inject_error";

	if (sbdp_do_inject == 0)
		return (SUCCESS);

	switch (sbdp_ie_type) {

	case SBDP_IE_RANDOM:
		/*
		 * Since we usually only need a binary type of return
		 * value, use lbolt to generate the psuedo random
		 * response.
		 */
		value = (-(int)(ddi_get_lbolt() % 2));
		break;

	case SBDP_IE_FAILURE:
		value = FAILURE;
		break;

	case SBDP_IE_DEFINED:
		/*
		 * Don't inject error if can't find the function.
		 */
		if ((index = sbdp_func_lookup(func_name)) == -1) {
			value = SUCCESS;
			break;
		}

		/*
		 * Don't inject error if can't find the entry.
		 */
		if (entry >= sbdp_error_matrix[index].num_entries) {
			value = SUCCESS;
			break;
		}

		value = sbdp_error_matrix[index].entries[entry];
		break;

	default:
		value = SUCCESS;
		break;
	}

	if (value != SUCCESS)
		SBDP_DBG_ERR("%s: function=%s entry=%d value=%d\n",
		    f, func_name, entry, value);

	return (value);
}

static int
sbdp_func_lookup(const char *func_name)
{
	int		i;
	const char	*name;

	/*
	 * Linear search for a match
	 */
	for (i = 0; (name = sbdp_error_matrix[i].func_name) != NULL; i++) {
		if (strcmp(name, func_name) == 0)
			return (i);
	}

	/*
	 * Function name not found in matrix
	 */
	return (-1);
}

#endif /* DEBUG */