OpenSolaris_b135/lib/mpapi/libmpapi/common/mpapi.c
/******************************************************************************
*
* 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;
MP_STATUS status;
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) {
status = 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);
}
}
}