xref: /onnv-gate/usr/src/lib/udapl/libdat/common/udat.c (revision 8580:85b678a652f5)

/*
 * 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: udat.c
 *
 * PURPOSE: DAT Provider and Consumer registry functions.
 *
 * $Id: udat.c,v 1.13 2003/08/20 14:28:40 hobie16 Exp $
 */

#include <dat/udat.h>
#include <dat/dat_registry.h> /* Provider API function prototypes */

#include "dat_dr.h"
#include "dat_init.h"
#include "dat_osd.h"
#ifndef	DAT_NO_STATIC_REGISTRY
#include "dat_sr.h"
#endif


#define	UDAT_IS_BAD_POINTER(p) (NULL == (p))

/*
 *
 * Internal Function Declarations
 *
 */

DAT_BOOLEAN
udat_check_state(void);


/*
 *
 * External Function Definitions
 *
 */


/*
 *
 * Provider API
 *
 */


/*
 * Function: dat_registry_add_provider
 */

DAT_RETURN
dat_registry_add_provider(
	IN DAT_PROVIDER			*provider,
	IN const DAT_PROVIDER_INFO	*provider_info)
{
	DAT_DR_ENTRY 		entry;

	dat_os_dbg_print(DAT_OS_DBG_TYPE_PROVIDER_API,
	    "DAT Registry: dat_registry_add_provider() called\n");

	if (UDAT_IS_BAD_POINTER(provider)) {
		return (DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG1));
	}

	if (UDAT_IS_BAD_POINTER(provider_info)) {
		return (DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2));
	}

	if (DAT_FALSE == udat_check_state()) {
		return (DAT_ERROR(DAT_INVALID_STATE, 0));
	}

	entry.ref_count = 0;
	entry.ia_open_func = provider->ia_open_func;
	entry.info = *provider_info;

	return (dat_dr_insert(provider_info, &entry));
}


/*
 * Function: dat_registry_remove_provider
 */

DAT_RETURN
dat_registry_remove_provider(
	IN DAT_PROVIDER 		*provider,
	IN  const DAT_PROVIDER_INFO	*provider_info)
{
	dat_os_dbg_print(DAT_OS_DBG_TYPE_PROVIDER_API,
	    "DAT Registry: dat_registry_remove_provider() called\n");

	if (UDAT_IS_BAD_POINTER(provider)) {
		return (DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG1));
	}

	if (DAT_FALSE == udat_check_state()) {
		return (DAT_ERROR(DAT_INVALID_STATE, 0));
	}

	return (dat_dr_remove(provider_info));
}


/*
 *
 * Consumer API
 *
 */

/*
 * Function: dat_ia_open
 */

DAT_RETURN
dat_ia_openv(
	IN	const DAT_NAME_PTR	name,
	IN	DAT_COUNT		async_event_qlen,
	INOUT	DAT_EVD_HANDLE		*async_event_handle,
	OUT	DAT_IA_HANDLE		*ia_handle,
	IN	DAT_UINT32		dapl_major,
	IN	DAT_UINT32		dapl_minor,
	IN	DAT_BOOLEAN		thread_safety)
{
	DAT_IA_OPEN_FUNC		ia_open_func;
	DAT_PROVIDER_INFO 		info;
	DAT_RETURN 			status;
	DAT_OS_SIZE 			len;
#define	RO_AWARE_PREFIX	"RO_AWARE_"
	boolean_t			ro_aware_client;
	const char			*_name = name;

	dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
	    "DAT Registry: dat_ia_open() called\n");

	if (UDAT_IS_BAD_POINTER(_name)) {
		return (DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG1));
	}

	len = dat_os_strlen(_name);

	if (DAT_NAME_MAX_LENGTH <= len) {
		return (DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG1));
	}

	if (UDAT_IS_BAD_POINTER(ia_handle)) {
		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
	}

	if (DAT_FALSE == udat_check_state()) {
		return (DAT_ERROR(DAT_INVALID_STATE, 0));
	}

	/* Find out if this is an RO aware client and if so, strip the prefix */
	ro_aware_client =
	    (strncmp(RO_AWARE_PREFIX, _name, sizeof (RO_AWARE_PREFIX) - 1) ==
	    0);

	/* strip off the prefix from the provider's name if present */
	if (ro_aware_client) {
		_name = _name + sizeof (RO_AWARE_PREFIX) - 1;
		len -= sizeof (RO_AWARE_PREFIX) - 1;
	}

	(void) dat_os_strncpy(info.ia_name, _name, len);
	info.ia_name[len] = '\0';

	info.dapl_version_major = dapl_major;
	info.dapl_version_minor = dapl_minor;
	info.is_thread_safe = thread_safety;

	/*
	 * Since DAT allows providers to be loaded by either the static
	 * registry or explicitly through OS dependent methods, do not
	 * return an error if no providers are loaded via the static registry.
	 * Don't even bother calling the static registry if DAT is compiled
	 * with no static registry support.
	 */

#ifndef DAT_NO_STATIC_REGISTRY
	(void) dat_sr_provider_open(&info);
#endif

	status = dat_dr_provider_open(&info, &ia_open_func);
	if (status != DAT_SUCCESS) {
		dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
		    "DAT Registry: dat_ia_open() provider information "
		    "for IA name %s not found in dynamic registry\n",
		    _name);
		return (status);
	}

	return (*ia_open_func)((const DAT_NAME_PTR) _name,
	    async_event_qlen,
	    async_event_handle,
	    ia_handle,
	    ro_aware_client);
}


/*
 * Function: dat_ia_close
 */

DAT_RETURN
dat_ia_close(
	IN DAT_IA_HANDLE	ia_handle,
	IN DAT_CLOSE_FLAGS	ia_flags)
{
	DAT_PROVIDER	*provider;
	DAT_PROVIDER_ATTR   provider_attr = {0};
	DAT_RETURN 		status;
	const char 		*ia_name;

	dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
	    "DAT Registry: dat_ia_close() called\n");

	if (UDAT_IS_BAD_POINTER(ia_handle)) {
		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
	}

	if (DAT_FALSE == udat_check_state()) {
		return (DAT_ERROR(DAT_INVALID_STATE, 0));
	}

	provider = DAT_HANDLE_TO_PROVIDER(ia_handle);
	ia_name = provider->device_name;

	if (DAT_SUCCESS != (status = dat_ia_query(ia_handle,
	    NULL,
	    0,
	    NULL,
	    DAT_PROVIDER_FIELD_ALL,
	    &provider_attr))) {
		dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
		    "DAT Registry: query function for %s provider failed\n",
		    ia_name);
	} else if (DAT_SUCCESS != (status =
	    (*provider->ia_close_func)(ia_handle, ia_flags))) {
		dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
		    "DAT Registry: close function for %s provider failed\n",
		    ia_name);
	} else {
		DAT_PROVIDER_INFO info;
		DAT_OS_SIZE len;

		len = dat_os_strlen(ia_name);

		dat_os_assert(len <= DAT_NAME_MAX_LENGTH);

		(void) dat_os_strncpy(info.ia_name, ia_name, len);
		info.ia_name[len] = '\0';

		info.dapl_version_major = provider_attr.dapl_version_major;
		info.dapl_version_minor = provider_attr.dapl_version_minor;
		info.is_thread_safe = provider_attr.is_thread_safe;

		status = dat_dr_provider_close(&info);
		if (DAT_SUCCESS != status) {
			dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
			    "DAT Registry: dynamic registry unable to close "
			    "provider for IA name %s\n",
			    ia_name);
		}

#ifndef DAT_NO_STATIC_REGISTRY
		status = dat_sr_provider_close(&info);
		if (DAT_SUCCESS != status) {
			dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
			    "DAT Registry: static registry unable to close "
			    "provider for IA name %s\n",
			    ia_name);
		}
#endif
	}

	return (status);
}


/*
 * Function: dat_registry_list_providers
 */

DAT_RETURN
dat_registry_list_providers(
	IN  DAT_COUNT   		max_to_return,
	    OUT DAT_COUNT   		*entries_returned,
	    OUT	DAT_PROVIDER_INFO 	*(dat_provider_list[]))
{
	DAT_RETURN	dat_status;

	dat_status = DAT_SUCCESS;
	dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
	    "DAT Registry: dat_registry_list_providers() called\n");

	if (DAT_FALSE == udat_check_state()) {
			return (DAT_ERROR(DAT_INVALID_STATE, 0));
	}

	if ((UDAT_IS_BAD_POINTER(entries_returned))) {
		return (DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2));
	}

	if (0 != max_to_return && (UDAT_IS_BAD_POINTER(dat_provider_list))) {
		return (DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3));
	}

	if (0 == max_to_return) {
		/*
		 * the user is allowed to call with max_to_return set to zero.
		 * in which case we simply return (in *entries_returned) the
		 * number of providers currently installed.  We must also
		 * (per spec) return an error
		 */
#ifndef DAT_NO_STATIC_REGISTRY
		(void) dat_sr_size(entries_returned);
#else
		(void) dat_dr_size(entries_returned);
#endif
		return (DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG1));
	} else {
#ifndef DAT_NO_STATIC_REGISTRY
		dat_status = dat_sr_list(max_to_return,
		    entries_returned,
		    dat_provider_list);
#else
		dat_status = dat_dr_list(max_to_return,
		    entries_returned,
		    dat_provider_list);
#endif
	}
	return (dat_status);
}


/*
 *
 * Internal Function Definitions
 *
 */


/*
 * Function: udat_check_state
 */

/*
 * This function returns TRUE if the DAT registry is in a state capable
 * of handling DAT API calls and false otherwise.
 */

DAT_BOOLEAN
udat_check_state(void)
{
	DAT_MODULE_STATE 		state;
	DAT_BOOLEAN 		status;

	state = dat_module_get_state();

	if (DAT_MODULE_STATE_UNINITIALIZED == state) {
		dat_init();
		status = DAT_TRUE;
	} else if (DAT_MODULE_STATE_DEINITIALIZED == state) {
		status = DAT_FALSE;
	} else {
		status = DAT_TRUE;
	}

	return (status);
}


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