/*
 * 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) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/ksynch.h>
#include <sys/stream.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/vio_util.h>

static int vio_pool_cleanup_retries = 10;	/* Max retries to free pool */
static int vio_pool_cleanup_delay = 10000;	/* 10ms */

/*
 * Create a pool of mblks from which future vio_allocb() requests
 * will be serviced.
 *
 * NOTE: num_mblks has to non-zero and a power-of-2
 *
 * Returns
 *	0 on success
 *	EINVAL if num_mblks is zero or not a power of 2.
 *	ENOSPC if the pool could not be created due to alloc failures.
 */
int
vio_create_mblks(uint64_t num_mblks, size_t mblk_size, uint8_t *mblk_datap,
    vio_mblk_pool_t **poolp)
{
	vio_mblk_pool_t		*vmplp;
	vio_mblk_t		*vmp;
	uint8_t			*datap;
	int			i;
	int			rv;

	if (!(num_mblks) || (!ISP2(num_mblks))) {
		*poolp = 0;
		return (EINVAL);
	}

	vmplp = kmem_zalloc(sizeof (*vmplp), KM_SLEEP);
	vmplp->quelen = num_mblks;
	vmplp->quemask = num_mblks - 1; /* expects quelen is power-of-2 */
	vmplp->mblk_size = mblk_size;

	mutex_init(&vmplp->hlock, NULL, MUTEX_DRIVER,
	    DDI_INTR_PRI(DDI_INTR_SOFTPRI_DEFAULT));
	mutex_init(&vmplp->tlock, NULL, MUTEX_DRIVER,
	    DDI_INTR_PRI(DDI_INTR_SOFTPRI_DEFAULT));

	vmplp->basep = kmem_zalloc(num_mblks * sizeof (vio_mblk_t), KM_SLEEP);
	if (mblk_datap == NULL) {
		vmplp->datap = kmem_zalloc(num_mblks * mblk_size, KM_SLEEP);
	} else {
		vmplp->datap = mblk_datap;
		vmplp->flag |= VMPL_FLAG_CLIENT_DATA;
	}
	vmplp->nextp = NULL;

	/* create a queue of pointers to free vio_mblk_t's */
	vmplp->quep = kmem_zalloc(vmplp->quelen *
	    sizeof (vio_mblk_t *), KM_SLEEP);
	vmplp->head = 0;
	vmplp->tail =  0;

	for (i = 0, datap = vmplp->datap; i < num_mblks; i++) {

		vmp = &(vmplp->basep[i]);
		vmp->vmplp = vmplp;
		vmp->datap = datap;
		vmp->reclaim.free_func = vio_freeb;
		vmp->reclaim.free_arg = (caddr_t)vmp;
		vmp->mp = desballoc(vmp->datap, mblk_size, BPRI_MED,
		    &vmp->reclaim);

		if (vmp->mp == NULL) {
			/* reset tail */
			vmplp->tail = vmplp->head;

			/*
			 * vio_destroy_mblks() frees mblks that have been
			 * allocated so far and then destroys the pool.
			 */
			rv = vio_destroy_mblks(vmplp);
			ASSERT(rv == 0);

			*poolp = NULL;
			return (ENOSPC);
		}

		vmp->index = i;
		vmp->state = VIO_MBLK_FREE;

		/* put this vmp on the free stack */
		vmplp->quep[vmplp->tail] = vmp;
		vmplp->tail = (vmplp->tail + 1) & vmplp->quemask;

		datap += mblk_size;
	}

	*poolp = vmplp;
	return (0);
}

/*
 * Destroy the pool of mblks. This can only succeed when
 * all allocated mblks have been returned to the pool.
 *
 * It is up to the caller to ensure that no further mblks are
 * requested from the pool after destroy has been invoked.
 *
 * Returns 0 on success, EINVAL if handle is invalid, or
 * EBUSY if not all mblks reclaimed yet.
 */
int
vio_destroy_mblks(vio_mblk_pool_t *vmplp)
{
	uint64_t	i;
	uint64_t	num_mblks;
	vio_mblk_t	*vmp;
	int		pool_cleanup_retries = 0;


	if (vmplp == NULL)
		return (EINVAL);

	/*
	 * We can only destroy the pool once all the mblks have
	 * been reclaimed.
	 */
	do {
		if (vmplp->head == vmplp->tail) {
			break;
		}

		/* some mblks still in use */
		drv_usecwait(vio_pool_cleanup_delay);
	} while (++pool_cleanup_retries < vio_pool_cleanup_retries);

	if (vmplp->head != vmplp->tail) {
		return (EBUSY);
	}

	num_mblks = vmplp->quelen;

	/*
	 * Set pool flag to tell vio_freeb() which is invoked from freeb(),
	 * that it is being called in the context of vio_destroy_mblks().
	 * This results in freeing only mblk_t and dblk_t structures for
	 * each mp. The associated data buffers are freed below as one big
	 * chunk through kmem_free(vmplp->datap).
	 */
	vmplp->flag |= VMPL_FLAG_DESTROYING;
	for (i = 0; i < num_mblks; i++) {
		vmp = &(vmplp->basep[i]);
		/*
		 * It is possible that mblks have been allocated only upto
		 * a certain index and the entire quelen has not been
		 * initialized. This might happen due to desballoc() failure
		 * while creating the pool. The below check handles this
		 * condition.
		 */
		if (vmp->mp != NULL)
			freeb(vmp->mp);
	}
	vmplp->flag &= ~(VMPL_FLAG_DESTROYING);

	kmem_free(vmplp->basep, num_mblks * sizeof (vio_mblk_t));
	if ((vmplp->flag & VMPL_FLAG_CLIENT_DATA) == 0) {
		kmem_free(vmplp->datap, num_mblks * vmplp->mblk_size);
	}
	kmem_free(vmplp->quep, num_mblks * sizeof (vio_mblk_t *));

	mutex_destroy(&vmplp->hlock);
	mutex_destroy(&vmplp->tlock);

	kmem_free(vmplp, sizeof (*vmplp));

	return (0);
}

/*
 * Allocate a vio_mblk from the free pool if one is available.
 * Otherwise returns NULL.
 */
vio_mblk_t *
vio_allocb(vio_mblk_pool_t *vmplp)
{
	vio_mblk_t	*vmp = NULL;
	uint32_t	head;

	mutex_enter(&vmplp->hlock);
	head = (vmplp->head + 1) & vmplp->quemask;
	if (head != vmplp->tail) {
		/* we have free mblks */
		vmp = vmplp->quep[vmplp->head];
		vmplp->head = head;
		ASSERT(vmp->state == VIO_MBLK_FREE);
		vmp->state = VIO_MBLK_BOUND;
	}
	mutex_exit(&vmplp->hlock);

	return (vmp);
}

/*
 * Return a mblk to the free pool. Invoked when the upper IP
 * layers do freemsg() etc on the mblk they were passed.
 */
void
vio_freeb(void *arg)
{
	vio_mblk_t	*vmp = (vio_mblk_t *)arg;
	vio_mblk_pool_t	*vmplp = vmp->vmplp;

	if (vmplp->flag & VMPL_FLAG_DESTROYING) {
		/*
		 * This flag indicates that freeb() is being called from
		 * vio_destroy_mblks().
		 * We don't need to alloc a new mblk_t/dblk_t pair for
		 * this data buffer, return from here and the data buffer
		 * itself will be freed in vio_destroy_mblks().
		 */
		return;
	}

	vmp->mp = desballoc(vmp->datap, vmplp->mblk_size,
	    BPRI_MED, &vmp->reclaim);
	vmp->state = VIO_MBLK_FREE;

	mutex_enter(&vmplp->tlock);
	vmplp->quep[vmplp->tail] = vmp;
	vmplp->tail = (vmplp->tail + 1) & vmplp->quemask;
	mutex_exit(&vmplp->tlock);
}


/*
 * This function searches the given mblk pool for mblks that are in the
 * BOUND state and moves them to the FREE state. Note that only clients that
 * are operating in RxDringData mode use this function. This allows such
 * clients to reclaim buffers that are provided to the peer as shared memory,
 * before calling vio_destroy_mblks(). We don't need this in other cases
 * as the buffer is locally managed.
 */
void
vio_clobber_pool(vio_mblk_pool_t *vmplp)
{
	uint64_t	num_mblks = vmplp->quelen;
	uint64_t	i;
	vio_mblk_t	*vmp;

	mutex_enter(&vmplp->hlock);
	mutex_enter(&vmplp->tlock);
	for (i = 0; i < num_mblks; i++) {
		vmp = &(vmplp->basep[i]);
		if ((vmp->state & VIO_MBLK_BOUND) != 0) {
			/* put this vmp on the free stack */
			vmp->state = VIO_MBLK_FREE;
			ASSERT(vmplp->tail != vmplp->head);
			vmplp->quep[vmplp->tail] = vmp;
			vmplp->tail = (vmplp->tail + 1) & vmplp->quemask;
		}
	}
	mutex_exit(&vmplp->tlock);
	mutex_exit(&vmplp->hlock);
}

/*
 * Create a multiple pools of mblks from which future vio_allocb()
 * or vio_multipool_allocb() requests will be serviced.
 *
 * Arguments:
 *	vmultip -- A pointer to vio_multi_pool_t structure.
 *	num_pools -- Number of the pools.
 *	... -- Variable arguments consisting a list of buffer sizes for
 *		each pool and list of number of buffers for each pool.
 *
 * NOTE: The restrictions of vio_create_mblks() apply to this interface also.
 *
 * Returns 0 on success or an error returned by vio_create_mblks().
 */
int
vio_init_multipools(vio_multi_pool_t *vmultip, int num_pools, ...)
{
	int		i;
	int		status;
	char		*tbuf;
	va_list		vap;
	vio_mblk_pool_t *fvmp = NULL;

	/*
	 * Allocate memory for all of the following in one allocation.
	 * 	bufsz_tbl -- sizeof (uint32_t) * num_pools
	 * 	nbuf_tbl  -- sizeof (uint32_t) * num_pools
	 *	vmpp	  -- sizeof (vio_mblk_pool_t *) * numpools
	 */
	vmultip->tbsz = (sizeof (uint32_t) * num_pools) +
	    (sizeof (uint32_t) * num_pools) +
	    (sizeof (vio_mblk_pool_t *) * num_pools);
	tbuf = kmem_zalloc(vmultip->tbsz, KM_SLEEP);
	vmultip->bufsz_tbl = (uint32_t *)tbuf;
	vmultip->nbuf_tbl = (uint32_t *)(tbuf +
	    (sizeof (uint32_t) * num_pools));
	vmultip->vmpp = (vio_mblk_pool_t **)(tbuf +
	    (sizeof (uint32_t) * num_pools * 2));
	vmultip->num_pools = num_pools;

	/* initialize the array first */
	va_start(vap, num_pools);
	for (i = 0; i < num_pools; i++) {
		vmultip->bufsz_tbl[i] = va_arg(vap, uint32_t);
	}
	for (i = 0; i < num_pools; i++) {
		vmultip->nbuf_tbl[i] = va_arg(vap, uint32_t);
	}
	va_end(vap);

	for (i = 0; i < vmultip->num_pools; i++) {
		status = vio_create_mblks(vmultip->nbuf_tbl[i],
		    vmultip->bufsz_tbl[i], NULL, &vmultip->vmpp[i]);
		if (status != 0) {
			vio_destroy_multipools(vmultip, &fvmp);
			/* We expect to free the pools without failure here */
			ASSERT(fvmp == NULL);
			return (status);
		}
	}
	return (0);
}

/*
 * Destroy the multiple pools of mblks. This can only succeed when
 * all allocated mblks have been returned to the pool.
 *
 * If a pool of mblks couldn't be destroyed, then the failed vio_mblk_pool_t
 * pointers are returned via th fvmp list. Its the caller's
 * responsibility to check this list and free them later at an appropriate
 * time with vio_destroy_mblks().
 *
 * Arguments:
 *	vmultip -- A pointer to vio_multi_pool_t structure.
 *	fvmp -- A list in which the pools that couldn't be destroyed are
 *		returned.
 */
void
vio_destroy_multipools(vio_multi_pool_t *vmultip, vio_mblk_pool_t **fvmp)
{
	int i;
	vio_mblk_pool_t *vmp;

	for (i = 0; i < vmultip->num_pools; i++) {
		if ((vmp = vmultip->vmpp[i]) != NULL) {
			if (vio_destroy_mblks(vmp)) {
				/*
				 * if we cannot reclaim all mblks, then
				 * return the pool in the failed vmp
				 * list(fvmp).
				 */
				vmp->nextp =  *fvmp;
				*fvmp = vmp;
			}
		}
	}
	if (vmultip->tbsz != 0)
		kmem_free(vmultip->bufsz_tbl, vmultip->tbsz);
	vmultip->bufsz_tbl = NULL;
	vmultip->nbuf_tbl = NULL;
	vmultip->vmpp = NULL;
	vmultip->num_pools = 0;
	vmultip->tbsz = 0;
}


/*
 * Allocate an vio_mblk from one of the free pools, but tries the pool that
 * best fits size requested first.
 */
vio_mblk_t *
vio_multipool_allocb(vio_multi_pool_t *vmultip, size_t size)
{
	int i;
	vio_mblk_t *vmp = NULL;

	/* Try allocating any size that fits */
	for (i = 0; i < vmultip->num_pools; i++) {
		if (size > vmultip->bufsz_tbl[i]) {
			continue;
		}
		vmp = vio_allocb(vmultip->vmpp[i]);
		if (vmp != NULL) {
			break;
		}
	}
	return (vmp);
}

/*
 * -----------------------------------------------------------------------------
 * LDoms versioning functions
 *
 * Future work: the version negotiating code in the various VIO drivers
 * could be made common and placed here.
 */

/*
 * Description:
 *	This function checks to see if the supplied version tuple (major,minor)
 *	is supported by the version 'ver', negotiated during the handshake
 *	between the client and the server (ver).
 *
 * Assumption:
 *	This function assumes that backward compatability is not broken in
 *	newer minor versions of the protocol (e.g. v1.5 & v1.1 support v1.0)
 *
 * Return Value:
 *	B_TRUE		- The (major,minor) version is supported
 *	B_FALSE		- not supported
 */
boolean_t
vio_ver_is_supported(vio_ver_t ver, uint16_t major, uint16_t minor)
{
	if ((ver.major == major) && (ver.minor >= minor))
		return (B_TRUE);

	return (B_FALSE);
}