/*
 * 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) 2002-2003, Network Appliance, Inc. All rights reserved.
 */

/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 *
 * MODULE: dapl_osd.c
 *
 * PURPOSE: Operating System Dependent layer
 * Description:
 *	Provide OS dependent functions with a canonical DAPL
 *	interface. Designed to be portable and hide OS specific quirks
 *	of common functions.
 *
 *
 * $Id: dapl_osd.c,v 1.26 2003/07/31 14:04:18 jlentini Exp $
 */

#include "dapl_osd.h"
#include "dapl.h"
#include "dapl_hca_util.h"
#include "dapl_ia_util.h"
#include "dapl_rmr_util.h"
#include "dapl_lmr_util.h"
#include "dapl_pz_util.h"
#include "dapl_ep_util.h"
#include "dapl_cr_util.h"
#include "dapl_evd_util.h"
#include "dapl_sp_util.h"
#include "dapl_adapter_util.h"
#include "dapl_provider.h"
#include "dapl_hash.h"
#include "dapl_debug.h"

#include <sys/time.h>
#include <stdlib.h>			/* needed for getenv() */
#include <pthread.h>			/* needed for pthread_atfork() */
#include <signal.h>			/* needed for thread setup */

static void dapls_osd_fork_cleanup(void);

/*
 * dapl_osd_init
 *
 * Do Linux initialization:
 * - Set up fork handler to clean up DAPL resources in the child
 *   process after a fork().
 *
 * Input:
 *      none
 *
 * Returns:
 *	DAT_SUCCESS
 */
void
dapl_os_init()
{
	int status;

	/*
	 * Set up fork control
	 */
	status = pthread_atfork(NULL, NULL, dapls_osd_fork_cleanup);
	if (status != 0) {
		dapl_dbg_log(DAPL_DBG_TYPE_WARN,
		    "WARNING: pthread_atfork %d\n", status);
	}
}


/*
 * dapl_os_get_time
 *
 * Return 64 bit value of current time in microseconds.
 *
 * Input:
 *      loc       User location to place current time
 *
 * Returns:
 *	DAT_SUCCESS
 */

DAT_RETURN
dapl_os_get_time(
    OUT DAPL_OS_TIMEVAL * loc)
{
	struct timeval	tv;
	struct timezone	tz;


	(void) gettimeofday(&tv, &tz);
	*loc = ((DAT_UINT64)(tv.tv_sec) * 1000000L) + (DAT_UINT64) tv.tv_usec;

	return (DAT_SUCCESS);
}


/*
 * dapl_os_get__env_bool
 *
 * Return boolean value of passed in environment variable: 1 if present,
 * 0 if not
 *
 * Input:
 *
 *
 * Returns:
 *	TRUE or FALSE
 */
int
dapl_os_get_env_bool(
	char		*env_str)
{
	char		*env_var;

	env_var = getenv(env_str);
	if (env_var != NULL) {
		return (1);
	}

	return (0);
}


/*
 * dapl_os_get_env_val
 *
 * Update val to  value of passed in environment variable if present
 *
 * Input:
 *      env_str
 *	def_val		default value if environment variable does not exist
 *
 * Returns:
 *	TRUE or FALSE
 */
int
dapl_os_get_env_val(
	char		*env_str,
	int		def_val)
{
	char		*env_var;

	env_var = getenv(env_str);
	if (env_var != NULL) {
		def_val = strtol(env_var, NULL, 0);
	}

	return (def_val);
}


/*
 * Wait object routines
 */

/*
 * dapl_os_wait_object_init
 *
 * Initialize a wait object
 *
 * Input:
 *	wait_obj
 *
 * Returns:
 *	DAT_SUCCESS
 *	DAT_INTERNAL_ERROR
 */
DAT_RETURN
dapl_os_wait_object_init(
    IN DAPL_OS_WAIT_OBJECT *wait_obj)
{
	wait_obj->signaled = DAT_FALSE;
	if (0 != pthread_cond_init(&wait_obj->cv, NULL)) {
		return (DAT_ERROR(DAT_INTERNAL_ERROR, 0));
	}

	/* Always returns 0.  */
	(void) pthread_mutex_init(&wait_obj->lock, NULL);

	return (DAT_SUCCESS);
}


/*
 * Wait on the supplied wait object, up to the specified time_out.
 * A timeout of DAT_TIMEOUT_INFINITE will wait indefinitely.
 * Timeout should be specified in micro seconds.
 *
 * Functional returns:
 *	DAT_SUCCESS -- another thread invoked dapl_os_wait object_wakeup
 * 	DAT_INVALID_STATE -- someone else is already waiting in this wait
 * 	object.
 *			     only one waiter is allowed at a time.
 *	DAT_ABORT -- another thread invoked dapl_os_wait_object_destroy
 *	DAT_TIMEOUT -- the specified time limit was reached.
 */

DAT_RETURN
dapl_os_wait_object_wait(
	IN  DAPL_OS_WAIT_OBJECT *wait_obj,
	IN  DAT_TIMEOUT timeout_val)
{
	DAT_RETURN 		dat_status;
	int			pthread_status;
	struct timespec 	future;

	dat_status = DAT_SUCCESS;
	pthread_status = 0;

	if (timeout_val != DAT_TIMEOUT_INFINITE) {
		struct timeval now;
		struct timezone tz;
		unsigned int microsecs;

		(void) gettimeofday(&now, &tz);
		microsecs = now.tv_usec + (timeout_val % 1000000);
		if (microsecs > 1000000) {
			now.tv_sec = now.tv_sec + timeout_val / 1000000 + 1;
			now.tv_usec = microsecs - 1000000;
		} else {
			now.tv_sec = now.tv_sec + timeout_val / 1000000;
			now.tv_usec = microsecs;
		}

		/* Convert timeval to timespec */
		future.tv_sec = now.tv_sec;
		future.tv_nsec = now.tv_usec * 1000;

		(void) pthread_mutex_lock(&wait_obj->lock);
		while (wait_obj->signaled == DAT_FALSE && pthread_status == 0) {
			pthread_status = pthread_cond_timedwait(
			    &wait_obj->cv, &wait_obj->lock, &future);

			/*
			 * No need to reset &future if we go around the loop;
			 * It's an absolute time.
			 */
		}
		/* Reset the signaled status if we were woken up.  */
		if (pthread_status == 0) {
			wait_obj->signaled = DAT_FALSE;
		}
		(void) pthread_mutex_unlock(&wait_obj->lock);
	} else {
		(void) pthread_mutex_lock(&wait_obj->lock);
		while (wait_obj->signaled == DAT_FALSE && pthread_status == 0) {
			pthread_status = pthread_cond_wait(
			    &wait_obj->cv, &wait_obj->lock);
		}
		/* Reset the signaled status if we were woken up.  */
		if (pthread_status == 0) {
			wait_obj->signaled = DAT_FALSE;
		}
		(void) pthread_mutex_unlock(&wait_obj->lock);
	}

	if (ETIMEDOUT == pthread_status) {
		dat_status = DAT_ERROR(DAT_TIMEOUT_EXPIRED, 0);
	} else if (0 != pthread_status) {
		dat_status = DAT_ERROR(DAT_INTERNAL_ERROR, 0);
	}

	return (dat_status);
}


/*
 * dapl_os_wait_object_wakeup
 *
 * Wakeup a thread waiting on a wait object
 *
 * Input:
 *      wait_obj
 *
 * Returns:
 *	DAT_SUCCESS
 *	DAT_INTERNAL_ERROR
 */
DAT_RETURN
dapl_os_wait_object_wakeup(
    IN	DAPL_OS_WAIT_OBJECT *wait_obj)
{
	(void) pthread_mutex_lock(&wait_obj->lock);
	wait_obj->signaled = DAT_TRUE;
	(void) pthread_mutex_unlock(&wait_obj->lock);
	if (0 != pthread_cond_signal(&wait_obj->cv)) {
		return (DAT_ERROR(DAT_INTERNAL_ERROR, 0));
	}

	return (DAT_SUCCESS);
}


/*
 * dapl_os_wait_object_destroy
 *
 * Destroy a wait object
 *
 * Input:
 *      wait_obj
 *
 * Returns:
 *	DAT_SUCCESS
 *	DAT_INTERNAL_ERROR
 */
DAT_RETURN
dapl_os_wait_object_destroy(
    IN	DAPL_OS_WAIT_OBJECT *wait_obj)
{
	if (0 != pthread_cond_destroy(&wait_obj->cv)) {
		return (DAT_ERROR(DAT_INTERNAL_ERROR, 0));
	}
	if (0 != pthread_mutex_destroy(&wait_obj->lock)) {
		return (DAT_ERROR(DAT_INTERNAL_ERROR, 0));
	}

	return (DAT_SUCCESS);
}


/*
 * dapls_osd_fork_cleanup
 *
 * Update val to  value of passed in environment variable if present
 *
 * Input:
 *      env_str
 *	val		Updated if environment variable exists
 *
 * Returns:
 *	TRUE or FALSE
 */
void
dapls_osd_fork_cleanup(void)
{
	DAPL_PROVIDER_LIST_NODE 	*cur_node;
	DAPL_HCA			*hca_ptr;
	DAPL_IA				*ia_ptr;
	DAPL_LMR 			*lmr_ptr;
	DAPL_RMR			*rmr_ptr;
	DAPL_PZ				*pz_ptr;
	DAPL_CR				*cr_ptr;
	DAPL_EP				*ep_ptr;
	DAPL_EVD			*evd_ptr;
	DAT_EP_PARAM			*param;
	DAPL_SP				*sp_ptr;

	while (NULL != g_dapl_provider_list.head) {
		cur_node = g_dapl_provider_list.head;
		g_dapl_provider_list.head = cur_node->next;

		hca_ptr = (DAPL_HCA *) cur_node->data.extension;

		/*
		 * Walk the list of IA ptrs & clean up. This is purposely
		 * a destructive list walk, we really don't want to preserve
		 * any of it.
		 */
		while (!dapl_llist_is_empty(&hca_ptr->ia_list_head)) {
			ia_ptr = (DAPL_IA *)
			    dapl_llist_peek_head(&hca_ptr->ia_list_head);

			/*
			 * The rest of the cleanup code is similar to
			 * dapl_ia_close, the big difference is that we don't
			 * release IB resources, only memory; the underlying IB
			 * subsystem doesn't deal with fork at all, so leave
			 * IB handles alone.
			 */
			while (!dapl_llist_is_empty(&ia_ptr->rmr_list_head)) {
				rmr_ptr = (DAPL_RMR *)
				    dapl_llist_peek_head(&ia_ptr->
				    rmr_list_head);
				if (rmr_ptr->param.lmr_triplet.
				    virtual_address != 0) {
					dapl_os_atomic_dec(&rmr_ptr->
					    lmr->lmr_ref_count);
					rmr_ptr->param.lmr_triplet.
					    virtual_address = 0;
				}
				dapl_os_atomic_dec(&rmr_ptr->pz->pz_ref_count);
				dapl_ia_unlink_rmr(rmr_ptr->header.owner_ia,
				    rmr_ptr);
				dapl_rmr_dealloc(rmr_ptr);
			}

			while (!dapl_llist_is_empty(&ia_ptr->rsp_list_head)) {
				sp_ptr = (DAPL_SP *) dapl_llist_peek_head(
				    &ia_ptr->rsp_list_head);
				dapl_os_atomic_dec(&((DAPL_EVD *)sp_ptr->
				    evd_handle)->evd_ref_count);
				dapls_ia_unlink_sp(ia_ptr, sp_ptr);
				dapls_sp_free_sp(sp_ptr);
			}

			while (!dapl_llist_is_empty(&ia_ptr->ep_list_head)) {
				ep_ptr = (DAPL_EP *) dapl_llist_peek_head(
				    &ia_ptr->ep_list_head);
				param = &ep_ptr->param;
				if (param->pz_handle != NULL) {
					dapl_os_atomic_dec(&((DAPL_PZ *)param->
					    pz_handle)->pz_ref_count);
				}
				if (param->recv_evd_handle != NULL) {
					dapl_os_atomic_dec(&((DAPL_EVD *)param->
					    recv_evd_handle)->evd_ref_count);
				}
				if (param->request_evd_handle) {
					dapl_os_atomic_dec(&((DAPL_EVD *)param->
					    request_evd_handle)->evd_ref_count);
				}
				if (param->connect_evd_handle != NULL) {
					dapl_os_atomic_dec(&((DAPL_EVD *)param->
					    connect_evd_handle)->evd_ref_count);
				}

				/* ...and free the resource */
				dapl_ia_unlink_ep(ia_ptr, ep_ptr);
				dapl_ep_dealloc(ep_ptr);
			}

			while (!dapl_llist_is_empty(&ia_ptr->lmr_list_head)) {
				lmr_ptr = (DAPL_LMR *) dapl_llist_peek_head(
				    &ia_ptr->lmr_list_head);

				(void) dapls_hash_remove(lmr_ptr->header.
				    owner_ia->hca_ptr->lmr_hash_table,
				    lmr_ptr->param.lmr_context, NULL);

				pz_ptr = (DAPL_PZ *) lmr_ptr->param.pz_handle;
				dapl_os_atomic_dec(&pz_ptr->pz_ref_count);
				dapl_ia_unlink_lmr(lmr_ptr->header.owner_ia,
				    lmr_ptr);
				dapl_lmr_dealloc(lmr_ptr);
			}

			while (!dapl_llist_is_empty(&ia_ptr->psp_list_head)) {
				sp_ptr = (DAPL_SP *) dapl_llist_peek_head(
				    &ia_ptr->psp_list_head);
				while (!dapl_llist_is_empty(&sp_ptr->
				    cr_list_head)) {
					cr_ptr = (DAPL_CR *)
					    dapl_llist_peek_head(
					    &sp_ptr->cr_list_head);
					dapl_sp_remove_cr(sp_ptr, cr_ptr);
					dapls_cr_free(cr_ptr);
				}

				dapls_ia_unlink_sp(ia_ptr, sp_ptr);
				dapl_os_atomic_dec(&((DAPL_EVD *)sp_ptr->
				    evd_handle)->evd_ref_count);
				dapls_sp_free_sp(sp_ptr);
			}

			while (!dapl_llist_is_empty(&ia_ptr->pz_list_head)) {
				pz_ptr = (DAPL_PZ *)
				    dapl_llist_peek_head(&ia_ptr->pz_list_head);
				dapl_ia_unlink_pz(pz_ptr->header.owner_ia,
				    pz_ptr);
				dapl_pz_dealloc(pz_ptr);
			}

			while (!dapl_llist_is_empty(&ia_ptr->evd_list_head)) {
				evd_ptr = (DAPL_EVD *) dapl_llist_peek_head(
				    &ia_ptr->evd_list_head);
				dapl_ia_unlink_evd(evd_ptr->header.owner_ia,
				    evd_ptr);
				/*
				 * reset the cq_handle to avoid having it
				 * removed
				 */
				evd_ptr->ib_cq_handle = IB_INVALID_HANDLE;
				(void) dapls_evd_dealloc(evd_ptr);
			}

			dapl_hca_unlink_ia(ia_ptr->hca_ptr, ia_ptr);
			/*
			 * asycn error evd was taken care of above, reset the
			 * pointer
			 */
			ia_ptr->async_error_evd = NULL;
			dapls_ia_free(ia_ptr);
		}	/* end while( ia_ptr != NULL ) */


		dapl_os_free(cur_node, sizeof (DAPL_PROVIDER_LIST_NODE));
	} /* end while (NULL != g_dapl_provider_list.head) */
}


/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 *  tab-width: 8
 * End:
 */