/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <libdevice.h>
#include <libdevinfo.h>
#define	_KERNEL
#include <sys/dditypes.h>
#include <sys/devctl.h>
#include <sys/bofi.h>

static int online_device(char *path);
static int offline_device(char *path);
static int getstate_device(char *path);
static int getnameinst(char *path, int *instance, char *name, int namelen);
static int getpath(char *path, int instance, char *name, int pathlen);

static char buffer[50*1024];

#define	CMD_TABLE_SIZE 11
#define	BOFI_ONLINE 0
#define	BOFI_OFFLINE 1
#define	BOFI_GETSTATE 2
#define	BOFI_GETPATH 3

static struct {
	char *string;
	int val;
	int devctl_val;
} cmd_table[] = {
	{"online", -1, BOFI_ONLINE},
	{"offline", -1, BOFI_OFFLINE},
	{"getstate", -1, BOFI_GETSTATE},
	{"getpath", -1, BOFI_GETPATH},
	{"broadcast", BOFI_BROADCAST, -1},
	{"clear_acc_chk", BOFI_CLEAR_ACC_CHK, -1},
	{"clear_errors", BOFI_CLEAR_ERRORS, -1},
	{"clear_errdefs", BOFI_CLEAR_ERRDEFS, -1},
	{"start", BOFI_START, -1},
	{"stop", BOFI_STOP, -1},
	{"get_handles", BOFI_GET_HANDLES, -1}
};

int
main(int argc, char **argv)
{
	struct bofi_errctl errctl;
	struct bofi_get_handles get_handles;
	int command = -1;
	int devctl_command = -1;
	int i;
	int fd;

	char buf[MAXPATHLEN];
	char path[MAXPATHLEN];

	if (argc == 3) {
		(void) strncpy(path, argv[1], MAXPATHLEN);

		for (i = 0; i < CMD_TABLE_SIZE; i++) {
			if (strcmp(argv[2], cmd_table[i].string) == 0) {
				command = cmd_table[i].val;
				devctl_command = cmd_table[i].devctl_val;
			}
		}
		switch (devctl_command) {
		case BOFI_ONLINE:
		case BOFI_OFFLINE:
		case BOFI_GETPATH:
		case BOFI_GETSTATE:
			break;
		default:
			if (getnameinst(argv[1], &errctl.instance, buf,
			    MAXPATHLEN) == -1) {
				(void) fprintf(stderr,
				    "th_manage - invalid path\n");
				exit(1);
			}
			(void) strncpy(errctl.name, buf, MAXNAMELEN);
			errctl.namesize = strlen(errctl.name);
		}
	} else if (argc == 4) {
		errctl.namesize = strlen(argv[1]);
		(void) strncpy(errctl.name, argv[1], MAXNAMELEN);
		errctl.instance = atoi(argv[2]);
		for (i = 0; i < CMD_TABLE_SIZE; i++) {
			if (strcmp(argv[3], cmd_table[i].string) == 0) {
				command = cmd_table[i].val;
				devctl_command = cmd_table[i].devctl_val;
			}
		}
		switch (devctl_command) {
		case BOFI_ONLINE:
		case BOFI_OFFLINE:
		case BOFI_GETPATH:
		case BOFI_GETSTATE:
			(void) strcpy(path, "/devices/");
			if (getpath(&path[8], errctl.instance, errctl.name,
			    MAXPATHLEN) == -1) {
				(void) fprintf(stderr,
				    "th_manage - invalid name/instance\n");
				exit(1);
			}
		default:
			break;
		}
	} else {
		(void) fprintf(stderr, "usage:\n");
		(void) fprintf(stderr,
		    "    th_manage name instance state\n");
		(void) fprintf(stderr,
		    "    th_manage path state\n");
		exit(2);
	}

	if (command == -1) {
		/*
		 * might have been a devctl command
		 */
		if (devctl_command == BOFI_ONLINE) {
			while (online_device(path) != 0) {
				(void) sleep(3);
			}
			exit(0);
		}
		if (devctl_command == BOFI_OFFLINE) {
			while (offline_device(path) != 0) {
				(void) sleep(3);
			}
			exit(0);
		}
		if (devctl_command == BOFI_GETSTATE) {
			if (getstate_device(path) != 0) {
				perror("th_manage - getstate failed");
				exit(1);
			} else {
				exit(0);
			}
		}
		if (devctl_command == BOFI_GETPATH) {
			(void) fprintf(stdout, "%s\n", path);
			exit(0);
		}
		(void) fprintf(stderr,
		    "th_manage: invalid command\n");
		(void) fprintf(stderr,
		    "     Command must be one of start, stop, broadcast, "
		    "get_handles,\n");
		(void) fprintf(stderr,
		    "     clear_acc_chk, clear_errors or clear_errdefs\n");
		exit(2);
	}
	fd = open("/devices/pseudo/bofi@0:bofi,ctl", O_RDWR);
	if (fd == -1) {
		perror("th_manage - open of bofi driver");
		exit(2);
	}
	if (command == BOFI_GET_HANDLES) {
		get_handles.namesize = errctl.namesize;
		(void) strncpy(get_handles.name, errctl.name, MAXNAMELEN);
		get_handles.instance =  errctl.instance;
		get_handles.buffer = buffer;
		get_handles.count = sizeof (buffer) - 1;
		if (ioctl(fd, command, &get_handles) == -1) {
			perror("th_manage - setting state failed");
			exit(2);
		}
		buffer[sizeof (buffer) - 1] = '\0';
		(void) fprintf(stdout, "%s", buffer);
		(void) fflush(stdout);
		exit(0);
	}
	if (errctl.instance == -1) {
		struct bofi_get_hdl_info hdli;
		struct handle_info *hip, *hp;
		int i, j, *instp;

		hdli.namesize = errctl.namesize;
		(void) strncpy(hdli.name, errctl.name, MAXNAMELEN);
		hdli.hdli = 0;
		hdli.count = 0;
		/*
		 * Ask the bofi driver for all handles created by the driver
		 * under test.
		 */
		if (ioctl(fd, BOFI_GET_HANDLE_INFO, &hdli) == -1) {
			perror("driver failed to return access handles");
			exit(1);
		}
		if (hdli.count == 0) {
			exit(0); /* no handles */
		}
		if ((hip = memalign(sizeof (void *),
		    hdli.count * sizeof (*hip))) == 0) {
			perror("out of memory");
			exit(1);
		}
		hdli.hdli = (caddr_t)hip;
		if (ioctl(fd, BOFI_GET_HANDLE_INFO, &hdli) == -1) {
			perror("couldn't obtain all handles");
			exit(1);
		}
		if ((instp = malloc((hdli.count + 1) * sizeof (*instp))) == 0) {
			perror("out of memory");
			exit(1);
		}
		*instp = -1;
		for (i = 0, hp = hip; i < hdli.count; hp++, i++) {
			for (j = 0; instp[j] != -1; j++)
				if (hp->instance == instp[j])
					break;
			if (instp[j] == -1) {
				instp[j] = hp->instance;
				instp[j+1] = -1;
			}
		}
		for (i = 0; instp[i] != -1; i++) {
			errctl.instance = instp[i];
			if (ioctl(fd, command, &errctl) == -1) {
				(void) fprintf(stderr,
				    "command failed on instance %d : %s\n",
				    errctl.instance, strerror(errno));
				exit(1);
			}
		}
	} else {
		if (ioctl(fd, command, &errctl) == -1) {
			perror("th_manage - setting state failed");
			exit(1);
		}
	}
	return (0);
}


/*
 * These functions provide access to the devctl functions,
 */
static int
online_device(char *path)
{
	devctl_hdl_t	dcp;

	if ((dcp = devctl_device_acquire(path, 0)) == NULL) {
		return (-1);
	}
	if ((devctl_device_online(dcp)) == -1) {
		devctl_release(dcp);
		return (-1);
	}
	devctl_release(dcp);
	return (0);
}


static int
offline_device(char *path)
{
	devctl_hdl_t	dcp;

	if ((dcp = devctl_device_acquire(path, 0)) == NULL) {
		return (-1);
	}
	if ((devctl_device_offline(dcp)) == -1) {
		devctl_release(dcp);
		return (-1);
	}
	devctl_release(dcp);
	return (0);
}

static int
getstate_device(char *path)
{
	devctl_hdl_t	dcp;
	uint_t		state = 0;

	if ((dcp = devctl_device_acquire(path, 0)) == NULL) {
		(void) printf("%s unknown unknown\n", path);
		return (-1);
	}
	if ((devctl_device_getstate(dcp, &state)) == -1) {
		(void) printf("%s unknown unknown\n", path);
		devctl_release(dcp);
		return (-1);
	}
	devctl_release(dcp);
	switch (state) {
	case DEVICE_DOWN:
		(void) printf("%s down not_busy\n", path);
		break;
	case DEVICE_OFFLINE:
		(void) printf("%s offline not_busy\n", path);
		break;
	case DEVICE_ONLINE:
		(void) printf("%s online not_busy\n", path);
		break;
	case (DEVICE_ONLINE | DEVICE_BUSY):
		(void) printf("%s online busy\n", path);
		break;
	case (DEVICE_DOWN | DEVICE_BUSY):
		(void) printf("%s down busy\n", path);
		break;
	default:
		(void) printf("%s unknown unknown\n", path);
		break;
	}
	return (0);
}

static int
getnameinst(char *path, int *instance, char *name, int namelen)
{
	di_node_t node;
	char *driver_name;

	if ((node = di_init(&path[8], DINFOSUBTREE)) == DI_NODE_NIL)
		return (-1);
	if ((driver_name = di_driver_name(node)) == NULL) {
		di_fini(node);
		return (-1);
	}
	*instance = di_instance(node);
	(void) strncpy(name, driver_name, namelen);
	di_fini(node);
	return (0);
}

struct walk_arg {
	char *path;
	int instance;
	char name[MAXPATHLEN];
	int found;
	int pathlen;
};

static int
walk_callback(di_node_t node, void *arg)
{
	struct walk_arg *warg = (struct walk_arg *)arg;
	char *driver_name;
	char *path;

	driver_name = di_driver_name(node);
	if (driver_name != NULL) {
		if (strcmp(driver_name, warg->name) == 0 &&
		    di_instance(node) == warg->instance) {
			path = di_devfs_path(node);
			if (path != NULL) {
				warg->found = 1;
				(void) strncpy(warg->path, path, warg->pathlen);
			}
			return (DI_WALK_TERMINATE);
		}
	}
	return (DI_WALK_CONTINUE);
}

static int
getpath(char *path, int instance, char *name, int pathlen)
{
	di_node_t node;
	struct walk_arg warg;

	warg.instance = instance;
	(void) strncpy(warg.name, name, MAXPATHLEN);
	warg.path = path;
	warg.pathlen = pathlen;
	warg.found = 0;
	if ((node = di_init("/", DINFOSUBTREE)) == DI_NODE_NIL)
		return (-1);
	if (di_walk_node(node, DI_WALK_CLDFIRST, &warg, walk_callback) == -1) {
		di_fini(node);
		return (-1);
	}
	if (warg.found == 0) {
		di_fini(node);
		return (-1);
	}
	di_fini(node);
	return (0);
}