udapl_tavor/common/dapl_ia_query.c

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