OpenSolaris_b135/lib/udapl/udapl_tavor/common/dapl_ia_query.c

Compare this file to the similar file:
Show the results in this format: 

/*
 * 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_ia_query.c
 *
 * PURPOSE: Interface Adapter management
 * Description: Interfaces in this file are completely described in
 *		the DAPL 1.1 API, Chapter 6, section 2
 *
 * $Id: dapl_ia_query.c,v 1.20 2003/08/06 14:04:27 sjs2 Exp $
 */

#include "dapl.h"
#include "dapl_adapter_util.h"
#include "dapl_vendor.h"

/*
 * dapl_ia_query
 *
 * DAPL Requirements Version xxx, 6.2.1.3
 *
 * Provide the consumer with Interface Adapter and Provider parameters.
 *
 * Input:
 *	ia_handle
 *	ia_mask
 *	provider_mask
 *
 * Output:
 *	async_evd_handle
 *	ia_parameters
 *	provider_parameters
 *
 * Returns:
 * 	DAT_SUCCESS
 * 	DAT_INVALID_PARAMETER
 */
DAT_RETURN
dapl_ia_query(
	IN	DAT_IA_HANDLE			ia_handle,
	OUT	DAT_EVD_HANDLE			*async_evd_handle,
	IN	DAT_IA_ATTR_MASK		ia_attr_mask,
	OUT	DAT_IA_ATTR			*ia_attr,
	IN	DAT_PROVIDER_ATTR_MASK		provider_attr_mask,
	OUT	DAT_PROVIDER_ATTR		*provider_attr)
{
	DAPL_IA		*ia_ptr;
	DAT_RETURN	dat_status;
	struct evd_merge_type {
		DAT_BOOLEAN		array[6][6];
	} *evd_merge;
	int		i;
	int		j;

	dapl_dbg_log(DAPL_DBG_TYPE_API,
	    "dapl_ia_query (%p, %p, 0x%x, %p, 0x%x, %p)\n",
	    ia_handle,
	    async_evd_handle,
	    ia_attr_mask,
	    ia_attr,
	    provider_attr_mask,
	    provider_attr);

	ia_ptr = (DAPL_IA *)ia_handle;
	dat_status = DAT_SUCCESS;

	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
		dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
		    DAT_INVALID_HANDLE_IA);
		goto bail;
	}

	if (NULL != async_evd_handle) {
		*async_evd_handle = ia_ptr->async_error_evd;
	}

	if (ia_attr_mask & DAT_IA_ALL) {
		if (NULL == ia_attr) {
			dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
			    DAT_INVALID_ARG4);
			goto bail;
		}

		/*
		 * Obtain parameters from the HCA.  Protect against multiple
		 * IAs beating on the HCA at the same time.
		 */
		dat_status = dapls_ib_query_hca(ia_ptr->hca_ptr, ia_attr, NULL,
		    NULL, NULL);
		if (dat_status != DAT_SUCCESS) {
			goto bail;
		}
	}

	if (ia_attr_mask & ~DAT_IA_ALL) {
		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
		goto bail;
	}

	if (provider_attr_mask & DAT_PROVIDER_FIELD_ALL) {
		if (NULL == provider_attr) {
			dat_status = DAT_ERROR(DAT_INVALID_PARAMETER,
			    DAT_INVALID_ARG6);
			goto bail;
		}

		(void) dapl_os_strncpy(provider_attr->provider_name,
		    ia_ptr->header.provider->device_name,
		    DAT_NAME_MAX_LENGTH);
		provider_attr->provider_version_major	  = VN_PROVIDER_MAJOR;
		provider_attr->provider_version_minor	  = VN_PROVIDER_MINOR;
		provider_attr->dapl_version_major	  = DAT_VERSION_MAJOR;
		provider_attr->dapl_version_minor	  = DAT_VERSION_MINOR;
		provider_attr->lmr_mem_types_supported	  =
		    DAT_MEM_TYPE_VIRTUAL | DAT_MEM_TYPE_LMR;
#if VN_MEM_SHARED_VIRTUAL_SUPPORT > 0
		provider_attr->lmr_mem_types_supported	 |=
		    DAT_MEM_TYPE_SHARED_VIRTUAL;
#endif
		provider_attr->iov_ownership_on_return	  = DAT_IOV_CONSUMER;
		provider_attr->dat_qos_supported	  = DAT_QOS_BEST_EFFORT;
		provider_attr->completion_flags_supported =
		    DAT_COMPLETION_DEFAULT_FLAG;
		provider_attr->is_thread_safe		  = DAT_FALSE;
		provider_attr->max_private_data_size	  =
		    DAPL_CONSUMER_MAX_PRIVATE_DATA_SIZE;
		provider_attr->supports_multipath	  = DAT_TRUE;
		provider_attr->ep_creator		  =
		    DAT_PSP_CREATES_EP_NEVER;
		provider_attr->optimal_buffer_alignment   =
		    DAT_OPTIMAL_ALIGNMENT;
		provider_attr->num_provider_specific_attr = 0;
		provider_attr->srq_supported = DAT_TRUE;
		/*
		 * 0x000 no watermarks support
		 * 0x001 low watermark support
		 * 0x010 soft high watermark support
		 * 0x100 hard high watermark support
		 */
		provider_attr->srq_watermarks_supported = 0x00;
		provider_attr->srq_ep_pz_difference_supported = DAT_FALSE;
		/*
		 * 0x01 available_dto_count
		 * 0x10 outstanding_dto_count
		 */
		provider_attr->srq_info_supported = 0x10;
		/*
		 * 0x00 no ep recv info support
		 * 0x01 nbufs_allocated returned from dat_ep_recv_query
		 * 0x10 bufs_alloc_span returned from dat_ep_recv_query
		 */
		provider_attr->ep_recv_info_supported = 0;
		/*
		 * we want the application to use the lmr_sync_rdma
		 * as a programming model and thus always true from the
		 * provider perspective. dat_registry will return success
		 * to consumers on platforms with coherent memory
		 */
		provider_attr->lmr_sync_req = DAT_TRUE;
		provider_attr->dto_async_return_guaranteed = DAT_FALSE;
		provider_attr->rdma_write_for_rdma_read_req = DAT_FALSE;
		provider_attr->provider_specific_attr	  = NULL;
		/*
		 * Set up evd_stream_merging_supported options. Note there is
		 * one bit per allowable combination, using the ordinal
		 * position of the DAT_EVD_FLAGS as positions in the
		 * array. e.g.
		 * [0][0] is DAT_EVD_SOFTWARE_FLAG | DAT_EVD_SOFTWARE_FLAG,
		 * [0][1] is DAT_EVD_SOFTWARE_FLAG | DAT_EVD_CR_FLAG, and
		 * [2][4] is DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG
		 *
		 * Most combinations are true, so initialize the array that way.
		 * Then finish by resetting the bad combinations.
		 */

		evd_merge = (struct evd_merge_type *)&provider_attr->
		    evd_stream_merging_supported[0][0];
		for (i = 0; i < 6; i++) {
			for (j = 0; j < 6; j++) {
				if (j == 5 || i == 5) {
					/* DAT_EVD_ASYNC_FLAG is disallowed */
					evd_merge->array[i][j] = DAT_FALSE;
				} else {
					evd_merge->array[i][j] = DAT_TRUE;
				}
			}
		}
	}

bail:
	dapl_dbg_log(DAPL_DBG_TYPE_RTN,
	    "dapl_ia_query () returns 0x%x\n",
	    dat_status);

	return (dat_status);
}

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