/*
 * 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 "iscsi_thread.h"

static	void	iscsi_threads_entry(void *arg);

/*
 * iscsi_thread_create - Creates the needed resources to handle a thread
 */
iscsi_thread_t *
iscsi_thread_create(dev_info_t *dip, char *name,
    iscsi_thread_ep_t entry_point, void *arg)
{
	iscsi_thread_t		*thread;

	thread = kmem_zalloc(sizeof (iscsi_thread_t), KM_SLEEP);

	if (thread != NULL) {

		thread->tq = ddi_taskq_create(dip, name, 1,
		    TASKQ_DEFAULTPRI, 0);

		if (thread->tq != NULL) {
			thread->signature	= SIG_ISCSI_THREAD;
			thread->dip		= dip;
			thread->entry_point	= entry_point;
			thread->arg		= arg;
			thread->state		= ISCSI_THREAD_STATE_STOPPED;
			thread->sign.bitmap	= 0;
			mutex_init(&thread->mgnt.mtx, NULL, MUTEX_DRIVER, NULL);
			mutex_init(&thread->sign.mtx, NULL, MUTEX_DRIVER, NULL);
			cv_init(&thread->sign.cdv, NULL, CV_DRIVER, NULL);
		} else {
			kmem_free(thread, sizeof (iscsi_thread_t));
			thread = NULL;
		}
	}

	return (thread);
}

/*
 * iscsi_thread_destroy - Releases the needed resources to handle a thread
 */
void
iscsi_thread_destroy(
	iscsi_thread_t		*thread
)
{
	ASSERT(thread != NULL);
	ASSERT(thread->signature == SIG_ISCSI_THREAD);

	mutex_enter(&thread->mgnt.mtx);

	switch (thread->state) {

	case ISCSI_THREAD_STATE_STARTED:

		/* A kill signal is sent first. */
		thread->state = ISCSI_THREAD_STATE_DESTROYING;
		mutex_enter(&thread->sign.mtx);
		if (!(thread->sign.bitmap & ISCSI_THREAD_SIGNAL_KILL)) {
			thread->sign.bitmap |= ISCSI_THREAD_SIGNAL_KILL;
			cv_signal(&thread->sign.cdv);
		}
		mutex_exit(&thread->sign.mtx);
		ddi_taskq_wait(thread->tq);
		break;

	case ISCSI_THREAD_STATE_STOPPED:

		/* Switch the state and wait for the thread to exit. */
		thread->state = ISCSI_THREAD_STATE_DESTROYING;
		break;

	default:
		ASSERT(0);
		break;
	}

	mutex_exit(&thread->mgnt.mtx);
	ddi_taskq_destroy(thread->tq);
	cv_destroy(&thread->sign.cdv);
	mutex_destroy(&thread->sign.mtx);
	mutex_destroy(&thread->mgnt.mtx);
	thread->signature = (uint32_t)~SIG_ISCSI_THREAD;
	kmem_free(thread, sizeof (iscsi_thread_t));
}

/*
 * iscsi_thread_start - Starts the thread given as an entry parameter
 */
boolean_t
iscsi_thread_start(
	iscsi_thread_t		*thread
)
{
	boolean_t		ret = B_FALSE;

	ASSERT(thread != NULL);
	ASSERT(thread->signature == SIG_ISCSI_THREAD);

	mutex_enter(&thread->mgnt.mtx);

	switch (thread->state) {

	case ISCSI_THREAD_STATE_STARTED:

		mutex_enter(&thread->sign.mtx);

		thread->state = ISCSI_THREAD_STATE_STOPPING;

		if (!(thread->sign.bitmap & ISCSI_THREAD_SIGNAL_KILL)) {
			thread->sign.bitmap |= ISCSI_THREAD_SIGNAL_KILL;
			cv_signal(&thread->sign.cdv);
		}
		mutex_exit(&thread->sign.mtx);
		ddi_taskq_wait(thread->tq);
		thread->state = ISCSI_THREAD_STATE_STOPPED;
		/* FALLTHRU */

	case ISCSI_THREAD_STATE_STOPPED:

		thread->sign.bitmap = 0;
		thread->state	    = ISCSI_THREAD_STATE_STARTING;

		if (ddi_taskq_dispatch(thread->tq, iscsi_threads_entry,
		    thread, DDI_SLEEP) == DDI_SUCCESS) {
			/*
			 * The dispatch succeeded.
			 */
			thread->state = ISCSI_THREAD_STATE_STARTED;
			ret = B_TRUE;
		}
		break;

	default:
		ASSERT(0);
		break;
	}
	mutex_exit(&thread->mgnt.mtx);
	return (ret);
}

/*
 * iscsi_thread_stop -
 */
boolean_t
iscsi_thread_stop(
	iscsi_thread_t		*thread
)
{
	boolean_t		ret = B_FALSE;

	ASSERT(thread != NULL);
	ASSERT(thread->signature == SIG_ISCSI_THREAD);

	mutex_enter(&thread->mgnt.mtx);

	switch (thread->state) {

	case ISCSI_THREAD_STATE_STARTED:

		mutex_enter(&thread->sign.mtx);

		thread->state = ISCSI_THREAD_STATE_STOPPING;

		if (!(thread->sign.bitmap & ISCSI_THREAD_SIGNAL_KILL)) {
			thread->sign.bitmap |= ISCSI_THREAD_SIGNAL_KILL;
			cv_signal(&thread->sign.cdv);
		}
		mutex_exit(&thread->sign.mtx);
		ddi_taskq_wait(thread->tq);
		thread->state = ISCSI_THREAD_STATE_STOPPED;
		ret = B_TRUE;
		break;

	case ISCSI_THREAD_STATE_STOPPED:
		ret = B_TRUE;
		break;

	default:
		ASSERT(0);
		break;
	}
	mutex_exit(&thread->mgnt.mtx);
	return (ret);
}

/*
 * iscsi_thread_send_kill -
 */
void
iscsi_thread_send_kill(
	iscsi_thread_t		*thread
)
{
	ASSERT(thread != NULL);
	ASSERT(thread->signature == SIG_ISCSI_THREAD);

	mutex_enter(&thread->mgnt.mtx);

	switch (thread->state) {

	case ISCSI_THREAD_STATE_STARTED:

		mutex_enter(&thread->sign.mtx);
		if (!(thread->sign.bitmap & ISCSI_THREAD_SIGNAL_KILL)) {
			thread->sign.bitmap |= ISCSI_THREAD_SIGNAL_KILL;
			cv_signal(&thread->sign.cdv);
		}
		mutex_exit(&thread->sign.mtx);
		break;

	default:
		ASSERT(0);
		break;
	}
	mutex_exit(&thread->mgnt.mtx);
}

/*
 * iscsi_thread_send_wakeup -
 */
boolean_t
iscsi_thread_send_wakeup(
	iscsi_thread_t		*thread
)
{
	boolean_t	ret = B_FALSE;

	ASSERT(thread != NULL);
	ASSERT(thread->signature == SIG_ISCSI_THREAD);

	mutex_enter(&thread->mgnt.mtx);

	switch (thread->state) {

	case ISCSI_THREAD_STATE_STARTED:

		mutex_enter(&thread->sign.mtx);
		if (!(thread->sign.bitmap & ISCSI_THREAD_SIGNAL_WAKEUP)) {
			thread->sign.bitmap |= ISCSI_THREAD_SIGNAL_WAKEUP;
			cv_signal(&thread->sign.cdv);
		}
		mutex_exit(&thread->sign.mtx);
		ret = B_TRUE;
		break;

	default:
		break;
	}
	mutex_exit(&thread->mgnt.mtx);
	return (ret);
}

/*
 * iscsi_thread_check_signals -
 */
uint32_t
iscsi_thread_check_signals(
	iscsi_thread_t		*thread
)
{
	uint32_t		bitmap;

	ASSERT(thread != NULL);
	ASSERT(thread->signature == SIG_ISCSI_THREAD);

	/* Acquire the mutex before anychecking. */
	mutex_enter(&thread->sign.mtx);
	bitmap = thread->sign.bitmap;
	mutex_exit(&thread->sign.mtx);
	return (bitmap);
}
/*
 * iscsi_thread_wait -
 */
int
iscsi_thread_wait(
	iscsi_thread_t		*thread,
	clock_t			timeout
)
{
	int			rtn = 1;

	ASSERT(thread != NULL);
	ASSERT(thread->signature == SIG_ISCSI_THREAD);

	/* Acquire the mutex before anychecking. */
	mutex_enter(&thread->sign.mtx);

	/* Check the signals. */
	if (thread->sign.bitmap & ISCSI_THREAD_SIGNAL_KILL) {
		goto signal_kill;
	} else if (thread->sign.bitmap & ISCSI_THREAD_SIGNAL_WAKEUP) {
		goto signal_wakeup;
	} else if (timeout == 0) {
		goto iscsi_thread_sleep_exit;
	}

	if (timeout == -1) {
		cv_wait(&thread->sign.cdv, &thread->sign.mtx);
	} else {
		rtn = cv_reltimedwait(&thread->sign.cdv, &thread->sign.mtx,
		    timeout, TR_CLOCK_TICK);
	}

	/* Check the signals. */
	if (thread->sign.bitmap & ISCSI_THREAD_SIGNAL_KILL) {
		goto signal_kill;
	} else if (thread->sign.bitmap & ISCSI_THREAD_SIGNAL_WAKEUP) {
		goto signal_wakeup;
	}

iscsi_thread_sleep_exit:
	mutex_exit(&thread->sign.mtx);
	return (rtn);

signal_kill:
	mutex_exit(&thread->sign.mtx);
	return (0);

signal_wakeup:
	thread->sign.bitmap &= ~ISCSI_THREAD_SIGNAL_WAKEUP;
	mutex_exit(&thread->sign.mtx);
	return (1);
}

/*
 * iscsi_threads_entry - Common entry point for all threads
 */
static
void
iscsi_threads_entry(
	void			*arg
)
{
	iscsi_thread_t		*thread;

	thread = (iscsi_thread_t *)arg;

	ASSERT(thread != NULL);
	ASSERT(thread->signature == SIG_ISCSI_THREAD);

	(thread->entry_point)(thread, thread->arg);
}