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

/*
 *
 * MODULE: dapls_cr_callback.c
 *
 * PURPOSE: implements passive side connection callbacks
 *
 * Description: Accepts asynchronous callbacks from the Communications Manager
 *              for EVDs that have been specified as the connection_evd.
 *
 * $Id: dapl_cr_callback.c,v 1.58 2003/08/20 14:55:39 sjs2 Exp $
 */

#include "dapl.h"
#include "dapl_evd_util.h"
#include "dapl_cr_util.h"
#include "dapl_ia_util.h"
#include "dapl_sp_util.h"
#include "dapl_ep_util.h"
#include "dapl_adapter_util.h"


/*
 * Prototypes
 */
DAT_RETURN dapli_connection_request(
	IN ib_cm_handle_t ib_cm_handle,
	IN DAPL_SP *sp_ptr,
	IN DAPL_PRIVATE	*prd_ptr,
	IN DAPL_EVD *evd_ptr);

DAPL_EP * dapli_get_sp_ep(
	IN ib_cm_handle_t ib_cm_handle,
	IN DAPL_SP *sp_ptr,
	IN const ib_cm_events_t ib_cm_event);

/*
 * dapls_cr_callback
 *
 * The callback function registered with verbs for passive side of
 * connection requests. The interface is specified by cm_api.h
 *
 *
 * Input:
 * 	ib_cm_handle,		Handle to CM
 * 	ib_cm_event		Specific CM event
 *	instant_data		Private data with DAT ADDRESS header
 * 	context			SP pointer
 *
 * Output:
 * 	None
 *
 */
void
dapls_cr_callback(
	IN ib_cm_handle_t ib_cm_handle,
	IN const ib_cm_events_t ib_cm_event,
	IN const void *private_data_ptr, /* event data */
	IN const void *context)
{
	DAPL_EP		*ep_ptr;
	DAPL_EVD	*evd_ptr;
	DAPL_SP		*sp_ptr;
	DAPL_PRIVATE	*prd_ptr;
	DAT_EVENT_NUMBER	event_type;
	DAT_RETURN		dat_status;

	dapl_dbg_log(DAPL_DBG_TYPE_CM,
	    "--> dapls_cr_callback! context: 0x%p "
	    "event: %d cm_handle 0x%llx magic 0x%x\n",
	    context, ib_cm_event, ib_cm_handle,
	    ((DAPL_HEADER *)context)->magic);

	if (((DAPL_HEADER *)context)->magic == DAPL_MAGIC_INVALID) {
		return;
	}
	/*
	 * Passive side of the connection, context is a SP and
	 * we need to look up the EP.
	 */
	dapl_os_assert(((DAPL_HEADER *)context)->magic == DAPL_MAGIC_PSP ||
	    ((DAPL_HEADER *)context)->magic == DAPL_MAGIC_RSP);
	sp_ptr = (DAPL_SP *) context;

	/*
	 * CONNECT_REQUEST events create an event on the PSP
	 * EVD, which will trigger connection processing. The
	 * sequence is:
	 * CONNECT_REQUEST Event to SP
	 * CONNECTED Event to EP
	 * DISCONNECT Event to EP
	 *
	 * Obtain the EP if required and set an event up on the correct EVD.
	 */
	if (ib_cm_event == IB_CME_CONNECTION_REQUEST_PENDING ||
	    ib_cm_event == IB_CME_CONNECTION_REQUEST_PENDING_PRIVATE_DATA) {
		ep_ptr = NULL;
		evd_ptr = sp_ptr->evd_handle;
	} else {
		ep_ptr = dapli_get_sp_ep(ib_cm_handle, sp_ptr, ib_cm_event);
		dapl_os_assert(ep_ptr != NULL);
		evd_ptr = (DAPL_EVD *) ep_ptr->param.connect_evd_handle;
		dapl_dbg_log(DAPL_DBG_TYPE_CM,
		    "    dapls_cr_callback cont: ep 0x%p evd 0x%p\n",
		    ep_ptr, evd_ptr);
	}

	prd_ptr = (DAPL_PRIVATE *)private_data_ptr;
	dat_status = DAT_INTERNAL_ERROR;	/* init to ERR */

	switch (ib_cm_event) {
	case IB_CME_CONNECTION_REQUEST_PENDING:
	case IB_CME_CONNECTION_REQUEST_PENDING_PRIVATE_DATA: {
		/*
		 * Requests arriving on a disabled SP are immediatly rejected
		 */

		dapl_os_lock(&sp_ptr->header.lock);
		if (sp_ptr->listening == DAT_FALSE) {
			dapl_os_unlock(&sp_ptr->header.lock);
			dapl_dbg_log(DAPL_DBG_TYPE_CM,
			"---> dapls_cr_callback: conn event on down SP\n");
			return;
		}

		if (sp_ptr->header.handle_type == DAT_HANDLE_TYPE_RSP) {
		/*
		 * RSP connections only allow a single connection. Close
		 * it down NOW so we reject any further connections.
		 */
			sp_ptr->listening = DAT_FALSE;
		}
		dapl_os_unlock(&sp_ptr->header.lock);

		/*
		 * Only occurs on the passive side of a connection
		 * dapli_connection_request will post the connection
		 * event if appropriate.
		 */
		dat_status = dapli_connection_request(ib_cm_handle,
		    sp_ptr, prd_ptr, evd_ptr);
		break;
	}
	case IB_CME_CONNECTED: {
		/*
		 * This is just a notification the connection is now
		 * established, there isn't any private data to deal with.
		 *
		 * Update the EP state and cache a copy of the cm handle,
		 * then let the user know we are ready to go.
		 */
		dapl_os_lock(&ep_ptr->header.lock);
		if (ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECT_PENDING) {
		/*
		 * If someone pulled the plug on the connection, just
		 * exit
		 */
			dapl_os_unlock(&ep_ptr->header.lock);
			dat_status = DAT_SUCCESS;
			break;
		}
		dapls_ib_connected(ep_ptr);
		ep_ptr->param.ep_state = DAT_EP_STATE_CONNECTED;
		ep_ptr->cm_handle = ib_cm_handle;
		dapl_os_unlock(&ep_ptr->header.lock);

		dat_status = dapls_evd_post_connection_event(
		    evd_ptr,
		    DAT_CONNECTION_EVENT_ESTABLISHED,
		    (DAT_HANDLE) ep_ptr,
		    ((DAPL_CR *)ep_ptr->cr_ptr)->param.private_data_size,
		    ((DAPL_CR *)ep_ptr->cr_ptr)->param.private_data);
		/*
		 * post them to the recv evd now.
		 * there is a race here - if events arrive after we change
		 * the ep state to connected and before we process premature
		 * events
		 */
		dapls_evd_post_premature_events(ep_ptr);
		break;
	}
	case IB_CME_DISCONNECTED:
	case IB_CME_DISCONNECTED_ON_LINK_DOWN: {
		/*
		 * EP is now fully disconnected; initiate any post processing
		 * to reset the underlying QP and get the EP ready for
		 * another connection
		 */
		dapl_os_lock(&ep_ptr->header.lock);
		if (ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECTED) {
			/* DTO error caused this */
			event_type = DAT_CONNECTION_EVENT_BROKEN;
		} else {
			ep_ptr->param.ep_state  = DAT_EP_STATE_DISCONNECTED;
			dapls_ib_disconnect_clean(ep_ptr, DAT_FALSE,
			    ib_cm_event);
			event_type = DAT_CONNECTION_EVENT_DISCONNECTED;
		}
		dapls_evd_post_premature_events(ep_ptr);

		ep_ptr->cr_ptr = NULL;
		dapl_os_unlock(&ep_ptr->header.lock);

		/*
		 * If the user has done an ep_free of the EP, we have been
		 * waiting for the disconnect event; just clean it up now.
		 */
		if (ep_ptr->header.magic == DAPL_MAGIC_EP_EXIT) {
			(void) dapl_ep_free(ep_ptr);
		}

		/* If the EP has been freed, the evd_ptr will be NULL */
		if (evd_ptr != NULL) {
			dat_status = dapls_evd_post_connection_event(
			    evd_ptr, event_type, (DAT_HANDLE) ep_ptr, 0, 0);
		}

		break;
	}
	case IB_CME_DESTINATION_REJECT:
	case IB_CME_DESTINATION_REJECT_PRIVATE_DATA:
	case IB_CME_DESTINATION_UNREACHABLE: {
		/*
		 * After posting an accept the requesting node has
		 * stopped talking.
		 */
		dapl_os_lock(&ep_ptr->header.lock);
		ep_ptr->param.ep_state  = DAT_EP_STATE_DISCONNECTED;
		ep_ptr->cm_handle = IB_INVALID_HANDLE;
		dapls_ib_disconnect_clean(ep_ptr, DAT_FALSE, ib_cm_event);
		dapl_os_unlock(&ep_ptr->header.lock);
		dat_status = dapls_evd_post_connection_event(
		    evd_ptr,
		    DAT_CONNECTION_EVENT_ACCEPT_COMPLETION_ERROR,
		    (DAT_HANDLE) ep_ptr, 0, 0);

		break;
	}
	case IB_CME_TOO_MANY_CONNECTION_REQUESTS: {
		/*
		 * DAPL does not deal with this IB error. There is a
		 * separate OVERFLOW event error if we try to post too many
		 * events, but we don't propagate this provider error.  Not
		 * all providers generate this error.
		 */
		break;
	}
	case IB_CME_LOCAL_FAILURE: {
		ep_ptr->param.ep_state  = DAT_EP_STATE_DISCONNECTED;
		dapls_ib_disconnect_clean(ep_ptr, DAT_FALSE, ib_cm_event);
		dat_status = dapls_evd_post_connection_event(
		    evd_ptr,
		    DAT_CONNECTION_EVENT_BROKEN,
		    (DAT_HANDLE) ep_ptr, 0, 0);

		break;
	}
	case IB_CME_TIMED_OUT: {
		ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECTED;
		dapls_ib_disconnect_clean(ep_ptr, DAT_FALSE, ib_cm_event);
		dat_status = dapls_evd_post_connection_event(
		    evd_ptr,
		    DAT_CONNECTION_EVENT_TIMED_OUT,
		    (DAT_HANDLE) ep_ptr, 0, 0);

		break;
	}
	default:
		dapl_os_assert(0);		/* shouldn't happen */
		break;
	}

	if (dat_status != DAT_SUCCESS) {
		/* The event post failed; take appropriate action.  */
		(void) dapls_ib_reject_connection(ib_cm_handle,
		    IB_CME_LOCAL_FAILURE, sp_ptr);
		return;
	}
}


/*
 * dapli_connection_request
 *
 * Process a connection request on the Passive side of a connection.
 * Create a CR record and link it on to the SP so we can update it
 * and free it later. Create an EP if specified by the PSP flags.
 *
 * Input:
 * 	ib_cm_handle,
 * 	sp_ptr
 * 	event_ptr
 *	prd_ptr
 *
 * Output:
 * 	None
 *
 * Returns
 *	DAT_INSUFFICIENT_RESOURCES
 *	DAT_SUCCESS
 *
 */
DAT_RETURN
dapli_connection_request(
	IN  ib_cm_handle_t ib_cm_handle,
	IN  DAPL_SP *sp_ptr,
	IN  DAPL_PRIVATE *prd_ptr,
	IN  DAPL_EVD *evd_ptr)
{
	DAT_RETURN	dat_status;
	DAPL_CR		*cr_ptr;
	DAPL_EP		*ep_ptr;
	DAPL_IA		*ia_ptr;
	DAT_SP_HANDLE	sp_handle;
	struct sockaddr_in *sv4;
	struct sockaddr_in6 *sv6;
	uint8_t		*sadata;
	DAT_COUNT	length;

	cr_ptr = dapls_cr_alloc(sp_ptr->header.owner_ia);
	if (cr_ptr == NULL) {
		/* Invoking function will call dapls_ib_cm_reject() */
		return (DAT_INSUFFICIENT_RESOURCES);
	}

	/*
	 * Set up the CR
	 */
	cr_ptr->sp_ptr = sp_ptr; /* maintain sp_ptr in case of reject */
	cr_ptr->ib_cm_handle = ib_cm_handle;
	/*
	 * Copy the remote address and private data out of the private_data
	 * payload and put them in a local structure
	 */
	cr_ptr->param.private_data = cr_ptr->private_data;
	cr_ptr->param.remote_ia_address_ptr =
	    (DAT_IA_ADDRESS_PTR)&cr_ptr->remote_ia_address;
	cr_ptr->param.remote_port_qual =
	    (DAT_PORT_QUAL) prd_ptr->hello_msg.hi_port;
	length = (DAT_COUNT) prd_ptr->hello_msg.hi_clen;
	cr_ptr->param.private_data_size = length;
	(void) dapl_os_memcpy(cr_ptr->private_data,
	    prd_ptr->private_data, length);
	switch (prd_ptr->hello_msg.hi_ipv) {
	case AF_INET:
		sv4 = (struct sockaddr_in *)&cr_ptr->remote_ia_address;
		sv4->sin_family = AF_INET;
		sv4->sin_port = prd_ptr->hello_msg.hi_port;
		sv4->sin_addr = prd_ptr->hello_msg.hi_v4ipaddr;
		break;
	case AF_INET6:
		sv6 = (struct sockaddr_in6 *)&cr_ptr->remote_ia_address;
		sv6->sin6_family = AF_INET6;
		sv6->sin6_port = prd_ptr->hello_msg.hi_port;
		sv6->sin6_addr = prd_ptr->hello_msg.hi_v6ipaddr;
		break;
	default:
		sadata = (uint8_t *)&cr_ptr->remote_ia_address;
		(void) dapl_os_memcpy(sadata, prd_ptr->hello_msg.hi_saaddr,
		    DAPL_ATS_NBYTES);
		break;
	}

	/* EP will be NULL unless RSP service point */
	ep_ptr = (DAPL_EP *) sp_ptr->ep_handle;

	if (sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG) {
		/*
		 * Never true for RSP connections
		 *
		 * Create an EP for the user. If we can't allocate an
		 * EP we are out of resources and need to tell the
		 * requestor that we cant help them.
		 */
		ia_ptr = sp_ptr->header.owner_ia;
		ep_ptr = dapl_ep_alloc(ia_ptr, NULL, DAT_FALSE);
		if (ep_ptr == NULL) {
			dapls_cr_free(cr_ptr);
			/* Invoking function will call dapls_ib_cm_reject() */
			return (DAT_INSUFFICIENT_RESOURCES);
		}
		/* Link the EP onto the IA */
		dapl_ia_link_ep(ia_ptr, ep_ptr);
	}

	cr_ptr->param.local_ep_handle = ep_ptr;

	if (ep_ptr != NULL) {
		/* Assign valid EP fields: RSP and PSP_PROVIDER_FLAG only */
		if (sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG) {
			ep_ptr->param.ep_state =
			    DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING;
		} else { /* RSP */
			dapl_os_assert(sp_ptr->header.handle_type ==
			    DAT_HANDLE_TYPE_RSP);
			ep_ptr->param.ep_state =
			    DAT_EP_STATE_PASSIVE_CONNECTION_PENDING;
		}
		ep_ptr->cm_handle = ib_cm_handle;
	}

	/* Post the event.  */
	/* assign sp_ptr to union to avoid typecast errors from compilers */
	sp_handle.psp_handle = (DAT_PSP_HANDLE)sp_ptr;
	dat_status = dapls_evd_post_cr_arrival_event(
	    evd_ptr,
	    DAT_CONNECTION_REQUEST_EVENT,
	    sp_handle,
	    (DAT_IA_ADDRESS_PTR)&sp_ptr->header.owner_ia->hca_ptr->hca_address,
	    sp_ptr->conn_qual,
	    (DAT_CR_HANDLE)cr_ptr);
	if (dat_status != DAT_SUCCESS) {
		dapls_cr_free(cr_ptr);
		(void) dapls_ib_reject_connection(ib_cm_handle,
		    IB_CME_LOCAL_FAILURE, sp_ptr);
		return (DAT_INSUFFICIENT_RESOURCES);
	}

	/* link the CR onto the SP so we can pick it up later */
	dapl_sp_link_cr(sp_ptr, cr_ptr);

	return (DAT_SUCCESS);
}


/*
 * dapli_get_sp_ep
 *
 * Passive side of a connection is now fully established. Clean
 * up resources and obtain the EP pointer associated with a CR in
 * the SP
 *
 * Input:
 * 	ib_cm_handle,
 * 	sp_ptr
 *
 * Output:
 *	none
 *
 * Returns
 * 	ep_ptr
 *
 */
DAPL_EP *
dapli_get_sp_ep(
	IN ib_cm_handle_t ib_cm_handle,
	IN DAPL_SP *sp_ptr,
	IN const ib_cm_events_t ib_cm_event)
{
	DAPL_CR		*cr_ptr;
	DAPL_EP		*ep_ptr;

	/*
	 * There are potentially multiple connections in progress. Need to
	 * go through the list and find the one we are interested
	 * in. There is no guarantee of order. dapl_sp_search_cr
	 * leaves the CR on the SP queue.
	 */
	cr_ptr = dapl_sp_search_cr(sp_ptr, ib_cm_handle);
	if (cr_ptr == NULL) {
		dapl_os_assert(0);
		return (NULL);
	}

	ep_ptr = (DAPL_EP *)cr_ptr->param.local_ep_handle;

	dapl_os_assert(!(DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) ||
	    ep_ptr->header.magic == DAPL_MAGIC_EP_EXIT);

	if (ib_cm_event == IB_CME_DISCONNECTED ||
	    ib_cm_event == IB_CME_DISCONNECTED_ON_LINK_DOWN) {
		/* Remove the CR from the queue */
		dapl_sp_remove_cr(sp_ptr, cr_ptr);
		/*
		 * Last event, time to clean up and dispose of the resource
		 */
		dapls_cr_free(cr_ptr);

		/*
		 * If this SP has been removed from service, free it
		 * up after the last CR is removed
		 */
		dapl_os_lock(&sp_ptr->header.lock);
		if (sp_ptr->listening != DAT_TRUE &&
		    sp_ptr->cr_list_count == 0 &&
		    sp_ptr->state != DAPL_SP_STATE_FREE) {
			dapl_dbg_log(DAPL_DBG_TYPE_CM,
			    "--> dapli_get_sp_ep! disconnect dump sp: %p \n",
			    sp_ptr);
			sp_ptr->state = DAPL_SP_STATE_FREE;
			dapl_os_unlock(&sp_ptr->header.lock);
			(void) dapls_ib_remove_conn_listener(sp_ptr->
			    header.owner_ia, sp_ptr);
			dapls_ia_unlink_sp((DAPL_IA *)sp_ptr->header.owner_ia,
			    sp_ptr);
			dapls_sp_free_sp(sp_ptr);
		} else {
			dapl_os_unlock(&sp_ptr->header.lock);
		}
	}
	return (ep_ptr);
}