/*
 * 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:
 */