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

/*
 *
 * MODULE: dapl_cookie.c
 *
 * PURPOSE: Manage CQE cookie structures
 *
 * The DAPL spec requires that all a cookies passed to a posting operation
 * be returned in the operation's corresponding completion.
 *
 * Implementing this feature is complicated by the user's ability to
 * suppress event generation for specific operations. When these operations
 * complete successfully, the provider does not have an easy way to
 * deallocate resources devoted to storing context data for these operations.
 *
 * To support this feature, a pool of memory is allocated up front large
 * enough to hold cookie data for the maximum number of operations possible
 * on an endpoint.
 *
 * Two pieces of information are maintained to manage cookie allocation:
 *
 * head index : index of next unallocated cookie
 * tail index : index of last unallocated cookie
 *
 * Each cookie store its index in this memory pool.
 *
 * When an event is received, the index stored in the event's cookie will be
 * used to update the tail. This will implicitly deallocate all of the cookies
 * "between" the old tail and the new tail.
 *
 * The implementation relies on the following assumptions:
 *
 * - there can be only 1 thread in dat_ep_post_send(), dat_ep_post_rdma_write(),
 *   dat_ep_post_rdma_read(), or dat_rmr_bind() at a time, therefore
 *   dapls_cb_get() does not need to be thread safe when manipulating
 *   request data structures.
 *
 * - there can be only 1 thread in dat_ep_post_recv(), therefore
 *   dapls_cb_get() does not need to be thread safe when manipulating
 *   receive data structures.
 *
 * - there can be only 1 thread generating completions for a given EP's request
 *   opeartions, therefore dapls_cb_put() does not need to be thread safe when
 *   manipulating request data structures.
 *
 * - there can be only 1 thread generating completions for a given EP's receive
 *   opeartions therefore dapls_cb_put() does not need to be thread safe when
 *   manipulating receive data structures.
 *
 * - completions are delivered in order
 *
 * $Id: dapl_cookie.c,v 1.13 2003/06/16 17:53:32 sjs2 Exp $
 */

#include "dapl_cookie.h"
#include "dapl_ring_buffer_util.h"

/*
 *
 * Function Prototypes
 *
 */

DAT_RETURN
dapls_cb_get(
	DAPL_COOKIE_BUFFER		*buffer,
	DAPL_COOKIE 		**cookie_ptr);

DAT_RETURN
dapls_cb_put(
	DAPL_COOKIE_BUFFER		*buffer,
	DAPL_COOKIE 		*cookie);


/*
 *
 * Function Definitions
 *
 */

/*
 * dapls_cb_create
 *
 * Given a DAPL_COOKIE_BUFFER, allocate and initialize memory for
 * the data structure.
 *
 * Input:
 *	buffer		pointer to DAPL_COOKIE_BUFFER
 *	ep		endpoint to associate with cookies
 *	size		number of elements to allocate & manage
 *
 * Output:
 *	none
 *
 * Returns:
 *	DAT_SUCCESS
 *	DAT_INSUFFICIENT_RESOURCES
 *
 */
DAT_RETURN
dapls_cb_create(
	IN	DAPL_COOKIE_BUFFER	*buffer,
	IN	void			*queue,
	IN	DAPL_COOKIE_QUEUE_TYPE	type,
	IN	DAT_COUNT		size)

{
	DAT_COUNT 			i;

	/*
	 * allocate one additional entry so that the tail
	 * can always point at an empty location
	 */
	size++;
	/* round up to multiple of 2 */
	i = 2;
	while (size > i) {
	    i <<= 1;
	}
	size = i;

	buffer->pool = dapl_os_alloc(size * sizeof (DAPL_COOKIE));
	if (NULL != buffer->pool) {
		buffer->pool_size = size;
		buffer->head = 0;
		buffer->tail = 0;

		for (i = 0; i < size; i++) {
			buffer->pool[i].index = i;
			buffer->pool[i].queue_type = type;
			if (type == DAPL_COOKIE_QUEUE_EP) {
				buffer->pool[i].queue.ep = queue;
			} else {
				buffer->pool[i].queue.srq = queue;
			}
		}

		return (DAT_SUCCESS);
	} else {
		return (DAT_INSUFFICIENT_RESOURCES);
	}
}

/*
 * dapls_cb_resize
 *
 * Given a DAPL_COOKIE_BUFFER, reallocate a larger buffer and initialize
 * memory for the data structure from an old one
 *
 * Input:
 *	curr_buffer     pointer to existing DAPL_COOKIE_BUFFER
 *	new_size	new number of elements to allocate & manage,
 *			has to be > current buffer's size
 *	new_buffer	pointer to the newly allocated cookie buffer
 *
 * Output:
 *	none
 *
 * Returns:
 *	DAT_SUCCESS
 *	DAT_INVALID_PARAMETER
 *	DAT_INSUFFICIENT_RESOURCES
 *
 */
DAT_RETURN
dapls_cb_resize(
	IN	DAPL_COOKIE_BUFFER	*curr_buffer,
	IN	DAT_COUNT		new_size,
	IN	DAPL_COOKIE_BUFFER	*new_buffer)
{
	int		index;
	DAPL_ATOMIC	head;
	DAPL_ATOMIC	tail;

	DAT_RETURN	dat_return;

	if (new_size < curr_buffer->pool_size) {
		return (DAT_ERROR(DAT_INVALID_PARAMETER, 0));
	}

	/*
	 * create a new cookie buffer, the queue type and queue ptr remain the
	 * same as the curr_buffer so use the values from there
	 */
	dat_return = dapls_cb_create(new_buffer,
	    curr_buffer->pool[0].queue.ptr, curr_buffer->pool[0].queue_type,
	    new_size);

	if (dat_return != DAT_SUCCESS) {
		return (dat_return);
	}

	/* copy all the free cookies to the new buffer */
	head = curr_buffer->head;
	tail = curr_buffer->tail;
	index = 0;
	while (head != tail) {
		new_buffer->pool[index] = curr_buffer->pool[head];
		head = (head + 1) % curr_buffer->pool_size;
		index++;
	}
	new_buffer->head = 0;
	new_buffer->tail = index;

	return (DAT_SUCCESS);
}

/*
 * dapls_cb_free
 *
 * Free the data structure
 *
 * Input:
 *	buffer		pointer to DAPL_COOKIE_BUFFER
 *
 * Output:
 *	none
 *
 * Returns:
 *	none
 *
 */
void
dapls_cb_free(
	IN  DAPL_COOKIE_BUFFER	*buffer)
{
	if (NULL != buffer->pool) {
		dapl_os_free(buffer->pool, buffer->pool_size *
		    sizeof (DAPL_COOKIE));
	}
}


/*
 * dapls_cb_get
 *
 * Remove an entry from the buffer
 *
 * Input:
 *	buffer		pointer to DAPL_COOKIE_BUFFER
 *
 * Output:
 *      cookie_ptr 	pointer to pointer to cookie
 *
 * Returns:
 *	DAT_SUCCESS
 * 	DAT_INVALID_PARAMETER
 *	DAT_INSUFFICIENT_RESOURCES
 *
 */
DAT_RETURN
dapls_cb_get(
	IN  DAPL_COOKIE_BUFFER	*buffer,
	OUT DAPL_COOKIE 		**cookie_ptr)
{
	DAT_RETURN	dat_status;
	DAT_COUNT	new_head;

	dapl_os_assert(NULL != cookie_ptr);

	new_head = (buffer->head + 1) % buffer->pool_size;

	if (new_head == buffer->tail) {
		dat_status = DAT_INSUFFICIENT_RESOURCES;
		goto bail;
	} else {
		buffer->head = new_head;
		*cookie_ptr = &buffer->pool[buffer->head];
		dat_status = DAT_SUCCESS;
	}

bail:
	return (dat_status);
}

/*
 * dapls_cb_put
 *
 * Add entry(s) to the buffer
 *
 * Input:
 *	buffer		pointer to DAPL_COOKIE_BUFFER
 *      cookie 		pointer to cookie
 *
 * Output:
 *	entry		entry removed from the ring buffer
 *
 * Returns:
 *	DAT_SUCCESS
 *	DAT_INSUFFICIENT_EMPTY
 *
 */
DAT_RETURN
dapls_cb_put(
	IN  DAPL_COOKIE_BUFFER	*buffer,
	IN  DAPL_COOKIE 	*cookie)
{
	buffer->tail = cookie->index;

	return (DAT_SUCCESS);
}

/*
 * dapls_rmr_cookie_alloc
 *
 * Allocate an RMR Bind cookie
 *
 * Input:
 *	buffer		pointer to DAPL_COOKIE_BUFFER
 *      rmr 		rmr to associate with the cookie
 *      user_cookie     user's cookie data
 *
 * Output:
 *	cookie_ptr	pointer to pointer to allocated cookie
 *
 * Returns:
 *	DAT_SUCCESS
 *	DAT_INSUFFICIENT_EMPTY
 *
 */
DAT_RETURN
dapls_rmr_cookie_alloc(
	IN DAPL_COOKIE_BUFFER	*buffer,
	IN DAPL_RMR		*rmr,
	IN DAT_RMR_COOKIE	user_cookie,
	OUT DAPL_COOKIE 	**cookie_ptr)
{
	DAPL_COOKIE 		*cookie;
	DAT_RETURN		dat_status;

	if (DAT_SUCCESS != dapls_cb_get(buffer, &cookie)) {
		*cookie_ptr = NULL;
		dat_status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
		    DAT_RESOURCE_MEMORY);
		goto bail;
	}

	dat_status = DAT_SUCCESS;
	cookie->type = DAPL_COOKIE_TYPE_RMR;
	cookie->val.rmr.rmr = rmr;
	cookie->val.rmr.cookie = user_cookie;
	*cookie_ptr =  cookie;

bail:
	return (dat_status);
}


/*
 * dapls_dto_cookie_alloc
 *
 * Allocate a DTO cookie
 *
 * Input:
 *	buffer		pointer to DAPL_COOKIE_BUFFER
 * 	type 		DTO type
 *      user_cookie     user's cookie data
 *
 * Output:
 *	cookie_ptr	pointer to pointer to allocated cookie
 *
 * Returns:
 *	DAT_SUCCESS
 *	DAT_INSUFFICIENT_EMPTY
 *
 */
DAT_RETURN
dapls_dto_cookie_alloc(
	IN DAPL_COOKIE_BUFFER	*buffer,
	IN DAPL_DTO_TYPE	type,
	IN DAT_DTO_COOKIE	user_cookie,
	OUT DAPL_COOKIE		**cookie_ptr)
{
	DAPL_COOKIE 		*cookie;

	if (DAT_SUCCESS != dapls_cb_get(buffer, &cookie)) {
		*cookie_ptr = NULL;
		return (DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
		    DAT_RESOURCE_MEMORY));
	}
	cookie->type = DAPL_COOKIE_TYPE_DTO;
	cookie->val.dto.type = type;
	cookie->val.dto.cookie = user_cookie;
	cookie->val.dto.size = 0;

	*cookie_ptr = cookie;
	return (DAT_SUCCESS);
}

void
dapls_cookie_dealloc(
	IN  DAPL_COOKIE_BUFFER	*buffer,
	IN 	DAPL_COOKIE	*cookie)
{
	buffer->tail = cookie->index;
}