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

/*
 * Configuration and setup interface to vcc driver.
 * At intialization time, vntsd opens vcc ctrl port and read initial
 * configuratioa. It manages console groups, creates the listen thread,
 * dynamically adds and removes virtual console within a group.
 */


#include <syslog.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <wait.h>
#include <time.h>
#include <synch.h>
#include <netinet/in.h>
#include <thread.h>
#include <signal.h>
#include "vntsd.h"

/* signal all clients that console has been deleted */
boolean_t
vntsd_notify_client_cons_del(vntsd_client_t *clientp)
{
	(void) mutex_lock(&clientp->lock);
	clientp->status |= VNTSD_CLIENT_CONS_DELETED;
	(void) thr_kill(clientp->cons_tid, SIGUSR1);
	(void) mutex_unlock(&clientp->lock);
	return (B_FALSE);
}

/* free console  structure */
static void
free_cons(vntsd_cons_t *consp)
{
	assert(consp);
	(void) mutex_destroy(&consp->lock);
	(void) cond_destroy(&consp->cvp);
	if (consp->vcc_fd != -1)
		(void) close(consp->vcc_fd);
	free(consp);
}

/* free group structure */
static void
free_group(vntsd_group_t *groupp)
{
	assert(groupp);
	(void) mutex_destroy(&groupp->lock);
	(void) cond_destroy(&groupp->cvp);
	if (groupp->sockfd != -1)
		(void) close(groupp->sockfd);
	free(groupp);
}

/*
 *  all clients connected to a console must disconnect before
 *  removing a console.
 */
static void
cleanup_cons(vntsd_cons_t *consp)
{
	vntsd_group_t	*groupp;
	timestruc_t	to;

	assert(consp);
	D1(stderr, "t@%d vntsd_disconn_clients@%d\n", thr_self(),
	    consp->cons_no);

	groupp = consp->group;
	assert(groupp);


	(void) mutex_lock(&consp->lock);

	/* wait for all clients disconnect from the console */
	while (consp->clientpq != NULL) {
		consp->status |= VNTSD_CONS_SIG_WAIT;

		/* signal client to disconnect the console */
		(void) vntsd_que_walk(consp->clientpq,
		    (el_func_t)vntsd_notify_client_cons_del);

		(void) thr_kill(consp->wr_tid, SIGUSR1);
		to.tv_sec = VNTSD_CV_WAIT_DELTIME;
		to.tv_nsec = 0;

		/* wait for clients to disconnect  */
		(void) cond_reltimedwait(&consp->cvp, &consp->lock, &to);
	}

	/* reduce console count in the group */
	(void) mutex_lock(&groupp->lock);
	assert(groupp->num_cons > 0);
	groupp->num_cons--;
	(void) mutex_unlock(&groupp->lock);

	(void) mutex_unlock(&consp->lock);

	free_cons(consp);
}

/* search for a group whose console is being deleted */
static boolean_t
find_clean_cons_group(vntsd_group_t *groupp)
{
	if (groupp->status & VNTSD_GROUP_CLEAN_CONS) {
		return (B_TRUE);
	} else {
		return (B_FALSE);
	}
}

/* search for a console that is being deleted */
static boolean_t
find_clean_cons(vntsd_cons_t *consp)
{
	if (consp->status & VNTSD_CONS_DELETED) {
		return (B_TRUE);
	} else {
		return (B_FALSE);
	}
}

/* delete a console */
void
vntsd_delete_cons(vntsd_t *vntsdp)
{
	vntsd_group_t *groupp;
	vntsd_cons_t *consp;

	for (; ; ) {
		/* get the group contains deleted console */
		(void) mutex_lock(&vntsdp->lock);
		groupp = vntsd_que_walk(vntsdp->grouppq,
		    (el_func_t)find_clean_cons_group);
		if (groupp == NULL) {
			/* no more group has console deleted */
			(void) mutex_unlock(&vntsdp->lock);
			return;
		}
		(void) mutex_lock(&groupp->lock);
		groupp->status &= ~VNTSD_GROUP_CLEAN_CONS;
		(void) mutex_unlock(&groupp->lock);
		(void) mutex_unlock(&vntsdp->lock);

		for (; ; ) {
			/* get the console to be deleted */
			(void) mutex_lock(&groupp->lock);

			/* clean up any deleted console in the group */
			if (groupp->conspq != NULL) {
				consp = vntsd_que_walk(groupp->conspq,
				    (el_func_t)find_clean_cons);
				if (consp == NULL) {
					/* no more cons to delete */
					(void) mutex_unlock(&groupp->lock);
					break;
				}

				/* remove console from the group */
				(void) vntsd_que_rm(&groupp->conspq, consp);
				(void) mutex_unlock(&groupp->lock);

				/* clean up the console */
				cleanup_cons(consp);
			}

			/* delete group? */
			if (groupp->conspq == NULL) {
				/* no more console in the group delete group */
				assert(groupp->vntsd);

				(void) mutex_lock(&groupp->vntsd->lock);
				(void) vntsd_que_rm(&groupp->vntsd->grouppq,
				    groupp);
				(void) mutex_unlock(&groupp->vntsd->lock);

				/* clean up the group */
				vntsd_clean_group(groupp);
				break;
			}
		}
	}
}

/* clean up a group */
void
vntsd_clean_group(vntsd_group_t *groupp)
{

	timestruc_t	to;

	D1(stderr, "t@%d clean_group() group=%s tcp=%lld\n", thr_self(),
	    groupp->group_name, groupp->tcp_port);

	(void) mutex_lock(&groupp->lock);

	/* prevent from reentry */
	if (groupp->status & VNTSD_GROUP_IN_CLEANUP) {
		(void) mutex_unlock(&groupp->lock);
		return;
	}
	groupp->status |= VNTSD_GROUP_IN_CLEANUP;

	/* mark group waiting for listen thread to exits */
	groupp->status |= VNTSD_GROUP_SIG_WAIT;
	(void) mutex_unlock(&groupp->lock);

	vntsd_free_que(&groupp->conspq, (clean_func_t)cleanup_cons);

	(void) mutex_lock(&groupp->lock);
	/* walk through no cons client queue */
	while (groupp->no_cons_clientpq != NULL) {
		(void) vntsd_que_walk(groupp->no_cons_clientpq,
		    (el_func_t)vntsd_notify_client_cons_del);
		to.tv_sec = VNTSD_CV_WAIT_DELTIME;
		to.tv_nsec = 0;
		(void) cond_reltimedwait(&groupp->cvp, &groupp->lock, &to);
	}

	/* waiting for listen thread to exit */
	while (groupp->status & VNTSD_GROUP_SIG_WAIT) {
		/* signal listen thread to exit  */
		(void) thr_kill(groupp->listen_tid, SIGUSR1);
		to.tv_sec = VNTSD_CV_WAIT_DELTIME;
		to.tv_nsec = 0;
		/* wait listen thread to exit  */
		(void) cond_reltimedwait(&groupp->cvp, &groupp->lock, &to);
	}

	(void) mutex_unlock(&groupp->lock);
	(void) thr_join(groupp->listen_tid, NULL, NULL);
	/* free group */
	free_group(groupp);
}

/* allocate and initialize console structure */
static vntsd_cons_t *
alloc_cons(vntsd_group_t *groupp, vcc_console_t *consolep)
{
	vntsd_cons_t *consp;
	int	rv;

	/* allocate console */
	consp = (vntsd_cons_t *)malloc(sizeof (vntsd_cons_t));
	if (consp == NULL) {
		vntsd_log(VNTSD_ERR_NO_MEM, "alloc_cons");
		return (NULL);
	}

	/* intialize console */
	bzero(consp, sizeof (vntsd_cons_t));

	(void) mutex_init(&consp->lock, USYNC_THREAD|LOCK_ERRORCHECK, NULL);
	(void) cond_init(&consp->cvp, USYNC_THREAD, NULL);

	consp->cons_no = consolep->cons_no;
	(void) strlcpy(consp->domain_name, consolep->domain_name, MAXPATHLEN);
	(void) strlcpy(consp->dev_name, consolep->dev_name, MAXPATHLEN);
	consp->wr_tid = (thread_t)-1;
	consp->vcc_fd = -1;

	/* join the group */
	(void) mutex_lock(&groupp->lock);

	if ((rv = vntsd_que_append(&groupp->conspq, consp)) !=
	    VNTSD_SUCCESS) {
		(void) mutex_unlock(&groupp->lock);
		vntsd_log(rv, "alloc_cons");
		free_cons(consp);
		return (NULL);
	}
	groupp->num_cons++;
	consp->group = groupp;

	(void) mutex_unlock(&groupp->lock);

	D1(stderr, "t@%d alloc_cons@%d %s %s\n", thr_self(),
	    consp->cons_no, consp->domain_name, consp->dev_name);

	return (consp);
}

/* compare tcp with group->tcp */
static boolean_t
grp_by_tcp(vntsd_group_t *groupp, uint64_t *tcp_port)
{
	assert(groupp);
	assert(tcp_port);
	return (groupp->tcp_port == *tcp_port);
}

/* allocate and initialize group */
static vntsd_group_t *
alloc_group(vntsd_t *vntsdp, char *group_name, uint64_t tcp_port)
{
	vntsd_group_t *groupp;

	/* allocate group */
	groupp = (vntsd_group_t *)malloc(sizeof (vntsd_group_t));
	if (groupp == NULL) {
		vntsd_log(VNTSD_ERR_NO_MEM, "alloc_group");
		return (NULL);
	}

	/* initialize group */
	bzero(groupp, sizeof (vntsd_group_t));

	(void) mutex_init(&groupp->lock, USYNC_THREAD|LOCK_ERRORCHECK, NULL);
	(void) cond_init(&groupp->cvp, USYNC_THREAD, NULL);

	if (group_name != NULL) {
		(void) memcpy(groupp->group_name, group_name, MAXPATHLEN);
	}

	groupp->tcp_port = tcp_port;
	groupp->listen_tid = (thread_t)-1;
	groupp->sockfd = -1;
	groupp->vntsd = vntsdp;

	D1(stderr, "t@%d alloc_group@%lld:%s\n", thr_self(), groupp->tcp_port,
	    groupp->group_name);

	return (groupp);
}

/* mark a deleted console */
boolean_t
vntsd_mark_deleted_cons(vntsd_cons_t *consp)
{
	(void) mutex_lock(&consp->lock);
	consp->status |= VNTSD_CONS_DELETED;
	(void) mutex_unlock(&consp->lock);
	return (B_FALSE);
}

/*
 * Initialize a console, if console is associated with with a
 * new group, intialize the group.
 */
static int
alloc_cons_with_group(vntsd_t *vntsdp, vcc_console_t *consp,
    vntsd_group_t **new_groupp)
{
	vntsd_group_t	*groupp = NULL;
	int		rv;

	*new_groupp = NULL;

	/* match group by tcp port */


	(void) mutex_lock(&vntsdp->lock);
	groupp = vntsd_que_find(vntsdp->grouppq,
	    (compare_func_t)grp_by_tcp, (void *)&(consp->tcp_port));
	if (groupp != NULL)
		(void) mutex_lock(&groupp->lock);

	(void) mutex_unlock(&vntsdp->lock);

	if (groupp != NULL) {
		/*
		 *  group with same tcp port found.
		 *  if there is no console in the group, the
		 *  group should be removed and the tcp port can
		 *  be used for tne new group.
		 *  This is possible, when there is tight loop of
		 *  creating/deleting domains. When a vcc port is
		 *  removed, a read thread will have an I/O error because
		 *  vcc has closed the port. The read thread then marks
		 *  the console is removed and notify main thread to
		 *  remove the console.
		 *  Meanwhile, the same port and its group (with same
		 *  tcp port and group name) is created. Vcc notify
		 *  vntsd that new console is added.
		 *  Main thread now have two events. If main thread polls
		 *  out vcc notification first, it will find that there is
		 *  a group has no console.
		 */

		if (vntsd_chk_group_total_cons(groupp) == 0) {

			/* all consoles in the group have been removed */
			(void) vntsd_que_walk(groupp->conspq,
			    (el_func_t)vntsd_mark_deleted_cons);
			groupp->status |= VNTSD_GROUP_CLEAN_CONS;
			(void) mutex_unlock(&groupp->lock);
			groupp = NULL;

		} else if (strcmp(groupp->group_name, consp->group_name)) {
			/* conflict group name */
			vntsd_log(VNTSD_ERR_VCC_GRP_NAME,
			    "group name is different from existing group");
			(void) mutex_unlock(&groupp->lock);
			return (VNTSD_ERR_VCC_CTRL_DATA);

		} else {
			/* group already existed */
			(void) mutex_unlock(&groupp->lock);
		}

	}

	if (groupp == NULL) {
		/* new group */
		groupp = alloc_group(vntsdp, consp->group_name,
		    consp->tcp_port);
		if (groupp == NULL) {
			return (VNTSD_ERR_NO_MEM);
		}

		assert(groupp->conspq == NULL);
		/* queue group to vntsdp */
		(void) mutex_lock(&vntsdp->lock);
		rv = vntsd_que_append(&vntsdp->grouppq, groupp);
		(void) mutex_unlock(&vntsdp->lock);

		if (rv != VNTSD_SUCCESS) {
			return (rv);
		}

		*new_groupp = groupp;
	}

	/* intialize console */
	if (alloc_cons(groupp, consp) == NULL) {
		/* no memory */
		if (*new_groupp != NULL) {
			/* clean up new group */
			free_group(groupp);
		}

		return (VNTSD_ERR_NO_MEM);
	}

	return (VNTSD_SUCCESS);

}


/* create listen thread */
static boolean_t
create_listen_thread(vntsd_group_t *groupp)
{

	char err_msg[VNTSD_LINE_LEN];
	int rv;

	assert(groupp);

	(void) mutex_lock(&groupp->lock);
	assert(groupp->num_cons);

	D1(stderr, "t@%d create_listen:%lld\n", thr_self(), groupp->tcp_port);

	if ((rv = thr_create(NULL, 0, (thr_func_t)vntsd_listen_thread,
	    (void *)groupp, THR_DETACHED, &groupp->listen_tid)) != 0) {
		(void) (void) snprintf(err_msg, sizeof (err_msg),
		    "Can not create listen thread for"
		    "group %s tcp %llx\n", groupp->group_name,
		    groupp->tcp_port);
		vntsd_log(VNTSD_ERR_CREATE_LISTEN_THR, err_msg);

		/* clean up group queue */
		vntsd_free_que(&groupp->conspq, (clean_func_t)free_cons);
		groupp->listen_tid = (thread_t)-1;
	}

	(void) mutex_unlock(&groupp->lock);

	return (rv != 0);
}

/* find deleted console by console no */
static boolean_t
deleted_cons_by_consno(vntsd_cons_t *consp, int *cons_no)
{
	vntsd_client_t *clientp;

	assert(consp);

	if (consp->cons_no != *cons_no)
		return (B_FALSE);

	/* has console marked as deleted? */
	if ((consp->status & VNTSD_CONS_DELETED) == 0)
		return (B_TRUE);

	if (consp->clientpq == NULL)
		/* there is no client for this console */
		return (B_TRUE);

	/* need to notify clients of console ? */
	clientp = (vntsd_client_t *)consp->clientpq->handle;

	if (clientp->status & VNTSD_CLIENT_CONS_DELETED)
		/* clients of console have notified */
		return (B_FALSE);

	return (B_TRUE);
}

/* find group structure from console no */
static boolean_t
find_cons_group_by_cons_no(vntsd_group_t *groupp, uint_t *cons_no)
{
	vntsd_cons_t *consp;

	consp = vntsd_que_find(groupp->conspq,
	    (compare_func_t)deleted_cons_by_consno, cons_no);
	return (consp != NULL);

}

/* delete a console if the console exists in the vntsd */
static void
delete_cons_before_add(vntsd_t *vntsdp, uint_t cons_no)
{
	vntsd_group_t	    *groupp;
	vntsd_cons_t	    *consp;

	/* group exists? */
	(void) mutex_lock(&vntsdp->lock);
	groupp = vntsd_que_find(vntsdp->grouppq,
	    (compare_func_t)find_cons_group_by_cons_no,
	    &cons_no);
	(void) mutex_unlock(&vntsdp->lock);

	if (groupp == NULL) {
		/* no such group */
		return;
	}

	/* group exists, if console exists? */
	(void) mutex_lock(&groupp->lock);
	consp = vntsd_que_find(groupp->conspq,
	    (compare_func_t)deleted_cons_by_consno, &cons_no);

	if (consp == NULL) {
		/* no such console */
		(void) mutex_unlock(&groupp->lock);
		return;
	}

	/* console exists - mark console for main thread to delete it */
	(void) mutex_lock(&consp->lock);

	if (consp->status & VNTSD_CONS_DELETED) {
		/* already marked */
		(void) mutex_unlock(&consp->lock);
		(void) mutex_unlock(&groupp->lock);
		return;
	}

	consp->status |= VNTSD_CONS_DELETED;
	groupp->status |= VNTSD_GROUP_CLEAN_CONS;

	(void) mutex_unlock(&consp->lock);
	(void) mutex_unlock(&groupp->lock);

}

/* add a console */
static void
do_add_cons(vntsd_t *vntsdp, int cons_no)
{
	vcc_console_t	console;
	vntsd_group_t	*groupp;
	int		rv;
	char		err_msg[VNTSD_LINE_LEN];


	(void) snprintf(err_msg, sizeof (err_msg),
	    "do_add_cons():Can not add console=%d", cons_no);

	/* get console configuration from vcc */

	if ((rv = vntsd_vcc_ioctl(VCC_CONS_INFO, cons_no, (void *)&console))
	    != VNTSD_SUCCESS) {
		vntsd_log(rv, err_msg);
		return;
	}

	/* clean up the console if console was deleted and added again */
	delete_cons_before_add(vntsdp, console.cons_no);

	/* initialize console */

	if ((rv = alloc_cons_with_group(vntsdp, &console, &groupp)) !=
	    VNTSD_SUCCESS) {
		/* no memory to add this new console */
		vntsd_log(rv, err_msg);
		return;
	}

	if (groupp != NULL) {
		/* new group */
		/* create listen thread for this console */
		if (create_listen_thread(groupp)) {
			vntsd_log(VNTSD_ERR_CREATE_LISTEN_THR, err_msg);
			free_group(groupp);
		}

	}
}

/* daemon wake up */
void
vntsd_daemon_wakeup(vntsd_t *vntsdp)
{

	vcc_response_t	inq_data;

	/* reason to wake up  */
	if (vntsd_vcc_ioctl(VCC_INQUIRY, 0, (void *)&inq_data) !=
	    VNTSD_SUCCESS) {
		vntsd_log(VNTSD_ERR_VCC_IOCTL, "vntsd_daemon_wakeup()");
		return;
	}

	D1(stderr, "t@%d vntsd_daemon_wakup:msg %d port %x\n", thr_self(),
	    inq_data.reason, inq_data.cons_no);

	switch (inq_data.reason) {

	case VCC_CONS_ADDED:
		do_add_cons(vntsdp, inq_data.cons_no);
		break;

	case VCC_CONS_MISS_ADDED:
		/* an added port was deleted before vntsd can process it */
		return;

	default:
		DERR(stderr, "t@%d daemon_wakeup:ioctl_unknown %d\n",
		    thr_self(), inq_data.reason);
		vntsd_log(VNTSD_ERR_UNKNOWN_CMD, "from vcc\n");
		break;
	}
}

/* initial console configuration */
void
vntsd_get_config(vntsd_t *vntsdp)
{

	int		i;
	int		num_cons;
	vcc_console_t	*consp;
	vntsd_group_t	*groupp;

	/* num of consoles */
	num_cons = 0;

	if (vntsd_vcc_ioctl(VCC_NUM_CONSOLE, 0, (void *)&num_cons) !=
	    VNTSD_SUCCESS) {
		vntsd_log(VNTSD_ERR_VCC_IOCTL, "VCC_NUM_CONSOLE failed\n");
		return;
	}

	D3(stderr, "get_config:num_cons=%d", num_cons);

	if (num_cons == 0) {
		return;
	}

	/* allocate memory for all consoles */
	consp = malloc(num_cons*sizeof (vcc_console_t));

	if (consp == NULL) {
		vntsd_log(VNTSD_ERR_NO_MEM, "for console table.");
		return;
	}

	/* get console table */
	if (vntsd_vcc_ioctl(VCC_CONS_TBL, 0, (void *)consp) != VNTSD_SUCCESS) {
		vntsd_log(VNTSD_ERR_VCC_IOCTL, " VCC_CONS_TBL "
		    "for console table\n");
		return;
	}

	/* intialize groups and consoles  */
	for (i = 0; i < num_cons; i++) {
		if (alloc_cons_with_group(vntsdp, &consp[i], &groupp)
		    != VNTSD_SUCCESS) {
			vntsd_log(VNTSD_ERR_ADD_CONS_FAILED, "get_config");
		}
	}

	/* create listen thread for each group */
	(void) mutex_lock(&vntsdp->lock);

	for (; ; ) {
		groupp = vntsd_que_walk(vntsdp->grouppq,
		    (el_func_t)create_listen_thread);
		if (groupp == NULL) {
			break;
		}
		vntsd_log(VNTSD_ERR_CREATE_LISTEN_THR, "get config()");
	}

	(void) mutex_unlock(&vntsdp->lock);
}