xref: /illumos-gate/usr/src/lib/mpapi/libmpapi/common/mpapi.c (revision 55fea89dcaa64928bed4327112404dcb3e07b79f)

/******************************************************************************
 *
 * Description
 * mpapi.c - Implements Multipath Management API Version 1.0
 *
 * License:
 *  The contents of this file are subject to the SNIA Public License
 *  Version 1.1 (the "License"); you may not use this file except in
 *  compliance with the License. You may obtain a copy of the License at
 *
 *  http://mp-mgmt-api.sourceforge.net
 *
 *  Software distributed under the License is distributed on an "AS IS"
 *  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 *  the License for the specific language governing rights and limitations
 *  under the License.
 *
 * The Original Code is  SNIA iSCSI Management API and Multipath Management
 *	API header files.
 *
 * The Initial Developer of the Original Code is:
 *	Benjamin F. Kuo Troika Networks, Inc. (benk@troikanetworks.com)
 *	David Dillard	VERITAS Software(david.dillard@veritas.com)
 *	Jeff Ding 	Adaptec, Inc. (jding@corp.adaptec.com)
 *      Hyon Kim        Sun Microsystems(hyon.kim@sun.com)
 *
 * Contributor(s):
 *	Paul von Behren Sun Microsystems(paul.vonbehren@sun.com)
 *
 ******************************************************************************
 *
 *   Changes:
 *  1/15/2005	Implemented SNIA MP API specification 1.0
 *  10/11/2005
 * 		- License location was specified in the header comment.
 *  	    	- validate_object() routine was updated per the latest
 *		  specification.
 *  		- is_zero_oid() routine was added.
 *  		- MP_GetObjectType() was updated with validate_object().
 *  		- pplist argument checking added in MP_GetMultipathLus().
 *  		- Corrected typo in MP_GetTaregetPortGroupProperties()
 *  		- MP_RegisterForObjectPropertyChanges() was updated with
 *		  is_zero_oid() routine.
 *  		- MP_DeregisterForObjectPropertyChanges() was updated with
 *		  is_zero_oid() routine.
 *		- MP_RegisterForObjectVisibilityChanges() was updated with
 *		  is_zero_oid() routine.
 *		- MP_DeregisterForObjectVisibilityChanges() was updated with
 *		  is_zero_oid() routine.
 *  		- Added stat() check in MP_RegisterPlugin() to validate the
 *		  the given plugin file name.
 *  		- Made MP_DeregisterPlugin() return MP_STATUS_UNKNOWN_FN
 *		  to mach the specification description.
 ******************************************************************************
 */

#include <sys/sem.h>
#include <dlfcn.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <time.h>
#include <pthread.h>
#include "mpapi.h"
#include "mpapi-sun.h"
#include "mpapi-plugin.h"

#define LIBRARY_SUPPORTED_MP_VERSION	1
#define LIBRARY_IMPLEMENTATION_VERSION	L"1.0.0"
#define LIBRARY_VENDOR			L"Sun Microsystems Inc."

#define LIBRARY_FILE_NAME               "libMPAPI.so"


MPPLUGININFO_T	plugintable[MP_MAX_NUM_PLUGINS];
pthread_mutex_t mp_lib_mutex = PTHREAD_MUTEX_INITIALIZER;

static int	number_of_plugins = -1;


void InitLibrary();
void ExitLibrary();
static int lock_register(int fd, int cmd, int type, off_t offset, int whence,
	    off_t len);
static int search_line(MP_CHAR *buf, size_t buflen, MP_CHAR *srch_id,
	    size_t id_len, int *write_offset, int *bytes_left);
static int is_zero_oid(MP_OID);

/**
 ******************************************************************************
 *
 * Validate the oid.
 *
 * - Return MP_STATUS_OBJECT_NOT_FOUND when no plugin is found or the ownerId
 *      of input OID is not found.
 * - Return MP_STATUS_INVALID_OBJECT_TYPE when no plugin is found or
 *      the type of input OID is not one of legitimate types defined SNIA
 *      Multipath Management spec.
 * - Return MP_STATUS_INVALID_PARAMETER when the type of input OID is
 *	legitimate but its object type doesn't match with the object type
 *      argument.
 * - Otherwise return MP_STATUS_SUCCESS.
 *
 ******************************************************************************
 */
MP_STATUS validate_object(MP_OID obj, MP_OBJECT_TYPE objType,
    MP_UINT32 flag)
{

    if ((number_of_plugins == 0) ||
	(obj.ownerId > number_of_plugins || obj.ownerId <= 0)) {
	return (MP_STATUS_OBJECT_NOT_FOUND);
    } else if (obj.objectType < 0 || obj.objectType > MP_OBJECT_TYPE_MAX) {
	return (MP_STATUS_INVALID_OBJECT_TYPE);
    } else if (obj.objectType == MP_OBJECT_TYPE_PLUGIN) {
	if (obj.objectSequenceNumber != 0) {
	    return (MP_STATUS_OBJECT_NOT_FOUND);
	}
    }

    if (flag == MP_OBJECT_TYPE_MATCH) {
    	if (obj.objectType != objType) {
	    return (MP_STATUS_INVALID_PARAMETER);
        }
    }
    return (MP_STATUS_SUCCESS);
}

/**
 ******************************************************************************
 *
 * Check if an oid is ZERO_OID or not.
 *
 * - Return 1 if the input OID is ZERO_OID
 *
 * - Return 0 if not.
 *
 ******************************************************************************
 */
static int is_zero_oid(MP_OID oid)
{

    if ((oid.objectType != MP_OBJECT_TYPE_UNKNOWN) || (oid.ownerId != 0) ||
	(oid.objectSequenceNumber != 0)) {
	return (0);
    }

    return (1);
}

/**
 ******************************************************************************
 *
 * Initialize by loading plugin libraries and calling Initialize routine.
 * Note: The build of libMPAPI.so should include a linker option to make this
 *	 routine executed when it is loaded.
 *
 * - This routine bypasses a plugin library if it is not found.
 * - The implementation of this routine is based on configuration file
 *   /etc/mpapi.conf that contains a list of plugin libraries.
 *
 ******************************************************************************
 */
void InitLibrary()
{
	FILE *mpconf;
	int fd_mpconf;
	MP_WCHAR fullline[MAX_LINE_SIZE]; /* line read in from mpapi.conf */
	MP_WCHAR name[MAX_NAME_SIZE]; 	/* Read in from file mpapi.conf */
	char path[MAX_NAME_SIZE]; 	/* Read in from file mpapi.conf */
	char systemPath[MAX_NAME_SIZE], mpConfFilePath[MAX_NAME_SIZE];
	MP_WCHAR *charPtr;
	MP_WCHAR *sol;
	struct stat	stat_buf;

	MP_UINT32 i = 0;	/* index for plugin table */

	if(number_of_plugins != -1) {
		return;
	}

	(void) pthread_mutex_lock(&mp_lib_mutex);

	number_of_plugins = 0;

	/* Open configuration file from known location */
	strncpy(mpConfFilePath, "/etc/mpapi.conf", MAX_NAME_SIZE);

	if ((fd_mpconf = open(mpConfFilePath, O_RDONLY)) < 0) {
		(void) pthread_mutex_unlock(&mp_lib_mutex);
		return;
	}

	if (lock_register(fd_mpconf, F_SETLKW, F_RDLCK, 0, SEEK_SET, 0) < 0) {
		close(fd_mpconf);
		(void) pthread_mutex_unlock(&mp_lib_mutex);
		return;
	}

	if ((mpconf = fdopen(fd_mpconf, "r")) == NULL) {
		lock_register(fd_mpconf, F_SETLK, F_UNLCK, 0, SEEK_SET, 0);
		close(fd_mpconf);
		(void) pthread_mutex_unlock(&mp_lib_mutex);
		return;
	}

	/* Read in each line and load library */
	while ((mpconf != NULL) &&
	    (charPtr = fgetws(fullline, MAX_LINE_SIZE, mpconf))) {
	    if ((*charPtr != L'#') && (*charPtr != L'\n')) {
		/* Take out the '\n' */
		if ((charPtr = wcschr(fullline, L'\n')) != NULL)
		    *charPtr = L'\0';

		charPtr = fullline;
		/* remove leading blank or taps. */
		while ((fullline[0] == L' ') || (fullline[0] == L'\t'))
			charPtr++;

		sol = charPtr;

		/*
		 * look for first tab or space.
		 */
		if ((charPtr = wcschr(fullline, L'\t')) == NULL)
		    charPtr = wcschr(fullline, L' ');

		/* Set Null termination for library name if found */
		if (charPtr != NULL) {
		    *charPtr++ = L'\0';
		    wcsncpy(name, sol, MAX_NAME_SIZE);
			/* Skip space and tab until the next character found */
		    while ((*charPtr == L' ') || (*charPtr == L'\t'))
			charPtr++;
		} else {
		    continue;	/* May be invalid entry */
		}

		/* Copy library name and path */
		wcstombs(path, charPtr, MAX_NAME_SIZE);

		/*
		 * Continue to the next line if library name or path is
		 * invalid
		 */
		if ((wcslen(name) == 0) ||
			(strlen(path) == 0))
		    continue;

		/* Load the plugin now */
		if (stat(path, &stat_buf) != -1) {
		    plugintable[i].hdlPlugin = dlopen(path, RTLD_LAZY);
		} else {
		    continue;
		}

		if (plugintable[i].hdlPlugin != NULL) {
		    InitializeFn PassFunc;

                    wcsncpy(plugintable[i].pluginName,
                        name, MAX_NAME_SIZE);
                    strncpy(plugintable[i].pluginPath,
                        path, MAX_NAME_SIZE);

		    plugintable[i].ownerId = i + 1;

		    PassFunc = (InitializeFn)
			 dlsym(plugintable[i].hdlPlugin, "Initialize");
		    if (PassFunc != NULL) {
			(void) PassFunc(plugintable[i].ownerId);
		    }

		    i++;
		}
	    }
	}

	if (lock_register(fd_mpconf, F_SETLK, F_UNLCK, 0, SEEK_SET, 0) < 0) {
	    fclose(mpconf);
	    close(fd_mpconf);
	    (void) pthread_mutex_unlock(&mp_lib_mutex);
	    return;
	}
	fclose(mpconf);
	close(fd_mpconf);

	number_of_plugins = i;
	(void) pthread_mutex_unlock(&mp_lib_mutex);
}

/**
 ******************************************************************************
 *
 * Exit by calling Terminate routine of plugin libraries.
 *
 * Note: The build of libMPAPI.so should include a linker option to make this
 *	 routine executed when it is unloaded.
 *
 ******************************************************************************
 */
void ExitLibrary()
{
    MP_UINT32 i, j;

    if(number_of_plugins == -1)
        return;

    (void) pthread_mutex_lock(&mp_lib_mutex);
    for (i = 0; i < number_of_plugins; i++) {
        if (plugintable[i].hdlPlugin != NULL) {
        TerminateFn ExitPassFunc;

        ExitPassFunc = (TerminateFn)
            dlsym(plugintable[i].hdlPlugin, "Terminate");

        if (ExitPassFunc != NULL) {
            ExitPassFunc();
        }

        /* Unload plugin from memory */
        dlclose(plugintable[i].hdlPlugin);
        }
    }

    number_of_plugins = -1;

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    (void) pthread_mutex_destroy(&mp_lib_mutex);
}

/**
 ******************************************************************************
 *
 * Gets the properties of the MP API library that is being used.
 *
 * @param pProps
 *  A pointer to an @ref MP_LIBRARY_PROPERTIES structure allocated by
 *  the caller.  On successful return this structure will contain the
 *  properties of the MP library.
 *
 * @return An MP_STATUS indicating if the operation was successful or
 *  if an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *  Returned if the library properties were successfully returned.
 *
 * @retval MP_STATUS_INVALID_PARAMETER Returned if @a pProps is NULL or
 *  specifies a memory area to which data cannot be written.
 *
 ******************************************************************************
 */
MP_STATUS MP_GetLibraryProperties(
    MP_LIBRARY_PROPERTIES *pProps)
{
    char mpPath[MAX_NAME_SIZE];

    if(pProps == NULL) {
        return MP_STATUS_INVALID_PARAMETER;
    }

    /* Fill in properties */
    if (mbstowcs(pProps->buildTime, BUILD_TIME, 256) !=
	strlen(BUILD_TIME)) {
	return (MP_STATUS_INVALID_PARAMETER);
    }
    pProps->supportedMpVersion = LIBRARY_SUPPORTED_MP_VERSION;

    wcsncpy(pProps->implementationVersion,
	LIBRARY_IMPLEMENTATION_VERSION, MAX_NAME_SIZE);
    wcsncpy(pProps->vendor, LIBRARY_VENDOR, MAX_NAME_SIZE);

    snprintf(pProps->fileName, MAX_NAME_SIZE, "%s",
	LIBRARY_FILE_NAME);

    return MP_STATUS_SUCCESS;
}


/**
 ******************************************************************************
 *
 * Gets a list of the object IDs of all currently loaded plugins.
 *
 * @param ppList A pointer to a pointer to an @ref MP_OID_LIST.  On successful
 *  return this will contain a pointer to an @ref MP_OID_LIST
 *  which contains the object IDs of all of the plugins currently loaded
 *  by the library.
 * @return An MP_STATUS indicating if the operation was successful or if
 * an error
 *              occurred.
 * @retval MP_SUCCESS Returned if the plugin ID list was successfully returned.
 * @retval MP_STATUS_INVALID_PARAMETER Returned if @a ppList is NULL or
 * specifies a memory area to which data cannot be written.
 *
 ******************************************************************************
 */
MP_STATUS MP_GetPluginOidList(
    MP_OID_LIST **ppList)
{
    MP_UINT32  i;

    if (ppList == NULL)
        return (MP_STATUS_INVALID_PARAMETER);

    (void) pthread_mutex_lock(&mp_lib_mutex);

    if (number_of_plugins == 0) {
        *ppList = (MP_OID_LIST*)calloc(1, sizeof(MP_OID_LIST));
    } else {
        *ppList = (MP_OID_LIST*)calloc(1,
        sizeof(MP_OID_LIST) + (number_of_plugins - 1)* sizeof(MP_OID) );
    }

    if ((*ppList) == NULL) {
    	(void) pthread_mutex_unlock(&mp_lib_mutex);
        return (MP_STATUS_INSUFFICIENT_MEMORY);
    }

    (*ppList)->oidCount = number_of_plugins;

    if (number_of_plugins != 0) {
        for (i = 0; i < number_of_plugins; i++) {
        (*ppList)->oids[i].objectType = MP_OBJECT_TYPE_PLUGIN;
        (*ppList)->oids[i].ownerId = plugintable[i].ownerId;
        (*ppList)->oids[i].objectSequenceNumber = 0;
        }
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return MP_STATUS_SUCCESS;
}

/**
 *******************************************************************************
 *
 * Gets the properties of the specified vendor plugin.
 *
 * @param  oid
 *         The ID of the plugin whose properties are being retrieved.
 *
 * @param  pProps
 *         A pointer to an @ref MP_PLUGIN_PROPERTIES structure allocated by
 *         the caller.  On successful return this will contain the properties
 *         of the plugin specified by pluginOid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if an
 *         error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned if the plugin properties were successfully returned.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *         Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *         Returned if oid has an owner that is not currently known to
 *     the system.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *         Returned if 'pProps' is NULL or specifies a memory area to
 *         which data cannot be written.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetPluginProperties(
    MP_OID pluginOid,
    MP_PLUGIN_PROPERTIES *pProps)
{
    MP_GetPluginPropertiesPluginFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if(pProps == NULL)
        return (MP_STATUS_INVALID_PARAMETER);

    if ((status = validate_object(pluginOid, MP_OBJECT_TYPE_PLUGIN,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = pluginOid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetPluginPropertiesPluginFn)
        dlsym(plugintable[index].hdlPlugin, "MP_GetPluginPropertiesPlugin");

        if (PassFunc != NULL) {
            status = PassFunc(pProps);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return status;
}

/**
 *******************************************************************************
 *
 * Gets the object ID for the plugin associated with the specified object ID.
 *
 * @param  oid
 *         The object ID of an object that has been received from a previous
 *         library call.
 *
 * @param  pPluginOid
 *         A pointer to an MP_OID structure allocated by the caller.  On
 *         successful return this will contain the object ID of the plugin
 *         associated with the object specified by @a objectId.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *          Returned if the associated plugin ID was successfully returned.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid does not specify a plugin that is currently known to
 *     the system.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *          Returned if 'oid' specifies an object not owned by a plugin or
 *     if pPluginOid is NULL or specifies a memory area to which data
 *     cannot be written.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *         Returned if 'oid' specifies an object with an invalid type.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetAssociatedPluginOid(
    MP_OID objectId,
    MP_OID *pPluginId)
{
    MP_UINT32 i;
    MP_STATUS status;

    if (pPluginId == NULL)
        return (MP_STATUS_INVALID_PARAMETER);

    if ((status = validate_object(objectId, 0, MP_OBJECT_TYPE_ANY)) !=
            MP_STATUS_SUCCESS) {
        return (status);
    }

    pPluginId->objectType = MP_OBJECT_TYPE_PLUGIN;
    pPluginId->ownerId = objectId.ownerId;
    pPluginId->objectSequenceNumber = 0;

    return (MP_STATUS_SUCCESS);
}

/**
 *******************************************************************************
 *
 * Gets the object type of an initialized object ID.
 *
 * @param  oid
 *         The object ID of an object that has been received from a previous
 *         library call.
 *
 * @param  pObjectType
 *         A pointer to an MP_OBJECT_TYPE variable allocated by the caller.
 *         On successful return this will contain the object type of oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or
 *         if an error occurred.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *      Returned if oid has an owner that is not currently known to
 *      the system.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetObjectType(
    MP_OID oid,
    MP_OBJECT_TYPE *pObjectType)
{
    MP_STATUS status;

    if (pObjectType == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, 0, MP_OBJECT_TYPE_ANY))
	!= MP_STATUS_SUCCESS) {
        return (status);
    }

    *pObjectType = oid.objectType;
    return MP_STATUS_SUCCESS;
}

/**
 *******************************************************************************
 *
 * Gets a list of the object IDs of all the device product properties
 *       associated with this plugin.
 *
 * @param  oid
 *         The object ID of plugin.
 *
 * @param  ppList
 *      A pointer to a pointer to an MP_OID_LIST structure.
 *      On a successful return, this will contain a pointer to
 *      an MP_OID_LIST that contains the object IDs of all the device
 *      product descriptors associated with the specified plugin.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppList pointer passed as placeholder for holding
 *      the device product list is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *         Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *         Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the API is not supported.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetDeviceProductOidList(
    MP_OID oid,
    MP_OID_LIST **ppList)
{
    MP_GetDeviceProductOidListPluginFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (ppList == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetDeviceProductOidListPluginFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetDeviceProductOidListPlugin");
        if (PassFunc != NULL) {
	    status = PassFunc(ppList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return status;
}

/**
 *******************************************************************************
 *
 * Gets the device product properties of the specified plugin oid.
 *
 * @param  oid
 *         The object ID of the plugin.
 *
 * @param  ppProps
 *      A pointer to a pointer to an MP_DEVICE_PRODUCT_PROPERTIES structure
 *      allocated by the caller. On successful return it will contain
 *      a pointer to an MP_DEVICE_PRODUCT_PROPERTIES structure allocated
 *      by the library.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppProps pointer passed as placeholder for holding
 *      the device product properties is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *         Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *         Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the API is not supported.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetDeviceProductProperties(
        MP_OID oid,
        MP_DEVICE_PRODUCT_PROPERTIES *pProps)
{
    MP_GetDeviceProductPropertiesFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (pProps == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_DEVICE_PRODUCT,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetDeviceProductPropertiesFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetDeviceProductProperties");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, pProps);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return status;
}

/**
 *******************************************************************************
 *
 * Gets a list of the object IDs of all the initiator ports associated
 * with this plugin.
 *
 * @param  oid
 *         The object ID of plugin.
 *
 * @param  ppList
 *      A pointer to a pointer to an MP_OID_LIST structure.
 *      On a successful return, this will contain a pointer to
 *      an MP_OID_LIST that contains the object IDs of all the initiator
 *      ports associated with the specified plugin.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppList pointer passed as placeholder for holding
 *      the initiator port list is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the API is not supported.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetInitiatorPortOidList(
        MP_OID oid,
        MP_OID_LIST **ppList)
{
    MP_GetInitiatorPortOidListPluginFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (ppList == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetDeviceProductOidListPluginFn)
        dlsym(plugintable[index].hdlPlugin, "MP_GetInitiatorPortOidListPlugin");

        if (PassFunc != NULL) {
	    status = PassFunc(ppList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets the properties of the specified initiator port.
 *
 * @param  oid
 *         The object ID of the initiator port.
 *
 * @param  pProps
 *      A pointer to an MP_INITIATOR_PORT_PROPERTIES structure
 *      allocated by the caller. On successful return, this structure
 *      will contain the properties of the port specified by oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pProps is NULL or specifies a memory area to
 *      which data cannot be written.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetInitiatorPortProperties(
        MP_OID oid,
        MP_INITIATOR_PORT_PROPERTIES *pProps)
{
    MP_GetInitiatorPortPropertiesFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (pProps == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_INITIATOR_PORT,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetInitiatorPortPropertiesFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetInitiatorPortProperties");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, pProps);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return status;
}

/**
 *******************************************************************************
 *
 * Gets a list of multipath logical units associated to a plugin.
 *
 * @param  oid
 *         The object ID of plugin.
 *
 * @param  ppList
 *      A pointer to a pointer to an MP_OID_LIST structure.
 *      On a successful return, this will contain a pointer to
 *      an MP_OID_LIST that contains the object IDs of all the multipath
 *      logical units associated with the specified plugin.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppList pointer passed as placeholder for holding
 *      the multipath logical unit list is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the API is not supported.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetMultipathLus(
        MP_OID oid,
        MP_OID_LIST **ppList)
{
    MP_UINT32 index;
    MP_STATUS status;

    if (ppList == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
	MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_DEVICE_PRODUCT,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
	if (oid.objectType == MP_OBJECT_TYPE_PLUGIN) {
	    MP_GetMultipathLusPluginFn PassFunc;
	    PassFunc = (MP_GetMultipathLusPluginFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_GetMultipathLusPlugin");

	    if (PassFunc != NULL) {
		status = PassFunc(ppList);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else if (oid.objectType == MP_OBJECT_TYPE_DEVICE_PRODUCT) {
	    MP_GetMultipathLusDevProdFn PassFunc;
	    PassFunc = (MP_GetMultipathLusDevProdFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_GetMultipathLusDevProd");

	    if (PassFunc != NULL) {
		status = PassFunc(oid, ppList);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else {
	    status = MP_STATUS_INVALID_PARAMETER;
	}
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}


/**
 *******************************************************************************
 *
 * Gets the properties of the specified logical unit.
 *
 * @param  oid
 *         The object ID of the multipath logical unit.
 *
 * @param  pProps
 *      A pointer to an MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES structure
 *      allocated by the caller. On successful return, this structure
 *      will contain the properties of the port specified by oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pProps is NULL or specifies a memory area to
 *      which data cannot be written.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetMPLogicalUnitProperties(
        MP_OID oid,
        MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES *pProps)
{
    MP_GetMPLogicalUnitPropertiesFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (pProps == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetMPLogicalUnitPropertiesFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetMPLogicalUnitProperties");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, pProps);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets a list of the object IDs of all the path logical units associated
 * with the specified multipath logical unit, initiator port, or target port.
 *
 * @param  oid
 *         The object ID of multipath logical unit, initiator port, or
 *     target port.
 *
 * @param  ppList
 *      A pointer to a pointer to an MP_OID_LIST structure.
 *      On a successful return, this will contain a pointer to
 *      an MP_OID_LIST that contains the object IDs of all the mp path
 *      logical units associated with the specified OID.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppList pointer passed as placeholder for holding
 *      the device product list is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *      Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetAssociatedPathOidList(
        MP_OID oid,
        MP_OID_LIST **ppList)
{
    MP_GetAssociatedPathOidListFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (ppList == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_INITIATOR_PORT,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_TARGET_PORT,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetAssociatedPathOidListFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetAssociatedPathOidList");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, ppList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets the properties of the specified path logical unit.
 *
 * @param  oid
 *         The object ID of the path logical unit.
 *
 * @param  pProps
 *      A pointer to an MP_PATH_LOGICAL_UNIT_PROPERTIES structure
 *      allocated by the caller. On successful return, this structure
 *      will contain the properties of the port specified by oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pProps is NULL or specifies a memory area to
 *      which data cannot be written.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetPathLogicalUnitProperties(
        MP_OID oid,
        MP_PATH_LOGICAL_UNIT_PROPERTIES *pProps)
{
    MP_GetPathLogicalUnitPropertiesFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (pProps == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_PATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetPathLogicalUnitPropertiesFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetPathLogicalUnitProperties");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, pProps);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets a list of the object IDs of all the target port group associated
 * with the specified multipath logical unit.
 *
 * @param  oid
 *         The object ID of the multiple logical unit.
 *
 * @param  ppList
 *      A pointer to a pointer to an MP_OID_LIST structure.
 *      On a successful return, this will contain a pointer to
 *      an MP_OID_LIST that contains the object IDs of all the target
 *      port group associated with the specified multipath logical unit.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppList pointer passed as placeholder for holding
 *      the target port group list is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 *
 *******************************************************************************
 */
MP_STATUS MP_GetAssociatedTPGOidList(
        MP_OID oid,
        MP_OID_LIST **ppList)
{
    MP_GetAssociatedTPGOidListFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (ppList == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetAssociatedTPGOidListFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetAssociatedTPGOidList");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, ppList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets the properties of the specified target port group.
 *
 * @param  oid
 *         The object ID of the target port group.
 *
 * @param  pProps
 *      A pointer to an MP_TARGET_PORT_GROUP_PROPERTIES structure
 *      allocated by the caller. On successful return, this structure
 *      will contain the properties of the port specified by oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pProps is NULL or specifies a memory area to
 *      which data cannot be written.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetTargetPortGroupProperties(
        MP_OID oid,
        MP_TARGET_PORT_GROUP_PROPERTIES *pProps)
{
    MP_GetTargetPortGroupPropertiesFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (pProps == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_TARGET_PORT_GROUP,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetTargetPortGroupPropertiesFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetTargetPortGroupProperties");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, pProps);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets a list of multipath logical units associated with the specific target
 *  port group.
 *
 * @param  oid
 *         The object ID of the target port group.
 *
 * @param  ppList
 *      A pointer to a pointer to an MP_OID_LIST structure.
 *      On a successful return, this will contain a pointer to
 *      an MP_OID_LIST that contains the object IDs of all the multipath
 *      logical units associated with the specified target port group.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppList pointer passed as placeholder for holding
 *      the multipath logical unit list is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 *******************************************************************************
 */
MP_STATUS MP_GetMPLuOidListFromTPG(
        MP_OID oid,
        MP_OID_LIST **ppList)
{
    MP_GetMPLuOidListFromTPGFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (ppList == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_TARGET_PORT_GROUP,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetMPLuOidListFromTPGFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetMPLuOidListFromTPG");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, ppList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets a list of the object IDs of all the proprietary load balance
 * algorithms associated with this plugin.
 *
 * @param  oid
 *         The object ID of the plugin.
 *
 * @param  ppList
 *      A pointer to a pointer to an MP_OID_LIST structure.
 *      On a successful return, this will contain a pointer to
 *      an MP_OID_LIST that contains the object IDs of all the proprietary
 *      load balance algorithms associated with the specified plugin.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppList pointer passed as placeholder for holding
 *      the proprietary load balance oid list is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the API is not supported.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetProprietaryLoadBalanceOidList(
        MP_OID oid,
        MP_OID_LIST **ppList)
{
    MP_GetProprietaryLoadBalanceOidListPluginFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (ppList == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetProprietaryLoadBalanceOidListPluginFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetProprietaryLoadBalanceOidListPlugin");

        if (PassFunc != NULL) {
	    status = PassFunc(ppList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets the properties of the specified load balance properties structure.
 *
 * @param  oid
 *         The object ID of the load balance properties structure.
 *
 * @param  pProps
 *      A pointer to an MP_LOAD_BALANCE_PROPRIETARY_TYPE structure
 *      allocated by the caller. On successful return, this structure
 *      will contain the properties of the proprietary load balance algorithm
 *	specified by oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pProps is NULL or specifies a memory area to
 *      which data cannot be written.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetProprietaryLoadBalanceProperties (
        MP_OID oid,
        MP_PROPRIETARY_LOAD_BALANCE_PROPERTIES *pProps)
{
    MP_GetProprietaryLoadBalancePropertiesFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (pProps == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_PROPRIETARY_LOAD_BALANCE,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetProprietaryLoadBalancePropertiesFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetProprietaryLoadBalanceProperties");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, pProps);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets a list of the object IDs of the target ports in the specified target
 * port group.
 *
 * @param  oid
 *         The object ID of the target port group.
 *
 * @param  ppList
 *      A pointer to a pointer to an MP_OID_LIST structure.
 *      On a successful return, this will contain a pointer to
 *      an MP_OID_LIST that contains the object IDs of all the target ports
 *      associated with the specified target port group.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if ppList pointer passed as placeholder for holding
 *      the multipath logical unit list is found to be invalid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the plugin for the specified oid is not found.
 *
 * @retval MP_STATUS_INSUFFICIENT_MEMORY
 *      Returned when memory allocation failure occurs
 *
 *******************************************************************************
 */
MP_STATUS MP_GetTargetPortOidList(
        MP_OID oid,
        MP_OID_LIST **ppList)
{
    MP_GetTargetPortOidListFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (ppList == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_TARGET_PORT_GROUP,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetTargetPortOidListFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetTargetPortOidList");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, ppList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Gets the properties of the specified target port.
 *
 * @param  oid
 *         The object ID of the target port.
 *
 * @param  pProps
 *      A pointer to an MP_TARGET_PORT_PROPERTIES structure
 *      allocated by the caller. On successful return, this structure
 *      will contain the properties of the port specified by oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pProps is NULL or specifies a memory area to
 *      which data cannot be written.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_GetTargetPortProperties(
        MP_OID oid,
        MP_TARGET_PORT_PROPERTIES *pProps)
{
    MP_GetTargetPortPropertiesFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (pProps == NULL)
        return MP_STATUS_INVALID_PARAMETER;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_TARGET_PORT,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_GetTargetPortPropertiesFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_GetTargetPortProperties");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, pProps);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}


/**
 *******************************************************************************
 *
 * Assign a multipath logical unit to a target port group.
 *
 * @param  tpgOid
 *      An MP_TARGET_PORT_GROUP oid. The target port group currently in
 *      active access state that the administrator would like the LU
 *      assigned to.
 *
 * @param  luOid
 *      An MP_MULTIPATH_LOGICAL_UNIT oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned when luOid is not associated with tpgOid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_AssignLogicalUnitToTPG(
        MP_OID tpgOid,
        MP_OID luOid)
{
    MP_AssignLogicalUnitToTPGFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (luOid.ownerId != tpgOid.ownerId) {
        return (MP_STATUS_INVALID_PARAMETER);
    }

    if ((status = validate_object(tpgOid, MP_OBJECT_TYPE_TARGET_PORT_GROUP,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    if ((status = validate_object(luOid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = tpgOid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_AssignLogicalUnitToTPGFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_AssignLogicalUnitToTPG");

        if (PassFunc != NULL) {
            status = PassFunc(tpgOid, luOid);
        } else {
            status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Manually override the path for a logical unit. The path exclusively used to
 * access the logical unit until cleared.
 *
 * @param  logicalUnitOid
 *      The object ID of the multipath logical unit.
 *
 * @param  pathOid
 *      The object ID of the path logical unit.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if the oid of the object is not valid
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the implementation does not support the API
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_PATH_NONOPERATIONAL
 *          Returned when the driver cannot communicate through selected path.
 *
 *******************************************************************************
 */
MP_STATUS MP_SetOverridePath(
    MP_OID logicalUnitOid,
    MP_OID pathOid)
{
    MP_SetOverridePathFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if ((status = validate_object(logicalUnitOid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }
    if ((status = validate_object(pathOid, MP_OBJECT_TYPE_PATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = pathOid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_SetOverridePathFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_SetOverridePath");

        if (PassFunc != NULL) {
	    status = PassFunc(logicalUnitOid, pathOid);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Cancel a path override and re-enable load balancing.
 *
 * @param  luOid
 *         An MP_MULTIPATH_LOGICAL_UNIT oid.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if MP_MULTIPATH_LOGICAL_UNIT with the luOid is not found.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *          Returned if oid has an owner that is not currently known to
 *      the system.
 *
 *******************************************************************************
 */
MP_STATUS MP_CancelOverridePath(
        MP_OID luOid)
{
    MP_CancelOverridePathFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if ((status = validate_object(luOid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = luOid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_CancelOverridePathFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_CancelOverridePath");

        if (PassFunc != NULL) {
	    status = PassFunc(luOid);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Enables Auto-failback.
 *
 * @param  oid
 *      The oid of the plugin.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if oid is NULL or specifies a memory area that is not
 *	a valid plugin oid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_EnableAutoFailback(
    MP_OID oid)
{
    MP_UINT32 index;
    MP_STATUS status;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
	MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
	if (oid.objectType == MP_OBJECT_TYPE_PLUGIN) {
	    MP_EnableAutoFailbackPluginFn PassFunc;
	    PassFunc = (MP_EnableAutoFailbackPluginFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_EnableAutoFailbackPlugin");

	    if (PassFunc != NULL) {
		status = PassFunc();
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else if (oid.objectType == MP_OBJECT_TYPE_MULTIPATH_LU) {
	    MP_EnableAutoFailbackLuFn PassFunc;
	    PassFunc = (MP_EnableAutoFailbackLuFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_EnableAutoFailbackLu");

	    if (PassFunc != NULL) {
		status = PassFunc(oid);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else {
	    status = MP_STATUS_INVALID_PARAMETER;
	}
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Enables Auto-probing.
 *
 * @param  oid
 *      The oid of the plugin or the multipath logical unit.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if oid is NULL or specifies a memory area that is not
 *      a valid plugin oid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_EnableAutoProbing(
    MP_OID oid)
{
    MP_UINT32 index;
    MP_STATUS status;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
	MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
	if (oid.objectType == MP_OBJECT_TYPE_PLUGIN) {
	    MP_EnableAutoProbingPluginFn PassFunc;
	    PassFunc = (MP_EnableAutoProbingPluginFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_EnableAutoProbingPlugin");

	    if (PassFunc != NULL) {
		status = PassFunc();
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else if (oid.objectType == MP_OBJECT_TYPE_MULTIPATH_LU) {
	    MP_EnableAutoProbingLuFn PassFunc;
	    PassFunc = (MP_EnableAutoProbingLuFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_EnableAutoProbingLu");

	    if (PassFunc != NULL) {
		status = PassFunc(oid);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else {
	    status = MP_STATUS_INVALID_PARAMETER;
	}
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Disables Auto-failback.
 *
 * @param  oid
 *      The oid of the plugin.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if oid is NULL or specifies a memory area that is not
 *      a valid plugin oid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_DisableAutoFailback(
    MP_OID oid)
{
    MP_UINT32 index;
    MP_STATUS status;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
	MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
	if (oid.objectType == MP_OBJECT_TYPE_PLUGIN) {
	    MP_DisableAutoFailbackPluginFn PassFunc;
	    PassFunc = (MP_DisableAutoFailbackPluginFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_DisableAutoFailbackPlugin");

	    if (PassFunc != NULL) {
		status = PassFunc();
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else if (oid.objectType == MP_OBJECT_TYPE_MULTIPATH_LU) {
	    MP_DisableAutoFailbackLuFn PassFunc;
	    PassFunc = (MP_DisableAutoFailbackLuFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_DisableAutoFailbackLu");

	    if (PassFunc != NULL) {
		status = PassFunc(oid);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else {
	    status = MP_STATUS_INVALID_PARAMETER;
	}
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Disables Auto-probing.
 *
 * @param  oid
 *      The oid of the plugin or the multipath logical unit.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if oid is NULL or specifies a memory area that is not
 *      a valid plugin oid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_DisableAutoProbing(
    MP_OID oid)
{
    MP_UINT32 index;
    MP_STATUS status;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
	MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
	if (oid.objectType == MP_OBJECT_TYPE_PLUGIN) {
	    MP_DisableAutoProbingPluginFn PassFunc;
	    PassFunc = (MP_DisableAutoProbingPluginFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_DisableAutoProbingPlugin");

	    if (PassFunc != NULL) {
		status = PassFunc();
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else if (oid.objectType == MP_OBJECT_TYPE_MULTIPATH_LU) {
	    MP_DisableAutoFailbackLuFn PassFunc;
	    PassFunc = (MP_DisableAutoProbingLuFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_DisableAutoProbingLu");

	    if (PassFunc != NULL) {
		status = PassFunc(oid);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else {
	    status = MP_STATUS_INVALID_PARAMETER;
	}
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Enables a path. This API may cause failover in a logical unit with
 * asymmetric access.
 *
 * @param  oid
 *      The oid of the path.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if oid is NULL or specifies a memory area that is not
 *      a valid path oid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_EnablePath(
    MP_OID oid)
{
    MP_EnablePathFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_PATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_EnablePathFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_EnablePath");

        if (PassFunc != NULL) {
	    status = PassFunc(oid);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Disables a path. This API may cause failover in a logical unit with
 * asymmetric access. This API may cause a logical unit to become unavailable.
 *
 * @param  oid
 *      The oid of the path.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if oid is NULL or specifies a memory area that is not
 *      a valid path oid.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_DisablePath(
    MP_OID oid)
{
    MP_DisablePathFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_PATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_DisablePathFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_DisablePath");

        if (PassFunc != NULL) {
	    status = PassFunc(oid);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Set the multipath logical unit s load balancing policy.
 *
 * @param  logicalUnitoid
 *      The object ID of the multipath logical unit.
 *
 * @param  loadBanlance
 *      The desired load balance policy for the specified logical unit.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if no MP_MULTIPATH_LOGICAL_UNIT associated with
 *      @ref ligicalUnitrOid is found or invalid MP_LOAD_BALANCE_TYPE is
 *      specified.
 *
 * @retval MP_STATUS_FAILED
 *      Returned when the specified loadBalance type cannot be handled
 *      by the plugin.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_SetLogicalUnitLoadBalanceType(
    MP_OID logicalUnitOid,
    MP_LOAD_BALANCE_TYPE loadBalance)
{
    MP_SetLogicalUnitLoadBalanceTypeFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if ((status = validate_object(logicalUnitOid,
        MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = logicalUnitOid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_SetLogicalUnitLoadBalanceTypeFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_SetLogicalUnitLoadBalanceType");

        if (PassFunc != NULL) {
	    status = PassFunc(logicalUnitOid, loadBalance);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Set the weight to be assigned to a particular path.
 *
 * @param  pathOid
 *      The object ID of the path logical unit.
 *
 * @param  weight
 *      weight that will be assigned to the path logical unit.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *      Returned when the MP Path specified by the PathOid could not be
 *      found.
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the implementation does not support the API
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the operation failed.
 *
 * @retval MP_STATUS_PATH_NONOPERATIONAL
 *          Returned when the driver cannot communicate through selected path.
 *
 * @retval MP_STATUS_INVALID_WEIGHT
 *          Returned when the weight parameter is greater than the plugin's
 *      maxWeight property.
 *
 *******************************************************************************
 */
MP_STATUS MP_SetPathWeight(
    MP_OID pathOid,
    MP_UINT32 weight)
{
    MP_SetPathWeightFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if ((status = validate_object(pathOid, MP_OBJECT_TYPE_PATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = pathOid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_SetPathWeightFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_SetPathWeight");

        if (PassFunc != NULL) {
	    status = PassFunc(pathOid, weight);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Set the default load balance policy for the plugin.
 *
 * @param  oid
 *      The object ID of the plugin
 *
 * @param  loadBalance
 *      The desired default load balance policy for the specified plugin.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *      Returned when the the plugin specified by @ref oid could not be
 *      found.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if the oid of the object is not valid.
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the implementation does not support the API
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned when the specified loadBalance type cannot be handled
 *      by the plugin.
 *
 *******************************************************************************
 */
MP_STATUS MP_SetPluginLoadBalanceType(
    MP_OID oid,
    MP_LOAD_BALANCE_TYPE loadBalance)
{
    MP_SetPluginLoadBalanceTypePluginFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if ((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_SetPluginLoadBalanceTypePluginFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_SetPluginLoadBalanceTypePlugin");

        if (PassFunc != NULL) {
	    status = PassFunc(loadBalance);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Set the failback polling rates. Setting both rates to zero disables polling.
 *
 * @param  pluginOid
 *      The object ID of the plugin or multipath lu.
 *
 * @param  pollingRate
 *      The value to be set in MP_PLUGIN_PROPERTIES currentPollingRate.or
 *	MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES pollingRate.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *      Returned when the the plugin specified by @ref oid could not be
 *      found.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if one of the polling values is outside the range
 *      supported by the driver.
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the implementation does not support the API
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_SetFailbackPollingRate(
    MP_OID oid,
    MP_UINT32 pollingRate)
{
    MP_UINT32 index;
    MP_STATUS status;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
	MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
	if (oid.objectType == MP_OBJECT_TYPE_PLUGIN) {
	    MP_SetFailbackPollingRatePluginFn PassFunc;
	    PassFunc = (MP_SetFailbackPollingRatePluginFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_SetFailbackPollingRatePlugin");

	    if (PassFunc != NULL) {
		status = PassFunc(pollingRate);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else if (oid.objectType == MP_OBJECT_TYPE_MULTIPATH_LU) {
	    MP_SetFailbackPollingRateLuFn PassFunc;
	    PassFunc = (MP_SetFailbackPollingRateLuFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_SetFailbackPollingRateLu");

	    if (PassFunc != NULL) {
		status = PassFunc(oid, pollingRate);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else {
	    status = MP_STATUS_INVALID_PARAMETER;
	}
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Set the probing polling rates. Setting both rates to zero disables polling.
 *
 * @param  pluginOid
 *      The object ID of either the plugin or a multipath logical unit.
 *
 * @param  pollingRate
 *      The value to be set in MP_PLUGIN_PROPERTIES current pollingRate or
 *	MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES pollingRate.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *      Returned when the the plugin specified by @ref oid could not be
 *      found.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if one of the polling values is outside the range
 *      supported by the driver.
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the implementation does not support the API
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_SetProbingPollingRate(
    MP_OID    oid,
    MP_UINT32 pollingRate)
{
    MP_UINT32 index;
    MP_STATUS status;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
	MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
	if (oid.objectType == MP_OBJECT_TYPE_PLUGIN) {
	    MP_SetProbingPollingRatePluginFn PassFunc;
	    PassFunc = (MP_SetProbingPollingRatePluginFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_SetProbingPollingRatePlugin");

	    if (PassFunc != NULL) {
		status = PassFunc(pollingRate);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else if (oid.objectType == MP_OBJECT_TYPE_MULTIPATH_LU) {
	    MP_SetProbingPollingRateLuFn PassFunc;
	    PassFunc = (MP_SetProbingPollingRateLuFn)
	    dlsym(plugintable[index].hdlPlugin,
        	"MP_SetProbingPollingRateLu");

	    if (PassFunc != NULL) {
		status = PassFunc(oid, pollingRate);
	    } else {
		status = MP_STATUS_UNSUPPORTED;
	    }
	} else {
	    status = MP_STATUS_INVALID_PARAMETER;
	}
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Set proprietary properties in supported object instances.
 *
 * @param  pluginOid
 *      The object ID of MP_LOAD_BALANCE_PROPRIETARY_TYPE, MP_PLUGIN_PROPERTIES
 *	or MP_MULTIPATH_LOGICAL_UNIT_PROPERTIES.
 *
 * @param  count
 *	   The number of valid items in pPropertyList.
 *
 * @param  pPropertyList
 *	   A pointer to an array of property name/value pairs. This array must
 *	   contain the same number of elements as count.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *      Returned when the the plugin specified by @ref oid could not be
 *      found.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if one of the polling values is outside the range
 *      supported by the driver.
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the implementation does not support the API
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_SetProprietaryProperties(
    MP_OID    oid,
    MP_UINT32 count,
    MP_PROPRIETARY_PROPERTY *pPropertyList)
{
    MP_SetProprietaryPropertiesFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if (((status = validate_object(oid, MP_OBJECT_TYPE_PLUGIN,
	MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) &&
	((status = validate_object(oid, MP_OBJECT_TYPE_PROPRIETARY_LOAD_BALANCE,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS)) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = oid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_SetProprietaryPropertiesFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_SetProprietaryProperties");

        if (PassFunc != NULL) {
	    status = PassFunc(oid, count, pPropertyList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Set the access state for a list of target port groups. This allows
 * a client to force a failover or failback to a desired set of target port
 * groups.
 *
 * @param  luOid
 *      The object ID of the logical unit where the command is sent.
 *
 * @param  count
 *      The number of valid items in the pTpgStateList.
 *
 * @param  pTpgStateList
 *      A pointer to an array of TPG/access-state values. This array must
 *      contain the same number of elements as @ref count.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_OBJECT_NOT_FOUND
 *      Returned when the MP_MULTIPATH_LOGICAL_UNIT associated with @ref
 *      oid could not be found.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pTpgStateList is null or if one of the TPGs referenced
 *      in the list is not associated with the specified MP logical unit.
 *
 * @retval MP_STATUS_UNSUPPORTED
 *      Returned when the implementation does not support the API
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_ACCESS_STATE_INVALID
 *         Returned if the target device returns a status indicating the caller
 *     is attempting to establish an illegal combination of access states.
 *
 * @retval MP_STATUS_FAILED
 *          Returned if the underlying interface failed the commend for some
 *      reason other than MP_STATUS_ACCESS_STATE_INVALID
 *
 *******************************************************************************
 */
MP_STATUS MP_SetTPGAccess(
    MP_OID luOid,
    MP_UINT32 count,
    MP_TPG_STATE_PAIR *pTpgStateList)
{
    MP_SetTPGAccessFn PassFunc;
    MP_UINT32 index;
    MP_STATUS status;

    if ((status = validate_object(luOid, MP_OBJECT_TYPE_MULTIPATH_LU,
        MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
        return (status);
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    index = luOid.ownerId - 1;
    if (plugintable[index].hdlPlugin != NULL) {
        PassFunc = (MP_SetTPGAccessFn)
        dlsym(plugintable[index].hdlPlugin,
        "MP_SetTPGAccess");

        if (PassFunc != NULL) {
	    status = PassFunc(luOid, count, pTpgStateList);
        } else {
	    status = MP_STATUS_UNSUPPORTED;
        }
    } else {
        status = MP_STATUS_FAILED;
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Registers a client function that is to be called
 * whenever the property of an an object changes.
 *
 * @param  pClientFn,
 *      A pointer to an MP_OBJECT_PROPERTY_FN function defined by the
 *      client. On successful return this function will be called to
 *      inform the client of objects that have had one or more properties
 *      change.
 *
 * @param  objectType
 *      The type of object the client wishes to deregister for
 *      property change callbacks. If null, then all objects types are
 *      deregistered.
 *
 * @param  pCallerData
 *      A pointer that is passed to the callback routine with each event.
 *      This may be used by the caller to correlate the event to source of
 *      the registration.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pClientFn is NULL or specifies a memory area
 *      that is not executable.
 *
 * @retval MP_STATUS_FN_REPLACED
 *      Returned when an existing client function is replaced with the one
 *      specified in pClientFn.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_RegisterForObjectPropertyChanges(
    MP_OBJECT_PROPERTY_FN pClientFn,
    MP_OBJECT_TYPE objectType,
    void *pCallerData,
    MP_OID pluginOid)
{
    MP_RegisterForObjectPropertyChangesPluginFn PassFunc;
    MP_UINT32 i;
    MP_UINT32 index;
    MP_STATUS status;

    if (pClientFn == NULL) {
        return (MP_STATUS_INVALID_PARAMETER);
    }

    if (objectType > MP_OBJECT_TYPE_MAX) {
        return (MP_STATUS_INVALID_OBJECT_TYPE);
    }

    if (!(is_zero_oid(pluginOid))) {
	if ((status = validate_object(pluginOid, MP_OBJECT_TYPE_PLUGIN,
	    MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
	    return (status);
	}
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    if (is_zero_oid(pluginOid)) {
	for (i = 0; i < number_of_plugins; i++) {
	    if (plugintable[i].hdlPlugin != NULL) {
		PassFunc = (MP_RegisterForObjectPropertyChangesPluginFn)
		dlsym(plugintable[i].hdlPlugin,
		"MP_RegisterForObjectPropertyChangesPlugin");
	    }

	    if (PassFunc != NULL) {
		status =
		     PassFunc(pClientFn, objectType, pCallerData);
		/* ignore an error and continue */
	    }
	}
    } else {
	index = pluginOid.ownerId - 1;
	if (plugintable[index].hdlPlugin != NULL) {
		PassFunc = (MP_RegisterForObjectPropertyChangesPluginFn)
		dlsym(plugintable[index].hdlPlugin,
		"MP_RegisterForObjectPropertyChangesPlugin");
	}

	if (PassFunc != NULL) {
	    status = PassFunc(pClientFn, objectType, pCallerData);
	}
    }
    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Deregisters a previously registered client function that is to be invoked
 * whenever an object's property changes.
 *
 * @param  pClientFn,
 *      A pointer to an MP_OBJECT_PROPERTY_FN function defined by the
 *      client that was previously registered using
 *      the MP_RegisterForObjectPropertyChanges API. On successful return
 *      this function will no longer be called to inform the client of
 *      object property changes.
 *
 * @param  objectType
 *      The type of object the client wishes to deregister for
 *      property change callbacks. If null, then all objects types are
 *      deregistered.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pClientFn is NULL or specifies a memory area
 *      that is not executable.
 *
 * @retval MP_STATUS_UNKNOWN_FN
 *      Returned if pClientFn is not the same as the previously registered
 *      function.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if oid does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned if pClientFn deregistration is not possible at this time.
 *
 *******************************************************************************
 */
MP_STATUS MP_DeregisterForObjectPropertyChanges(
    MP_OBJECT_PROPERTY_FN pClientFn,
    MP_OBJECT_TYPE objectType,
    MP_OID pluginOid)
{
    MP_DeregisterForObjectPropertyChangesPluginFn PassFunc;
    MP_UINT32 i;
    MP_UINT32 index;
    MP_STATUS status;

    if (pClientFn == NULL) {
        return (MP_STATUS_INVALID_PARAMETER);
    }

    if (objectType > MP_OBJECT_TYPE_MAX) {
        return (MP_STATUS_INVALID_OBJECT_TYPE);
    }

    if (!(is_zero_oid(pluginOid))) {
	if ((status = validate_object(pluginOid, MP_OBJECT_TYPE_PLUGIN,
	    MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
	    return (status);
	}
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    if (is_zero_oid(pluginOid)) {
	for (i = 0; i < number_of_plugins; i++) {
	    if (plugintable[i].hdlPlugin != NULL) {
		PassFunc = (MP_DeregisterForObjectPropertyChangesPluginFn)
		dlsym(plugintable[i].hdlPlugin,
		"MP_DeregisterForObjectPropertyChangesPlugin");
	    }

	    if (PassFunc != NULL) {
		status = PassFunc(pClientFn, objectType);
	    }
	}
    } else {
	index = pluginOid.ownerId - 1;
	if (plugintable[index].hdlPlugin != NULL) {
		PassFunc = (MP_DeregisterForObjectPropertyChangesPluginFn)
		dlsym(plugintable[index].hdlPlugin,
		"MP_DeregisterForObjectPropertyChangesPlugin");
	}

	if (PassFunc != NULL) {
	    status = PassFunc(pClientFn, objectType);
	}
    }
    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Registers a client function that is to be called
 * whenever a high level object appears or disappears.
 *
 * @param  pClientFn,
 *      A pointer to an MP_OBJECT_VISIBILITY_FN function defined by the
 *      client. On successful return this function will be called to
 *      inform the client of objects whose visibility has changed.
 *
 * @param  objectType
 *      The type of object the client wishes to deregister for
 *      property change callbacks. If null, then all objects types are
 *      deregistered.
 *
 * @param  pCallerData
 *      A pointer that is passed to the callback routine with each event.
 *      This may be used by the caller to correlate the event to source of
 *      the registration.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pClientFn is NULL or specifies a memory area
 *      that is not executable.
 *
 * @retval MP_STATUS_FN_REPLACED
 *      Returned when an existing client function is replaced with the one
 *      specified in pClientFn.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if objectType does not specify any valid object type.
 *
 *******************************************************************************
 */
MP_STATUS MP_RegisterForObjectVisibilityChanges(
    MP_OBJECT_VISIBILITY_FN pClientFn,
    MP_OBJECT_TYPE objectType,
    void *pCallerData,
    MP_OID pluginOid)
{
    MP_RegisterForObjectVisibilityChangesPluginFn PassFunc;
    MP_UINT32 i;
    MP_UINT32 index;
    MP_STATUS status;

    if (pClientFn == NULL) {
        return (MP_STATUS_INVALID_PARAMETER);
    }

    if (objectType > MP_OBJECT_TYPE_MAX) {
        return (MP_STATUS_INVALID_OBJECT_TYPE);
    }

    if (!(is_zero_oid(pluginOid))) {
	if ((status = validate_object(pluginOid, MP_OBJECT_TYPE_PLUGIN,
	    MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
	    return (status);
	}
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    if (is_zero_oid(pluginOid)) {
	for (i = 0; i < number_of_plugins; i++) {
	    if (plugintable[i].hdlPlugin != NULL) {
	    PassFunc = (MP_RegisterForObjectVisibilityChangesPluginFn)
		dlsym(plugintable[i].hdlPlugin,
		"MP_RegisterForObjectVisibilityChangesPlugin");
	    }

	    if (PassFunc != NULL) {
		status = PassFunc(pClientFn, objectType, pCallerData);
		/* ignore an error and continue. */
	    }
	}
    } else {
	    index = pluginOid.ownerId - 1;
	    if (plugintable[index].hdlPlugin != NULL) {
	    PassFunc = (MP_RegisterForObjectVisibilityChangesPluginFn)
		dlsym(plugintable[index].hdlPlugin,
		"MP_RegisterForObjectVisibilityChangesPlugin");
	    }

	    if (PassFunc != NULL) {
		status = PassFunc(pClientFn, objectType, pCallerData);
	    }
    }
    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);

}

/**
 *******************************************************************************
 *
 * Deregisters a previously registered client function that is to be invoked
 * whenever a high level object appears or disappears.
 *
 * @param  pClientFn,
 *      A pointer to an MP_OBJECT_VISIBILITY_FN function defined by the
 *      client that was previously registered using
 *      the MP_RegisterForObjectVisibilityChanges API. On successful return
 *      this function will no longer be called to inform the client of
 *      object property changes.
 *
 * @param  objectType
 *      The type of object the client wishes to deregister for visibility
 *      change callbacks. If null, then all objects types are
 *      deregistered.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the operation is successful.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pClientFn is NULL or specifies a memory area
 *      that is not executable.
 *
 * @retval MP_STATUS_UNKNOWN_FN
 *      Returned if pClientFn is not the same as the previously registered
 *      function.
 *
 * @retval MP_STATUS_INVALID_OBJECT_TYPE
 *          Returned if objectType does not specify any valid object type.
 *
 * @retval MP_STATUS_FAILED
 *          Returned if pClientFn deregistration is not possible at this time.
 *
 *******************************************************************************
 */
MP_STATUS MP_DeregisterForObjectVisibilityChanges(
    MP_OBJECT_VISIBILITY_FN pClientFn,
    MP_OBJECT_TYPE objectType,
    MP_OID pluginOid)
{
    MP_DeregisterForObjectVisibilityChangesPluginFn PassFunc;
    MP_UINT32 i;
    MP_UINT32 index;
    MP_STATUS status;

    if (pClientFn == NULL) {
        return (MP_STATUS_INVALID_PARAMETER);
    }

    if (objectType > MP_OBJECT_TYPE_MAX) {
        return (MP_STATUS_INVALID_OBJECT_TYPE);
    }

    if (!(is_zero_oid(pluginOid))) {
	if ((status = validate_object(pluginOid, MP_OBJECT_TYPE_PLUGIN,
	    MP_OBJECT_TYPE_MATCH)) != MP_STATUS_SUCCESS) {
	    return (status);
	}
    }

    (void) pthread_mutex_lock(&mp_lib_mutex);

    if (is_zero_oid(pluginOid)) {
	for (i = 0; i < number_of_plugins; i++) {
	    if (plugintable[i].hdlPlugin != NULL) {
		PassFunc = (MP_DeregisterForObjectVisibilityChangesPluginFn)
		    dlsym(plugintable[i].hdlPlugin,
		    "MP_DeregisterForObjectVisibilityChangesPlugin");
		if (PassFunc != NULL) {
		    status = PassFunc(pClientFn, objectType);
		}
	    }
	}
    } else  {
	    index = pluginOid.ownerId - 1;
	    if (plugintable[index].hdlPlugin != NULL) {
		PassFunc = (MP_DeregisterForObjectVisibilityChangesPluginFn)
		    dlsym(plugintable[index].hdlPlugin,
		    "MP_DeregisterForObjectVisibilityChangesPlugin");
		if (PassFunc != NULL) {
		    status = PassFunc(pClientFn, objectType);
		}
	    }
    }

    (void) pthread_mutex_unlock(&mp_lib_mutex);
    return (status);
}

/**
 *******************************************************************************
 *
 * Compare two Oids for equality to see whether they refer to the same object.
 *
 * @param  oid1
 *          Oid to compare.
 *
 * @param  oid2
 *          Oid to compare.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when the two Oids do refer to the same object.
 *
 * @retval MP_STATUS_FAILED
 *      Returned if the Oids don't compare.
 *
 *******************************************************************************
 */
MP_STATUS MP_CompareOIDs(
        MP_OID oid1,
    MP_OID oid2)
{
    if ((oid1.objectType == oid2.objectType) && (oid1.ownerId == oid2.ownerId)
    	&& (oid1.objectSequenceNumber == oid2.objectSequenceNumber)) {
    	return (MP_STATUS_SUCCESS);
    } else {
    	return (MP_STATUS_FAILED);
    }
}

/**
 *******************************************************************************
 *
 * Frees memory returned by an MP API.
 *
 * @param  pOidList
 *      A pointer to the memory returned by an MP API. On successful
        return, the allocated memory is freed.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when pPluginId is deregistered successfully.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pMemory is NULL or specifies a memory area to which
 *      data cannot be written.
 *
 *******************************************************************************
 */
MP_STATUS MP_FreeOidList(MP_OID_LIST *pOidList)
{
	if (pOidList == NULL) {
	    return (MP_STATUS_INVALID_PARAMETER);
	}

	free(pOidList);

	return (MP_STATUS_SUCCESS);
}

static MP_CHAR *HDR =
"#\n"
"# This file contains names and references to MP API plugin libraries\n"
"#\n"
"#  Do NOT manually edit this file\n"
"#\n"
"# Format:\n"
"#\n"
"# <library ID>  <library pathname>\n"
"#\n";

#define CLEANUP_N_RET(fd, ret)  \
	if (lock_register(fd, F_SETLK, F_UNLCK, 0, SEEK_SET, 0) < 0) { \
		close(fd); \
		return (MP_STATUS_FAILED); \
	} \
	close(fd); \
	return (ret)

/*
 * This function sets an advisory lock on the file pointed to by the argument
 * fd, which is a file descriptor. The lock is set using fcntl() which uses
 * flock structure.
 */
static int
lock_register(int fd, int cmd, int type, off_t offset, int whence, off_t len)
{
    struct flock lock;

    lock.l_type = type;
    lock.l_start = offset;
    lock.l_whence = whence;
    lock.l_len = len;

    return (fcntl(fd, cmd, &lock));
}

/*
 * This function searches for "srch_str" (of length "slen") in "buf" (of length
 * "buflen"). If it is not found, "write_offset" has the offset in "buf" where
 * "srch_str" would have to be added in "buf". If "srch_str" is found in "buf",
 * "write_offset" has its offset in "buf"
 *
 * ARGUMENTS :
 * buf		- buffer to search in
 * buflen	- length of buffer
 * srch_id	- id to search
 * id_len	- length of srch_id
 * write_offset	- Set in function on exit
 *		- It is the offset in buf where srch_str is or should be
 * bytes_left	- Set in function on exit
 *		- It is the # of bytes left beyond write_offset in buf
 * RETURN VALUES :
 * Zero - "srch_id" found in "buf"... "write_offset" has offset in "buf"
 * != 0 - "srch_str" NOT found in "buf" ... "write_offset" points to the end of
 *	    "buf".
 */
static int
search_line(MP_CHAR *buf, size_t buflen, MP_CHAR *srch_id, size_t id_len,
		int *write_offset, int *bytes_left)
{
	int	retval, sizeof_conf_hdr = strlen(HDR);
	MP_CHAR	*sol;		/* Pointer to Start-Of-Line */
	MP_CHAR	*cur_pos;	/* current position */

	*bytes_left = buflen;
	*write_offset = 0;

	if (buf == NULL || buflen <= 0)
		return (-1);

	if (srch_id == NULL || id_len <= 0)
		return (0);

	sol = cur_pos = buf;

	/*
	 * mp conf file should not be edited but takes care of
	 * any extra white space when parsing the line.
	 *
	 * The line should have id + delimiter + name + newline.
	 */
	while (*bytes_left >= (id_len + 3)) {
	    /* skip leading blank or space. */
	    while ((*cur_pos == ' ') || (*cur_pos == '\t')) {
		cur_pos++;
	    }

	    if (strncmp(cur_pos, srch_id, id_len) == 0) {
		/* id matched. */
		cur_pos += id_len;

		while (*cur_pos != '\n') {
		    cur_pos++;
		}
		*write_offset = (sol - buf);
		*bytes_left = buflen - ((cur_pos + 1) - buf);
		return (0);
	    } else {
		/* move to the next line */
		while (*cur_pos != '\n') {
		    cur_pos++;
		}
		*bytes_left = buflen - ((cur_pos + 1) - buf);
	    }
	    sol = cur_pos = cur_pos + 1;
	}

	/* Given strings are not found. */
	*write_offset = buflen;
	return (-1);
}

/**
 *******************************************************************************
 *
 * Registers a plugin with common library.  The implementation of this routine
 * is based on configuration file /etc/mpapi.conf that contains a list of
 * plugin libraries.
 *
 * @param  pPluginId
 *	    A pointer to the key name shall be the reversed domain name of
 *	    the vendor followed by followed by the vendor specific name for
 *	    the plugin that uniquely identifies the plugin.  Should be NULL
 *	    terminated.
 *
 * @param  pFileName
 *	    The full path to the plugin library.
 *	    Should be NULL terminated.
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when pPluginId is deregistered successfully.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pPluginId is NULL or specifies a memory area that
 *      is not executable.
 *
 * @retval MP_STATUS_FAILED
 *          Returned if pClientFn deregistration is not possible at this time.
 *
 *******************************************************************************
 */
MP_STATUS MP_RegisterPlugin(
	MP_WCHAR *pPluginId,
	char *pFileName)
{
	int mpconf, bytes_left, write_offset;
	MP_CHAR fullline[MAX_LINE_SIZE]; /* Full line to add to mpapi.conf */
	MP_CHAR *mpconf_buf;
	MP_CHAR pluginid[MAX_NAME_SIZE];
	char systemPath[MAX_NAME_SIZE], mpConfFilePath[MAX_NAME_SIZE];
	MP_UINT32   new_file_flag = 0;
	MP_UINT32   sizeof_conf_hdr = strlen(HDR);
	struct stat	stbuf;

	if ((pPluginId == NULL) || (pFileName == NULL)) {
	    return (MP_STATUS_INVALID_PARAMETER);
	}

	if (stat(pFileName, &stbuf) != 0) {
	    return (MP_STATUS_INVALID_PARAMETER);
	}

	if (wcstombs(pluginid, pPluginId, MAX_NAME_SIZE) != wcslen(pPluginId)) {
	    return (MP_STATUS_INVALID_PARAMETER);
	}

	*fullline = '\0';
	strncpy(fullline, pluginid, MAX_NAME_SIZE);
	/* add tab */
	strncat(fullline, "\t", MAX_LINE_SIZE - strlen(pluginid));
	strncat(fullline, pFileName, MAX_LINE_SIZE - strlen(pluginid) - 1);
	/* add a new line. */
	strncat(fullline, "\n",
	    MAX_LINE_SIZE - strlen(pluginid) - strlen(pFileName) -1);

	/* Open configuration file from known location */
	strncpy(mpConfFilePath, "/etc/mpapi.conf", MAX_NAME_SIZE);

	if ((chmod(mpConfFilePath, S_IRUSR|S_IRGRP|S_IROTH) == -1) &&
		(errno == ENOENT))  {
	    new_file_flag = 1;
	}

	if ((mpconf = open(mpConfFilePath, O_RDWR | O_CREAT)) == -1) {
		return (MP_STATUS_FAILED);
	}

	if (fchmod(mpconf, S_IRUSR | S_IRGRP | S_IROTH) < 0) {
	    close(mpconf);
	    return (MP_STATUS_FAILED);
	}

	if (lock_register(mpconf, F_SETLKW, F_WRLCK, 0, SEEK_SET, 0) < 0) {
	    close(mpconf);
	    return (MP_STATUS_FAILED);
	}

	if (fstat(mpconf, &stbuf) == -1) {
	    CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	}

	if ((new_file_flag) || (stbuf.st_size == 0)) {
	    if (write(mpconf, HDR, sizeof_conf_hdr) !=
		sizeof_conf_hdr) {
		CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	    }

	    if (pwrite(mpconf, fullline, strlen(fullline),
		sizeof_conf_hdr) !=
		strlen(fullline)) {
		CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	    }
	    CLEANUP_N_RET(mpconf, MP_STATUS_SUCCESS);
	}

	if ((mpconf_buf = (MP_CHAR *)mmap(0, stbuf.st_size,
		PROT_READ | PROT_WRITE,
		MAP_SHARED, mpconf, 0)) == MAP_FAILED) {
	    CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	}

	if (search_line(mpconf_buf, stbuf.st_size,
	    pluginid, strlen(pluginid), &write_offset, &bytes_left) == 0) {
	    /* found a match. */
	    munmap((void *)mpconf_buf, stbuf.st_size);
	    CLEANUP_N_RET(mpconf, MP_STATUS_SUCCESS);
	} else {
	    munmap((void *)mpconf_buf, stbuf.st_size);
	    /* append the fullline to the mpconf. */
	    if (pwrite(mpconf, fullline, strlen(fullline),
		write_offset) !=
		strlen(fullline)) {
		CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	    } else {
		CLEANUP_N_RET(mpconf, MP_STATUS_SUCCESS);
	    }
	}
}

/**
 *******************************************************************************
 *
 * Deregisters a plugin from the common library.  This routine is based on
 * configuration file /etc/mpapi.conf that contains a list of plugin libraries.
 *
 * @param  pPluginId
 *      A pointer to a Plugin ID previously registered using
 *      the MP_RegisterPlugin API..
 *
 * @return An MP_STATUS indicating if the operation was successful or if
 *         an error occurred.
 *
 * @retval MP_STATUS_SUCCESS
 *         Returned when pPluginId is deregistered successfully.
 *
 * @retval MP_STATUS_INVALID_PARAMETER
 *      Returned if pPluginId is NULL or specifies a memory area that
 *      is not executable.
 *
 * @retval MP_STATUS_FAILED
 *          Returned if pClientFn deregistration is not possible at this time.
 *
 *******************************************************************************
 */
MP_STATUS MP_DeregisterPlugin(
    MP_WCHAR *pPluginId)
{
	int mpconf, tmp_mpconf, bytes_left, write_offset;
	char systemPath[MAX_NAME_SIZE], mpConfFilePath[MAX_NAME_SIZE],
	    tmp_mpConfFilePath[MAX_NAME_SIZE + sizeof(pid_t)];
	MP_CHAR    pluginid[MAX_NAME_SIZE];
	MP_CHAR    *mpconf_buf;
	MP_UINT32   sizeof_conf_hdr = strlen(HDR);
	struct stat	stbuf;

	if (pPluginId == NULL) {
	    return (MP_STATUS_INVALID_PARAMETER);
	}

	if (wcstombs(pluginid, pPluginId, MAX_NAME_SIZE) != wcslen(pPluginId)) {
	    return (MP_STATUS_INVALID_PARAMETER);
	}

	/* Open configuration file from known location */
	strncpy(mpConfFilePath, "/etc/mpapi.conf", MAX_NAME_SIZE);

	if ((chmod(mpConfFilePath, S_IRUSR|S_IRGRP|S_IROTH) == -1) &&
		(errno == ENOENT))  {
	    /* no file found */
	    return (MP_STATUS_UNKNOWN_FN);
	}

	if ((mpconf = open(mpConfFilePath, O_RDWR)) == -1) {
		return (MP_STATUS_FAILED);
	}

	if (fchmod(mpconf, S_IRUSR | S_IRGRP | S_IROTH) < 0) {
	    close(mpconf);
	    return (MP_STATUS_FAILED);
	}

	if (lock_register(mpconf, F_SETLKW, F_WRLCK, 0, SEEK_SET, 0) < 0) {
	    close(mpconf);
	    return (MP_STATUS_FAILED);
	}

	if (fstat(mpconf, &stbuf) == -1) {
	    CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	}

	if (stbuf.st_size == 0) {
	    CLEANUP_N_RET(mpconf, MP_STATUS_SUCCESS);
	}

	if ((mpconf_buf = (MP_CHAR *)mmap(0, stbuf.st_size,
		PROT_READ | PROT_WRITE,
		MAP_SHARED, mpconf, 0)) == MAP_FAILED) {
	    CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	}

	if (search_line(mpconf_buf, stbuf.st_size, pluginid, strlen(pluginid),
		&write_offset, &bytes_left) != 0) {
	    munmap((void *)mpconf_buf, stbuf.st_size);
	    CLEANUP_N_RET(mpconf, MP_STATUS_UNKNOWN_FN);
	} else {
	    /*
	     * found a match.
	     * construct temp file name using pid.
	     */
	    (void) snprintf(tmp_mpConfFilePath, MAX_NAME_SIZE,
		"%s%ld", "/etc/mpapi.conf", getpid());

	    if ((tmp_mpconf = open(tmp_mpConfFilePath,
		O_RDWR|O_CREAT|O_TRUNC, S_IRUSR | S_IWUSR)) < 0) {
		CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	    }

	    if (write(tmp_mpconf, mpconf_buf, write_offset) != write_offset) {
		close(tmp_mpconf);
		CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	    }

	    if (pwrite(tmp_mpconf, mpconf_buf + (stbuf.st_size - bytes_left),
		bytes_left, write_offset) != bytes_left) {
		close(tmp_mpconf);
		CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	    }

	    close(tmp_mpconf);
	    munmap((void *)mpconf_buf, stbuf.st_size);

	    /* rename temp file to mpConfFile before unlock and close. */
	    if (rename(tmp_mpConfFilePath, mpConfFilePath) != 0) {
		CLEANUP_N_RET(mpconf, MP_STATUS_FAILED);
	    } else {
		CLEANUP_N_RET(mpconf, MP_STATUS_SUCCESS);
	    }
	}
}