19e86db79SHyon Kim /*
29e86db79SHyon Kim * ************************************************************************
39e86db79SHyon Kim * Description
49e86db79SHyon Kim * HBAAPILIB.c - Implements a sample common (wrapper) HBA API library
59e86db79SHyon Kim *
69e86db79SHyon Kim * License:
79e86db79SHyon Kim * The contents of this file are subject to the SNIA Public License
89e86db79SHyon Kim * Version 1.0 (the "License"); you may not use this file except in
99e86db79SHyon Kim * compliance with the License. You may obtain a copy of the License at
109e86db79SHyon Kim *
119e86db79SHyon Kim * /http://www.snia.org/English/Resources/Code/OpenSource.html
129e86db79SHyon Kim *
139e86db79SHyon Kim * Software distributed under the License is distributed on an "AS IS"
149e86db79SHyon Kim * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
159e86db79SHyon Kim * the License for the specific language governing rights and limitations
169e86db79SHyon Kim * under the License.
179e86db79SHyon Kim *
189e86db79SHyon Kim * The Original Code is SNIA HBA API Wrapper Library
199e86db79SHyon Kim *
209e86db79SHyon Kim * The Initial Developer of the Original Code is:
219e86db79SHyon Kim * Benjamin F. Kuo, Troika Networks, Inc. (benk@troikanetworks.com)
229e86db79SHyon Kim *
239e86db79SHyon Kim * Contributor(s):
249e86db79SHyon Kim * Tuan Lam, QLogic Corp. (t_lam@qlc.com)
259e86db79SHyon Kim * Dan Willie, Emulex Corp. (Dan.Willie@emulex.com)
269e86db79SHyon Kim * Dixon Hutchinson, Legato Systems, Inc. (dhutchin@legato.com)
279e86db79SHyon Kim * David Dillard, VERITAS Software Corp. (david.dillard@veritas.com)
289e86db79SHyon Kim *
299e86db79SHyon Kim * ************************************************************************
309e86db79SHyon Kim *
319e86db79SHyon Kim * Adding on SM-HBA support
329e86db79SHyon Kim *
339e86db79SHyon Kim * The implementation includes Three different categories functions to support
349e86db79SHyon Kim * both HBAAPI and SM-HBA through the same library.
359e86db79SHyon Kim *
369e86db79SHyon Kim * SM-HBA unique interface:
379e86db79SHyon Kim * 1. CHECKLIBRARYANDVERSION(SMHBA) : match SMHBA VSL
389e86db79SHyon Kim * Or checking specifically if version is SMHBA beforehand.
399e86db79SHyon Kim * 2. resolved to ftable.smhbafunctiontable.{interface}
409e86db79SHyon Kim * HBAAPIV2 unique functions
419e86db79SHyon Kim * 1. CHECKLIBRARYANDVERSION(HBAAPIV2) : validate and match HBAAPI V2 VSL.
429e86db79SHyon Kim * Or checking specifically if version is HBAAPIV2 beforehand.
439e86db79SHyon Kim * 2. resolved to ftable.functiontable.{interface}
449e86db79SHyon Kim * Common interface between SM-HBA and HBAAPIV2.
459e86db79SHyon Kim * 1. CHECKLIBRARY() : to validate the VSL.
469e86db79SHyon Kim * 2. FUNCCOMMON macro to map the appropriate entry point table
479e86db79SHyon Kim * (union ftable).
489e86db79SHyon Kim * 3. If the interface is not supported by HBAAPI(Version 1)
499e86db79SHyon Kim * the funtiion ptr will be set to NULL.
509e86db79SHyon Kim * Common interface between HBAAPI and HBAAPIV2.
519e86db79SHyon Kim * 1. Check if version is not SMHBA).
529e86db79SHyon Kim * 2. ftable.functiontalbe.(interface)
539e86db79SHyon Kim *
549e86db79SHyon Kim * ************************************************************************
559e86db79SHyon Kim */
569e86db79SHyon Kim /*
579e86db79SHyon Kim * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
589e86db79SHyon Kim * Use is subject to license terms.
599e86db79SHyon Kim */
609e86db79SHyon Kim
619e86db79SHyon Kim #ifdef WIN32
629e86db79SHyon Kim #include <windows.h>
639e86db79SHyon Kim #include <string.h>
649e86db79SHyon Kim /*
659e86db79SHyon Kim * Next define forces entry points in the dll to be exported
669e86db79SHyon Kim * See hbaapi.h to see what it does.
679e86db79SHyon Kim */
689e86db79SHyon Kim #define HBAAPI_EXPORTS
699e86db79SHyon Kim #else
709e86db79SHyon Kim #include <dlfcn.h>
719e86db79SHyon Kim #include <strings.h>
729e86db79SHyon Kim #endif
739e86db79SHyon Kim #include <stdio.h>
749e86db79SHyon Kim #include <time.h>
759e86db79SHyon Kim #include "smhbaapi.h"
769e86db79SHyon Kim #include "vendorsmhbaapi.h"
779e86db79SHyon Kim #include <stdlib.h>
789e86db79SHyon Kim #ifdef USESYSLOG
799e86db79SHyon Kim #include <syslog.h>
809e86db79SHyon Kim #endif
819e86db79SHyon Kim #ifdef SOLARIS
829e86db79SHyon Kim #include <link.h>
839e86db79SHyon Kim #include <limits.h>
849e86db79SHyon Kim static int *handle;
859e86db79SHyon Kim static Link_map *map, *mp;
869e86db79SHyon Kim #endif
879e86db79SHyon Kim
889e86db79SHyon Kim /*
899e86db79SHyon Kim * LIBRARY_NUM is a shortcut to figure out which library we need to call.
909e86db79SHyon Kim * The top 16 bits of handle are the library index
919e86db79SHyon Kim */
929e86db79SHyon Kim #define LIBRARY_NUM(handle) ((handle)>>16)
939e86db79SHyon Kim
949e86db79SHyon Kim /*
959e86db79SHyon Kim * VENDOR_HANDLE turns a global library handle into a vendor specific handle,
969e86db79SHyon Kim * with all upper 16 bits set to 0
979e86db79SHyon Kim */
989e86db79SHyon Kim #define VENDOR_HANDLE(handle) ((handle)&0xFFFF)
999e86db79SHyon Kim
1009e86db79SHyon Kim #define HBA_HANDLE_FROM_LOCAL(library, vendor) \
1019e86db79SHyon Kim (((library)<<16) | ((vendor)&0x0000FFFF))
1029e86db79SHyon Kim
1039e86db79SHyon Kim int _hbaapi_debuglevel = 0;
1049e86db79SHyon Kim #define DEBUG(L, STR, A1, A2, A3)
1059e86db79SHyon Kim
1069e86db79SHyon Kim #if defined(USESYSLOG) && defined(USELOGFILE)
1079e86db79SHyon Kim FILE *_hbaapi_debug_fd = NULL;
1089e86db79SHyon Kim int _hbaapi_sysloginit = 0;
1099e86db79SHyon Kim #undef DEBUG
1109e86db79SHyon Kim #ifdef WIN32
1119e86db79SHyon Kim #define DEBUG(L, STR, A1, A2, A3)\
1129e86db79SHyon Kim if ((L) <= _hbaapi_debuglevel) {\
1139e86db79SHyon Kim if (_hbaapi_sysloginit == 0) {\
1149e86db79SHyon Kim openlog("HBAAPI", LOG_PID|LOG_ODELAY, LOG_USER);\
1159e86db79SHyon Kim _hbaapi_sysloginit = 1;\
1169e86db79SHyon Kim }\
1179e86db79SHyon Kim syslog(LOG_INFO, (STR), (A1), (A2), (A3));\
1189e86db79SHyon Kim if (_hbaapi_debug_fd == NULL) {\
1199e86db79SHyon Kim char _logFile[MAX_PATH]; \
1209e86db79SHyon Kim GetTempPath(MAX_PATH, _logFile); \
1219e86db79SHyon Kim strcat(_logFile, "HBAAPI.log"); \
1229e86db79SHyon Kim _hbaapi_debug_fd = fopen(_logFile, "a");\
1239e86db79SHyon Kim }\
1249e86db79SHyon Kim if (_hbaapi_debug_fd != NULL) {\
1259e86db79SHyon Kim fprintf(_hbaapi_debug_fd, #STR "\n", (A1), (A2), (A3));\
1269e86db79SHyon Kim }\
1279e86db79SHyon Kim }
1289e86db79SHyon Kim #else /* WIN32 */
1299e86db79SHyon Kim #define DEBUG(L, STR, A1, A2, A3)\
1309e86db79SHyon Kim if ((L) <= _hbaapi_debuglevel) {\
1319e86db79SHyon Kim if (_hbaapi_sysloginit == 0) {\
1329e86db79SHyon Kim openlog("HBAAPI", LOG_PID|LOG_ODELAY, LOG_USER);\
1339e86db79SHyon Kim _hbaapi_sysloginit = 1;\
1349e86db79SHyon Kim }\
1359e86db79SHyon Kim syslog(LOG_INFO, (STR), (A1), (A2), (A3));\
1369e86db79SHyon Kim if (_hbaapi_debug_fd == NULL) {\
1379e86db79SHyon Kim _hbaapi_debug_fd = fopen("/tmp/HBAAPI.log", "a");\
1389e86db79SHyon Kim }\
1399e86db79SHyon Kim if (_hbaapi_debug_fd != NULL) {\
1409e86db79SHyon Kim fprintf(_hbaapi_debug_fd, #STR "\n", (A1), (A2), (A3));\
1419e86db79SHyon Kim }\
1429e86db79SHyon Kim }
1439e86db79SHyon Kim #endif /* WIN32 */
1449e86db79SHyon Kim
1459e86db79SHyon Kim #else /* Not both USESYSLOG and USELOGFILE */
1469e86db79SHyon Kim #if defined(USESYSLOG)
1479e86db79SHyon Kim int _hbaapi_sysloginit = 0;
1489e86db79SHyon Kim #undef DEBUG
1499e86db79SHyon Kim #define DEBUG(L, STR, A1, A2, A3) \
1509e86db79SHyon Kim if ((L) <= _hbaapi_debuglevel) {\
1519e86db79SHyon Kim if (_hbaapi_sysloginit == 0) {\
1529e86db79SHyon Kim openlog("HBAAPI", LOG_PID|LOG_ODELAY, LOG_USER);\
1539e86db79SHyon Kim _hbaapi_sysloginit = 1;\
1549e86db79SHyon Kim }\
1559e86db79SHyon Kim syslog(LOG_DEBUG, (STR), (A1), (A2), (A3));\
1569e86db79SHyon Kim }
1579e86db79SHyon Kim #endif /* USESYSLOG */
1589e86db79SHyon Kim #if defined(USELOGFILE)
1599e86db79SHyon Kim FILE *_hbaapi_debug_fd = NULL;
1609e86db79SHyon Kim #undef DEBUG
1619e86db79SHyon Kim #ifdef WIN32
1629e86db79SHyon Kim #define DEBUG(L, STR, A1, A2, A3) \
1639e86db79SHyon Kim if ((L) <= _hbaapi_debuglevel) {\
1649e86db79SHyon Kim if (_hbaapi_debug_fd == NULL) {\
1659e86db79SHyon Kim char _logFile[MAX_PATH]; \
1669e86db79SHyon Kim GetTempPath(MAX_PATH, _logFile); \
1679e86db79SHyon Kim strcat(_logFile, "HBAAPI.log"); \
1689e86db79SHyon Kim _hbaapi_debug_fd = fopen(_logFile, "a");\
1699e86db79SHyon Kim }\
1709e86db79SHyon Kim }
1719e86db79SHyon Kim #else /* WIN32 */
1729e86db79SHyon Kim #define DEBUG(L, STR, A1, A2, A3) \
1739e86db79SHyon Kim if ((L) <= _hbaapi_debuglevel) {\
1749e86db79SHyon Kim if (_hbaapi_debug_fd == NULL) {\
1759e86db79SHyon Kim _hbaapi_debug_fd = fopen("/tmp/HBAAPI.log", "a");\
1769e86db79SHyon Kim }\
1779e86db79SHyon Kim if (_hbaapi_debug_fd != NULL) { \
1789e86db79SHyon Kim fprintf(_hbaapi_debug_fd, #STR "\n", (A1), (A2), (A3));\
1799e86db79SHyon Kim }\
1809e86db79SHyon Kim }
1819e86db79SHyon Kim #endif /* WIN32 */
1829e86db79SHyon Kim #endif /* USELOGFILE */
1839e86db79SHyon Kim #endif /* Not both USELOGFILE and USESYSLOG */
1849e86db79SHyon Kim
1859e86db79SHyon Kim #ifdef POSIX_THREADS
1869e86db79SHyon Kim #include <pthread.h>
1879e86db79SHyon Kim /*
1889e86db79SHyon Kim * When multiple mutex's are grabed, they must be always be grabbed in
1899e86db79SHyon Kim * the same order, or deadlock can result. There are three levels
1909e86db79SHyon Kim * of mutex's involved in this API. If LL_mutex is grabbed, always grap
1919e86db79SHyon Kim * it first. If AL_mutex is grabbed, it may not be grabbed before
1929e86db79SHyon Kim * LL_mutex. If grabbed in a multi grab sequence, the mutex's protecting
1939e86db79SHyon Kim * the callback lists must always be grabbed last and release before calling
1949e86db79SHyon Kim * a vendor specific library function that might invoke a callback function
1959e86db79SHyon Kim * on the same thread.
1969e86db79SHyon Kim */
1979e86db79SHyon Kim #define GRAB_MUTEX(M) grab_mutex(M)
1989e86db79SHyon Kim #define RELEASE_MUTEX(M) release_mutex(M)
1999e86db79SHyon Kim #define RELEASE_MUTEX_RETURN(M, RET) release_mutex(M); return (RET)
2009e86db79SHyon Kim #elif defined(WIN32)
2019e86db79SHyon Kim #define GRAB_MUTEX(m) EnterCriticalSection(m)
2029e86db79SHyon Kim #define RELEASE_MUTEX(m) LeaveCriticalSection(m)
2039e86db79SHyon Kim #define RELEASE_MUTEX_RETURN(m, RET) LeaveCriticalSection(m); return (RET)
2049e86db79SHyon Kim #else
2059e86db79SHyon Kim #define GRAB_MUTEX(M)
2069e86db79SHyon Kim #define RELEASE_MUTEX(M)
2079e86db79SHyon Kim #define RELEASE_MUTEX_RETURN(M, RET) return (RET)
2089e86db79SHyon Kim #endif
2099e86db79SHyon Kim
2109e86db79SHyon Kim /*
2119e86db79SHyon Kim * Vendor library information
2129e86db79SHyon Kim */
2139e86db79SHyon Kim typedef enum {
2149e86db79SHyon Kim HBA_LIBRARY_UNKNOWN,
2159e86db79SHyon Kim HBA_LIBRARY_LOADED,
2169e86db79SHyon Kim HBA_LIBRARY_NOT_LOADED
2179e86db79SHyon Kim } HBA_LIBRARY_STATUS;
2189e86db79SHyon Kim
2199e86db79SHyon Kim typedef enum {
2209e86db79SHyon Kim UNKNOWN = 1,
2219e86db79SHyon Kim SMHBA,
2229e86db79SHyon Kim HBAAPIV2,
2239e86db79SHyon Kim HBAAPI
2249e86db79SHyon Kim } LIBRARY_VERSION;
2259e86db79SHyon Kim
2269e86db79SHyon Kim typedef struct hba_library_info {
2279e86db79SHyon Kim struct hba_library_info
2289e86db79SHyon Kim *next;
2299e86db79SHyon Kim #ifdef WIN32
2309e86db79SHyon Kim HINSTANCE hLibrary; /* Handle to a loaded DLL */
2319e86db79SHyon Kim #else
2329e86db79SHyon Kim char *LibraryName;
2339e86db79SHyon Kim void* hLibrary; /* Handle to a loaded DLL */
2349e86db79SHyon Kim #endif
2359e86db79SHyon Kim char *LibraryPath;
2369e86db79SHyon Kim LIBRARY_VERSION version; /* resolve union */
2379e86db79SHyon Kim HBA_UINT32 numOfAdapters;
2389e86db79SHyon Kim union {
2399e86db79SHyon Kim SMHBA_ENTRYPOINTS smhbafunctionTable; /* smhba function pointers */
2409e86db79SHyon Kim HBA_ENTRYPOINTSV2 functionTable; /* hba api function pointers */
2419e86db79SHyon Kim } ftable;
2429e86db79SHyon Kim HBA_LIBRARY_STATUS status; /* info on this library */
2439e86db79SHyon Kim HBA_UINT32 index;
2449e86db79SHyon Kim } HBA_LIBRARY_INFO, *PHBA_LIBRARY_INFO;
2459e86db79SHyon Kim
2469e86db79SHyon Kim #define ARE_WE_INITED() \
2479e86db79SHyon Kim if (_hbaapi_librarylist == NULL) { \
2489e86db79SHyon Kim return (HBA_STATUS_ERROR_NOT_LOADED); \
2499e86db79SHyon Kim }
2509e86db79SHyon Kim HBA_LIBRARY_INFO *_hbaapi_librarylist = NULL;
2519e86db79SHyon Kim HBA_UINT32 _hbaapi_total_library_count = 0;
2529e86db79SHyon Kim #ifdef POSIX_THREADS
2539e86db79SHyon Kim pthread_mutex_t _hbaapi_LL_mutex = PTHREAD_MUTEX_INITIALIZER;
2549e86db79SHyon Kim #elif defined(WIN32)
2559e86db79SHyon Kim CRITICAL_SECTION _hbaapi_LL_mutex;
2569e86db79SHyon Kim #endif
2579e86db79SHyon Kim
2589e86db79SHyon Kim /*
2599e86db79SHyon Kim * Macro to use the right function table between smhba and hbaapi.
2609e86db79SHyon Kim */
2619e86db79SHyon Kim #define FUNCTABLE(lib_infop) \
2629e86db79SHyon Kim ((lib_infop->version == SMHBA) ? \
2639e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable : \
2649e86db79SHyon Kim lib_infop->ftable.functionTable);
2659e86db79SHyon Kim
2669e86db79SHyon Kim /*
2679e86db79SHyon Kim * Macro to use the right function ptr between smhba and hbaapi function table.
2689e86db79SHyon Kim * Should be used for an interface common to SM-HBA and HBAAPIV2.
2699e86db79SHyon Kim */
2709e86db79SHyon Kim #define FUNCCOMMON(lib_infop, func) \
2719e86db79SHyon Kim ((lib_infop->version == SMHBA) ? \
2729e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.func : \
2739e86db79SHyon Kim lib_infop->ftable.functionTable.func)
2749e86db79SHyon Kim
2759e86db79SHyon Kim /*
2769e86db79SHyon Kim * Macro to use the hbaapi function ptr.
2779e86db79SHyon Kim * Should be used for an interface applicable only HBAAPIV2.
2789e86db79SHyon Kim */
2799e86db79SHyon Kim #define FUNCHBAAPIV2(lib_infop, func) \
2809e86db79SHyon Kim lib_infop->ftable.functionTable.func
2819e86db79SHyon Kim
2829e86db79SHyon Kim /*
2839e86db79SHyon Kim * Macro to use the hbaapi function ptr.
2849e86db79SHyon Kim * Should be used for an interface applicable only HBAAPIV2.
2859e86db79SHyon Kim */
2869e86db79SHyon Kim #define FUNCSMHBA(lib_infop, func) \
2879e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.func
2889e86db79SHyon Kim
2899e86db79SHyon Kim /*
2909e86db79SHyon Kim * Individual adapter (hba) information
2919e86db79SHyon Kim */
2929e86db79SHyon Kim typedef struct hba_adapter_info {
2939e86db79SHyon Kim struct hba_adapter_info
2949e86db79SHyon Kim *next;
2959e86db79SHyon Kim HBA_STATUS GNstatus; /* status from GetAdapterNameFunc */
2969e86db79SHyon Kim char *name;
2979e86db79SHyon Kim HBA_WWN nodeWWN;
2989e86db79SHyon Kim HBA_LIBRARY_INFO *library;
2999e86db79SHyon Kim HBA_UINT32 index;
3009e86db79SHyon Kim } HBA_ADAPTER_INFO;
3019e86db79SHyon Kim
3029e86db79SHyon Kim HBA_ADAPTER_INFO *_hbaapi_adapterlist = NULL;
3039e86db79SHyon Kim HBA_UINT32 _hbaapi_total_adapter_count = 0;
3049e86db79SHyon Kim #ifdef POSIX_THREADS
3059e86db79SHyon Kim pthread_mutex_t _hbaapi_AL_mutex = PTHREAD_MUTEX_INITIALIZER;
3069e86db79SHyon Kim #elif defined(WIN32)
3079e86db79SHyon Kim CRITICAL_SECTION _hbaapi_AL_mutex;
3089e86db79SHyon Kim #endif
3099e86db79SHyon Kim
3109e86db79SHyon Kim /*
3119e86db79SHyon Kim * Call back registration
3129e86db79SHyon Kim */
3139e86db79SHyon Kim typedef struct hba_vendorcallback_elem {
3149e86db79SHyon Kim struct hba_vendorcallback_elem
3159e86db79SHyon Kim *next;
3169e86db79SHyon Kim HBA_CALLBACKHANDLE vendorcbhandle;
3179e86db79SHyon Kim HBA_LIBRARY_INFO *lib_info;
3189e86db79SHyon Kim } HBA_VENDORCALLBACK_ELEM;
3199e86db79SHyon Kim
3209e86db79SHyon Kim /*
3219e86db79SHyon Kim * Each instance of HBA_ADAPTERCALLBACK_ELEM represents a call to one of
3229e86db79SHyon Kim * "register" functions that apply to a particular adapter.
3239e86db79SHyon Kim * HBA_ALLADAPTERSCALLBACK_ELEM is used just for HBA_RegisterForAdapterAddEvents
3249e86db79SHyon Kim */
3259e86db79SHyon Kim typedef struct hba_adaptercallback_elem {
3269e86db79SHyon Kim struct hba_adaptercallback_elem
3279e86db79SHyon Kim *next;
3289e86db79SHyon Kim HBA_LIBRARY_INFO *lib_info;
3299e86db79SHyon Kim void *userdata;
3309e86db79SHyon Kim HBA_CALLBACKHANDLE vendorcbhandle;
3319e86db79SHyon Kim void (*callback)();
3329e86db79SHyon Kim } HBA_ADAPTERCALLBACK_ELEM;
3339e86db79SHyon Kim
3349e86db79SHyon Kim typedef struct hba_alladapterscallback_elem {
3359e86db79SHyon Kim struct hba_alladapterscallback_elem
3369e86db79SHyon Kim *next;
3379e86db79SHyon Kim void *userdata;
3389e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vendorhandlelist;
3399e86db79SHyon Kim void (*callback)();
3409e86db79SHyon Kim } HBA_ALLADAPTERSCALLBACK_ELEM;
3419e86db79SHyon Kim
3429e86db79SHyon Kim HBA_ALLADAPTERSCALLBACK_ELEM *_hbaapi_adapteraddevents_callback_list = NULL;
3439e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterevents_callback_list = NULL;
3449e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterportevents_callback_list = NULL;
3459e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterportstatevents_callback_list = NULL;
3469e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_hbaapi_targetevents_callback_list = NULL;
3479e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_hbaapi_linkevents_callback_list = NULL;
3489e86db79SHyon Kim
3499e86db79SHyon Kim HBA_ALLADAPTERSCALLBACK_ELEM *_smhba_adapteraddevents_callback_list = NULL;
3509e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_smhba_adapterevents_callback_list = NULL;
3519e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_smhba_adapterportevents_callback_list = NULL;
3529e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_smhba_adapterportstatevents_callback_list = NULL;
3539e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_smhba_adapterphystatevents_callback_list = NULL;
3549e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *_smhba_targetevents_callback_list = NULL;
3559e86db79SHyon Kim
3569e86db79SHyon Kim #ifdef POSIX_THREADS
3579e86db79SHyon Kim /* mutex's to protect each list */
3589e86db79SHyon Kim pthread_mutex_t _hbaapi_AAE_mutex = PTHREAD_MUTEX_INITIALIZER;
3599e86db79SHyon Kim pthread_mutex_t _hbaapi_AE_mutex = PTHREAD_MUTEX_INITIALIZER;
3609e86db79SHyon Kim pthread_mutex_t _hbaapi_APE_mutex = PTHREAD_MUTEX_INITIALIZER;
3619e86db79SHyon Kim pthread_mutex_t _hbaapi_APSE_mutex = PTHREAD_MUTEX_INITIALIZER;
3629e86db79SHyon Kim pthread_mutex_t _hbaapi_TE_mutex = PTHREAD_MUTEX_INITIALIZER;
3639e86db79SHyon Kim pthread_mutex_t _hbaapi_LE_mutex = PTHREAD_MUTEX_INITIALIZER;
3649e86db79SHyon Kim pthread_mutex_t _smhba_AAE_mutex = PTHREAD_MUTEX_INITIALIZER;
3659e86db79SHyon Kim pthread_mutex_t _smhba_AE_mutex = PTHREAD_MUTEX_INITIALIZER;
3669e86db79SHyon Kim pthread_mutex_t _smhba_APE_mutex = PTHREAD_MUTEX_INITIALIZER;
3679e86db79SHyon Kim pthread_mutex_t _smhba_APSE_mutex = PTHREAD_MUTEX_INITIALIZER;
3689e86db79SHyon Kim pthread_mutex_t _smhba_APHYSE_mutex = PTHREAD_MUTEX_INITIALIZER;
3699e86db79SHyon Kim pthread_mutex_t _smhba_TE_mutex = PTHREAD_MUTEX_INITIALIZER;
3709e86db79SHyon Kim pthread_mutex_t _smhba_LE_mutex = PTHREAD_MUTEX_INITIALIZER;
3719e86db79SHyon Kim #elif defined(WIN32)
3729e86db79SHyon Kim CRITICAL_SECTION _hbaapi_AAE_mutex;
3739e86db79SHyon Kim CRITICAL_SECTION _hbaapi_AE_mutex;
3749e86db79SHyon Kim CRITICAL_SECTION _hbaapi_APE_mutex;
3759e86db79SHyon Kim CRITICAL_SECTION _hbaapi_APSE_mutex;
3769e86db79SHyon Kim CRITICAL_SECTION _hbaapi_TE_mutex;
3779e86db79SHyon Kim CRITICAL_SECTION _smhba_AAE_mutex;
3789e86db79SHyon Kim CRITICAL_SECTION _smhba_AE_mutex;
3799e86db79SHyon Kim CRITICAL_SECTION _smhba_APE_mutex;
3809e86db79SHyon Kim CRITICAL_SECTION _smhba_APSE_mutex;
3819e86db79SHyon Kim CRITICAL_SECTION _smhba_APHYSE_mutex;
3829e86db79SHyon Kim CRITICAL_SECTION _smhba_TE_mutex;
3839e86db79SHyon Kim CRITICAL_SECTION _hbaapi_LE_mutex;
3849e86db79SHyon Kim #endif
3859e86db79SHyon Kim
3869e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM **cb_lists_array[] = {
3879e86db79SHyon Kim &_hbaapi_adapterevents_callback_list,
3889e86db79SHyon Kim &_hbaapi_adapterportevents_callback_list,
3899e86db79SHyon Kim &_hbaapi_adapterportstatevents_callback_list,
3909e86db79SHyon Kim &_hbaapi_targetevents_callback_list,
3919e86db79SHyon Kim &_hbaapi_linkevents_callback_list,
3929e86db79SHyon Kim &_smhba_adapterevents_callback_list,
3939e86db79SHyon Kim &_smhba_adapterportevents_callback_list,
3949e86db79SHyon Kim &_smhba_adapterportstatevents_callback_list,
3959e86db79SHyon Kim &_smhba_adapterphystatevents_callback_list,
3969e86db79SHyon Kim &_smhba_targetevents_callback_list,
3979e86db79SHyon Kim NULL};
3989e86db79SHyon Kim
3999e86db79SHyon Kim /*
4009e86db79SHyon Kim * Common library internal. Mutex handling
4019e86db79SHyon Kim */
4029e86db79SHyon Kim #ifdef POSIX_THREADS
4039e86db79SHyon Kim static void
grab_mutex(pthread_mutex_t * mp)4049e86db79SHyon Kim grab_mutex(pthread_mutex_t *mp) {
4059e86db79SHyon Kim /* LINTED E_FUNC_SET_NOT_USED */
4069e86db79SHyon Kim int ret;
4079e86db79SHyon Kim if ((ret = pthread_mutex_lock(mp)) != 0) {
4089e86db79SHyon Kim perror("pthread_mutex_lock - HBAAPI:");
4099e86db79SHyon Kim DEBUG(1, "pthread_mutex_lock returned %d", ret, 0, 0);
4109e86db79SHyon Kim }
4119e86db79SHyon Kim }
4129e86db79SHyon Kim
4139e86db79SHyon Kim static void
release_mutex(pthread_mutex_t * mp)4149e86db79SHyon Kim release_mutex(pthread_mutex_t *mp) {
4159e86db79SHyon Kim /* LINTED E_FUNC_SET_NOT_USED */
4169e86db79SHyon Kim int ret;
4179e86db79SHyon Kim if ((ret = pthread_mutex_unlock(mp)) != 0) {
4189e86db79SHyon Kim perror("pthread_mutex_unlock - HBAAPI:");
4199e86db79SHyon Kim DEBUG(1, "pthread_mutex_unlock returned %d", ret, 0, 0);
4209e86db79SHyon Kim }
4219e86db79SHyon Kim }
4229e86db79SHyon Kim #endif
4239e86db79SHyon Kim
4249e86db79SHyon Kim /*
4259e86db79SHyon Kim * Common library internal. Check library and return vendorhandle
4269e86db79SHyon Kim */
4279e86db79SHyon Kim static HBA_STATUS
HBA_CheckLibrary(HBA_HANDLE handle,HBA_LIBRARY_INFO ** lib_infopp,HBA_HANDLE * vendorhandle)4289e86db79SHyon Kim HBA_CheckLibrary(HBA_HANDLE handle,
4299e86db79SHyon Kim HBA_LIBRARY_INFO **lib_infopp,
4309e86db79SHyon Kim HBA_HANDLE *vendorhandle) {
4319e86db79SHyon Kim
4329e86db79SHyon Kim HBA_UINT32 libraryIndex;
4339e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
4349e86db79SHyon Kim
4359e86db79SHyon Kim if (_hbaapi_librarylist == NULL) {
4369e86db79SHyon Kim return (HBA_STATUS_ERROR);
4379e86db79SHyon Kim }
4389e86db79SHyon Kim libraryIndex = LIBRARY_NUM(handle);
4399e86db79SHyon Kim
4409e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
4419e86db79SHyon Kim for (lib_infop = _hbaapi_librarylist;
4429e86db79SHyon Kim lib_infop != NULL;
4439e86db79SHyon Kim lib_infop = lib_infop->next) {
4449e86db79SHyon Kim if (lib_infop->index == libraryIndex) {
4459e86db79SHyon Kim if (lib_infop->status != HBA_LIBRARY_LOADED) {
4469e86db79SHyon Kim return (HBA_STATUS_ERROR);
4479e86db79SHyon Kim }
4489e86db79SHyon Kim *lib_infopp = lib_infop;
4499e86db79SHyon Kim *vendorhandle = VENDOR_HANDLE(handle);
4509e86db79SHyon Kim /* caller will release the mutex */
4519e86db79SHyon Kim return (HBA_STATUS_OK);
4529e86db79SHyon Kim }
4539e86db79SHyon Kim }
4549e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INVALID_HANDLE);
4559e86db79SHyon Kim }
4569e86db79SHyon Kim #define CHECKLIBRARY() \
4579e86db79SHyon Kim status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);\
4589e86db79SHyon Kim if (status != HBA_STATUS_OK) { \
4599e86db79SHyon Kim return (status); \
4609e86db79SHyon Kim }
4619e86db79SHyon Kim
4629e86db79SHyon Kim #define CHECKLIBRARYANDVERSION(ver) \
4639e86db79SHyon Kim status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle); \
4649e86db79SHyon Kim if (status != HBA_STATUS_OK) { \
4659e86db79SHyon Kim return (status); \
4669e86db79SHyon Kim } else { \
4679e86db79SHyon Kim if (ver != lib_infop->version) { \
4689e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, \
4699e86db79SHyon Kim HBA_STATUS_ERROR_INCOMPATIBLE); \
4709e86db79SHyon Kim } \
4719e86db79SHyon Kim }
4729e86db79SHyon Kim
4739e86db79SHyon Kim /*
4749e86db79SHyon Kim * freevendorhandlelist is called with _hbaapi_LL_mutex already held
4759e86db79SHyon Kim */
4769e86db79SHyon Kim static void
freevendorhandlelist(HBA_VENDORCALLBACK_ELEM * vhlist)4779e86db79SHyon Kim freevendorhandlelist(HBA_VENDORCALLBACK_ELEM *vhlist) {
4789e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vhlp;
4799e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vnext;
4809e86db79SHyon Kim HBARemoveCallbackFunc registeredfunc;
4819e86db79SHyon Kim
4829e86db79SHyon Kim for (vhlp = vhlist; vhlp != NULL; vhlp = vnext) {
4839e86db79SHyon Kim vnext = vhlp->next;
4849e86db79SHyon Kim registeredfunc =
4859e86db79SHyon Kim FUNCCOMMON(vhlp->lib_info, RemoveCallbackHandler);
4869e86db79SHyon Kim if (registeredfunc == NULL) {
4879e86db79SHyon Kim continue;
4889e86db79SHyon Kim }
4899e86db79SHyon Kim (registeredfunc)(vhlp->vendorcbhandle);
4909e86db79SHyon Kim free(vhlp);
4919e86db79SHyon Kim }
4929e86db79SHyon Kim }
4939e86db79SHyon Kim
4949e86db79SHyon Kim static
4959e86db79SHyon Kim HBA_STATUS
local_remove_callback(HBA_CALLBACKHANDLE cbhandle)4969e86db79SHyon Kim local_remove_callback(HBA_CALLBACKHANDLE cbhandle) {
4979e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM ***listp;
4989e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM **lastp;
4999e86db79SHyon Kim HBA_ALLADAPTERSCALLBACK_ELEM **lap;
5009e86db79SHyon Kim HBA_ALLADAPTERSCALLBACK_ELEM *allcbp;
5019e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *cbp;
5029e86db79SHyon Kim HBARemoveCallbackFunc registeredfunc;
5039e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vhlp;
5049e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vnext;
5059e86db79SHyon Kim int found;
5069e86db79SHyon Kim HBA_STATUS status = HBA_STATUS_ERROR_INVALID_HANDLE;
5079e86db79SHyon Kim
5089e86db79SHyon Kim
5099e86db79SHyon Kim /* search through the simple lists first */
5109e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AAE_mutex);
5119e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AE_mutex);
5129e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_APE_mutex);
5139e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_APSE_mutex);
5149e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_TE_mutex);
5159e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LE_mutex);
5169e86db79SHyon Kim GRAB_MUTEX(&_smhba_AAE_mutex);
5179e86db79SHyon Kim GRAB_MUTEX(&_smhba_AE_mutex);
5189e86db79SHyon Kim GRAB_MUTEX(&_smhba_APE_mutex);
5199e86db79SHyon Kim GRAB_MUTEX(&_smhba_APSE_mutex);
5209e86db79SHyon Kim GRAB_MUTEX(&_smhba_TE_mutex);
5219e86db79SHyon Kim for (listp = cb_lists_array, found = 0;
5229e86db79SHyon Kim (found == 0 && *listp != NULL); listp++) {
5239e86db79SHyon Kim lastp = *listp;
5249e86db79SHyon Kim for (cbp = **listp; cbp != NULL; cbp = cbp->next) {
5259e86db79SHyon Kim if (cbhandle != (HBA_CALLBACKHANDLE)cbp) {
5269e86db79SHyon Kim lastp = &(cbp->next);
5279e86db79SHyon Kim continue;
5289e86db79SHyon Kim }
5299e86db79SHyon Kim found = 1;
5309e86db79SHyon Kim registeredfunc =
5319e86db79SHyon Kim FUNCCOMMON(cbp->lib_info, RemoveCallbackHandler);
5329e86db79SHyon Kim if (registeredfunc == NULL) {
5339e86db79SHyon Kim break;
5349e86db79SHyon Kim }
5359e86db79SHyon Kim (registeredfunc)(cbp->vendorcbhandle);
5369e86db79SHyon Kim *lastp = cbp->next;
5379e86db79SHyon Kim free(cbp);
5389e86db79SHyon Kim break;
5399e86db79SHyon Kim }
5409e86db79SHyon Kim }
5419e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LE_mutex);
5429e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_TE_mutex);
5439e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_APSE_mutex);
5449e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_APE_mutex);
5459e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AE_mutex);
5469e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AAE_mutex);
5479e86db79SHyon Kim RELEASE_MUTEX(&_smhba_AAE_mutex);
5489e86db79SHyon Kim RELEASE_MUTEX(&_smhba_AE_mutex);
5499e86db79SHyon Kim RELEASE_MUTEX(&_smhba_APE_mutex);
5509e86db79SHyon Kim RELEASE_MUTEX(&_smhba_APSE_mutex);
5519e86db79SHyon Kim RELEASE_MUTEX(&_smhba_TE_mutex);
5529e86db79SHyon Kim
5539e86db79SHyon Kim if (found != 0) {
5549e86db79SHyon Kim if (registeredfunc == NULL) {
5559e86db79SHyon Kim return (HBA_STATUS_ERROR_NOT_SUPPORTED);
5569e86db79SHyon Kim }
5579e86db79SHyon Kim return (HBA_STATUS_OK);
5589e86db79SHyon Kim }
5599e86db79SHyon Kim
5609e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AAE_mutex);
5619e86db79SHyon Kim /*
5629e86db79SHyon Kim * if it wasnt in the simple lists,
5639e86db79SHyon Kim * look in the list for adapteraddevents
5649e86db79SHyon Kim */
5659e86db79SHyon Kim lap = &_hbaapi_adapteraddevents_callback_list;
5669e86db79SHyon Kim for (allcbp = _hbaapi_adapteraddevents_callback_list;
5679e86db79SHyon Kim allcbp != NULL;
5689e86db79SHyon Kim allcbp = allcbp->next) {
5699e86db79SHyon Kim if (cbhandle != (HBA_CALLBACKHANDLE)allcbp) {
5709e86db79SHyon Kim lap = &allcbp->next;
5719e86db79SHyon Kim continue;
5729e86db79SHyon Kim }
5739e86db79SHyon Kim for (vhlp = allcbp->vendorhandlelist; vhlp != NULL; vhlp = vnext) {
5749e86db79SHyon Kim vnext = vhlp->next;
5759e86db79SHyon Kim /* should be HBAAPIV2 VSL to get to here */
5769e86db79SHyon Kim registeredfunc =
5779e86db79SHyon Kim vhlp->lib_info->ftable.functionTable.RemoveCallbackHandler;
5789e86db79SHyon Kim if (registeredfunc == NULL) {
5799e86db79SHyon Kim continue;
5809e86db79SHyon Kim }
5819e86db79SHyon Kim (registeredfunc)(vhlp->vendorcbhandle);
5829e86db79SHyon Kim free(vhlp);
5839e86db79SHyon Kim }
5849e86db79SHyon Kim *lap = allcbp->next;
5859e86db79SHyon Kim free(allcbp);
5869e86db79SHyon Kim status = HBA_STATUS_OK;
5879e86db79SHyon Kim break;
5889e86db79SHyon Kim }
5899e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AAE_mutex);
5909e86db79SHyon Kim
5919e86db79SHyon Kim /* now search smhba adapteradd events. */
5929e86db79SHyon Kim GRAB_MUTEX(&_smhba_AAE_mutex);
5939e86db79SHyon Kim lap = &_smhba_adapteraddevents_callback_list;
5949e86db79SHyon Kim for (allcbp = _smhba_adapteraddevents_callback_list;
5959e86db79SHyon Kim allcbp != NULL;
5969e86db79SHyon Kim allcbp = allcbp->next) {
5979e86db79SHyon Kim if (cbhandle != (HBA_CALLBACKHANDLE)allcbp) {
5989e86db79SHyon Kim lap = &allcbp->next;
5999e86db79SHyon Kim continue;
6009e86db79SHyon Kim }
6019e86db79SHyon Kim for (vhlp = allcbp->vendorhandlelist; vhlp != NULL; vhlp = vnext) {
6029e86db79SHyon Kim vnext = vhlp->next;
6039e86db79SHyon Kim /* should be SMHBA VSL to get to here */
6049e86db79SHyon Kim registeredfunc =
6059e86db79SHyon Kim vhlp->lib_info->
6069e86db79SHyon Kim ftable.smhbafunctionTable.RemoveCallbackHandler;
6079e86db79SHyon Kim if (registeredfunc == NULL) {
6089e86db79SHyon Kim continue;
6099e86db79SHyon Kim }
6109e86db79SHyon Kim (registeredfunc)(vhlp->vendorcbhandle);
6119e86db79SHyon Kim free(vhlp);
6129e86db79SHyon Kim }
6139e86db79SHyon Kim *lap = allcbp->next;
6149e86db79SHyon Kim free(allcbp);
6159e86db79SHyon Kim status = HBA_STATUS_OK;
6169e86db79SHyon Kim break;
6179e86db79SHyon Kim }
6189e86db79SHyon Kim RELEASE_MUTEX(&_smhba_AAE_mutex);
6199e86db79SHyon Kim
6209e86db79SHyon Kim return (status);
6219e86db79SHyon Kim }
6229e86db79SHyon Kim
6239e86db79SHyon Kim /* LINTED E_STATIC_UE_STATIC_UNUSED */
6249e86db79SHyon Kim static char wwn_str1[17];
6259e86db79SHyon Kim /* LINTED E_STATIC_UE_STATIC_UNUSED */
6269e86db79SHyon Kim static char wwn_str2[17];
6279e86db79SHyon Kim /* LINTED E_STATIC_UE_STATIC_UNUSED */
6289e86db79SHyon Kim static char wwn_str3[17];
6299e86db79SHyon Kim #define WWN2STR1(wwn) WWN2str(wwn_str1, (wwn))
6309e86db79SHyon Kim #define WWN2STR2(wwn) WWN2str(wwn_str2, (wwn))
6319e86db79SHyon Kim #define WWN2STR3(wwn) WWN2str(wwn_str3, (wwn))
6329e86db79SHyon Kim static char *
6339e86db79SHyon Kim /* LINTED E_STATIC_UE_STATIC_UNUSED */
WWN2str(char * buf,HBA_WWN * wwn)6349e86db79SHyon Kim WWN2str(char *buf, HBA_WWN *wwn) {
6359e86db79SHyon Kim int j;
6369e86db79SHyon Kim unsigned char *pc = (unsigned char *)&(wwn->wwn[0]);
6379e86db79SHyon Kim buf[0] = '\0';
6389e86db79SHyon Kim for (j = 0; j < 16; j += 2) {
6399e86db79SHyon Kim (void) sprintf(&buf[j], "%02X", (int)*pc++);
6409e86db79SHyon Kim }
6419e86db79SHyon Kim return (buf);
6429e86db79SHyon Kim }
6439e86db79SHyon Kim
6449e86db79SHyon Kim #ifdef WIN32
6459e86db79SHyon Kim BOOL APIENTRY
DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)6469e86db79SHyon Kim DllMain(HANDLE hModule,
6479e86db79SHyon Kim DWORD ul_reason_for_call,
6489e86db79SHyon Kim LPVOID lpReserved)
6499e86db79SHyon Kim {
6509e86db79SHyon Kim switch (ul_reason_for_call) {
6519e86db79SHyon Kim case DLL_PROCESS_ATTACH:
6529e86db79SHyon Kim break;
6539e86db79SHyon Kim case DLL_PROCESS_DETACH:
6549e86db79SHyon Kim break;
6559e86db79SHyon Kim case DLL_THREAD_ATTACH:
6569e86db79SHyon Kim case DLL_THREAD_DETACH:
6579e86db79SHyon Kim break;
6589e86db79SHyon Kim }
6599e86db79SHyon Kim return (TRUE);
6609e86db79SHyon Kim }
6619e86db79SHyon Kim #endif
6629e86db79SHyon Kim
6639e86db79SHyon Kim /*
6649e86db79SHyon Kim * Read in the config file and load all the specified vendor specific
6659e86db79SHyon Kim * libraries and perform the function registration exercise
6669e86db79SHyon Kim */
6679e86db79SHyon Kim HBA_STATUS
HBA_LoadLibrary()6689e86db79SHyon Kim HBA_LoadLibrary()
6699e86db79SHyon Kim {
6709e86db79SHyon Kim HBARegisterLibraryFunc RegisterFunc;
6719e86db79SHyon Kim HBARegisterLibraryV2Func RegisterV2Func;
6729e86db79SHyon Kim SMHBARegisterLibraryFunc RegisterSMHBAFunc;
6739e86db79SHyon Kim HBALoadLibraryFunc LoadLibraryFunc;
6749e86db79SHyon Kim HBAGetVersionFunc GetVersionFunc;
6759e86db79SHyon Kim #ifdef POSIX_THREADS
6769e86db79SHyon Kim int ret;
6779e86db79SHyon Kim #endif
6789e86db79SHyon Kim HBA_STATUS status;
6799e86db79SHyon Kim HBA_UINT32 libversion;
6809e86db79SHyon Kim
6819e86db79SHyon Kim /* Open configuration file from known location */
6829e86db79SHyon Kim #ifdef WIN32
6839e86db79SHyon Kim LONG lStatus;
6849e86db79SHyon Kim HKEY hkSniaHba, hkVendorLib;
6859e86db79SHyon Kim FILETIME ftLastWriteTime;
6869e86db79SHyon Kim TCHAR cSubKeyName[256];
6879e86db79SHyon Kim DWORD i, dwSize, dwType;
6889e86db79SHyon Kim BYTE byFileName[MAX_PATH];
6899e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
6909e86db79SHyon Kim
6919e86db79SHyon Kim if (_hbaapi_librarylist != NULL) {
6929e86db79SHyon Kim /* this is an app programming error */
6939e86db79SHyon Kim return (HBA_STATUS_ERROR);
6949e86db79SHyon Kim }
6959e86db79SHyon Kim
6969e86db79SHyon Kim lStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\SNIA\\HBA",
6979e86db79SHyon Kim 0, KEY_READ, &hkSniaHba);
6989e86db79SHyon Kim if (lStatus != ERROR_SUCCESS) {
6999e86db79SHyon Kim /* ???Opportunity to send error msg, configuration error */
7009e86db79SHyon Kim return (HBA_STATUS_ERROR);
7019e86db79SHyon Kim }
7029e86db79SHyon Kim /*
7039e86db79SHyon Kim * Enumerate all the subkeys. These have the form:
7049e86db79SHyon Kim * HKLM\Software\SNIA\HBA\<Vendor id> - note that we don't care
7059e86db79SHyon Kim * what the vendor id is
7069e86db79SHyon Kim */
7079e86db79SHyon Kim for (i = 0; ; i++) {
7089e86db79SHyon Kim dwSize = 255; /* how big the buffer is */
7099e86db79SHyon Kim lStatus = RegEnumKeyEx(hkSniaHba, i,
7109e86db79SHyon Kim (char *)&cSubKeyName, &dwSize, NULL,
7119e86db79SHyon Kim NULL, NULL, &ftLastWriteTime);
7129e86db79SHyon Kim if (lStatus == ERROR_NO_MORE_ITEMS) {
7139e86db79SHyon Kim break; /* we're done */
7149e86db79SHyon Kim } else if (lStatus == ERROR_MORE_DATA) { /* buffer not big enough */
7159e86db79SHyon Kim /* do whatever */
7169e86db79SHyon Kim ;
7179e86db79SHyon Kim }
7189e86db79SHyon Kim /* Now open the subkey that pertains to this vendor's library */
7199e86db79SHyon Kim lStatus = RegOpenKeyEx(hkSniaHba, cSubKeyName, 0, KEY_READ,
7209e86db79SHyon Kim &hkVendorLib);
7219e86db79SHyon Kim if (lStatus != ERROR_SUCCESS) {
7229e86db79SHyon Kim RegCloseKey(hkSniaHba);
7239e86db79SHyon Kim /* ???Opportunity to send error msg, installation error */
7249e86db79SHyon Kim return (HBA_STATUS_ERROR);
7259e86db79SHyon Kim /*
7269e86db79SHyon Kim * you may want to return something
7279e86db79SHyon Kim * else or keep trying
7289e86db79SHyon Kim */
7299e86db79SHyon Kim }
7309e86db79SHyon Kim /*
7319e86db79SHyon Kim * The name of the library is contained in a REG_SZ Value
7329e86db79SHyon Kim * keyed to "LibraryFile"
7339e86db79SHyon Kim */
7349e86db79SHyon Kim dwSize = MAX_PATH;
7359e86db79SHyon Kim lStatus = RegQueryValueEx(hkVendorLib, "LibraryFile", NULL, &dwType,
7369e86db79SHyon Kim byFileName, &dwSize);
7379e86db79SHyon Kim if (lStatus != ERROR_SUCCESS) {
7389e86db79SHyon Kim RegCloseKey(hkVendorLib);
7399e86db79SHyon Kim /* ???Opportunity to send error msg, installation error */
7409e86db79SHyon Kim continue;
7419e86db79SHyon Kim }
7429e86db79SHyon Kim lib_infop = (HBA_LIBRARY_INFO *)calloc(1, sizeof (HBA_LIBRARY_INFO));
7439e86db79SHyon Kim if (lib_infop == NULL) {
7449e86db79SHyon Kim /* what is the right thing to do in MS land??? */
7459e86db79SHyon Kim RegCloseKey(hkVendorLib);
7469e86db79SHyon Kim /* ???Opportunity to send error msg, installation error */
7479e86db79SHyon Kim return (HBA_STATUS_ERROR);
7489e86db79SHyon Kim }
7499e86db79SHyon Kim lib_infop->status = HBA_LIBRARY_NOT_LOADED;
7509e86db79SHyon Kim lib_infop->next = _hbaapi_librarylist;
7519e86db79SHyon Kim lib_infop->index = _hbaapi_total_library_count;
7529e86db79SHyon Kim _hbaapi_total_library_count++;
7539e86db79SHyon Kim _hbaapi_librarylist = lib_infop;
7549e86db79SHyon Kim
7559e86db79SHyon Kim /* Now I can try to load the library */
7569e86db79SHyon Kim lib_infop->hLibrary = LoadLibrary(byFileName);
7579e86db79SHyon Kim if (lib_infop->hLibrary == NULL) {
7589e86db79SHyon Kim /* printf("unable to load library %s\n", librarypath); */
7599e86db79SHyon Kim /* ???Opportunity to send error msg, installation error */
7609e86db79SHyon Kim goto dud_library;
7619e86db79SHyon Kim }
7629e86db79SHyon Kim lib_infop->LibraryPath = strdup(byFileName);
7639e86db79SHyon Kim DEBUG(1, "HBAAPI loading: %s\n", byFileName, 0, 0);
7649e86db79SHyon Kim
7659e86db79SHyon Kim RegisterSMHBAFunc = (SMHBARegisterLibraryFunc)
7669e86db79SHyon Kim GetProcAddress(lib_infop->hLibrary, "SMHBA_RegisterLibrary");
7679e86db79SHyon Kim if (RegisterSMHBAFunc != NULL) {
7689e86db79SHyon Kim status = ((RegisterSMHBAFunc)(SMHBA_ENTRYPOINTS *)
7699e86db79SHyon Kim (&lib_infop->ftable.smhbafunctionTable));
7709e86db79SHyon Kim if (status != HBA_STATUS_OK) {
7719e86db79SHyon Kim /* library not loaded */
7729e86db79SHyon Kim /* ???Opportunity to send error msg, library error? */
7739e86db79SHyon Kim goto dud_library;
7749e86db79SHyon Kim } else {
7759e86db79SHyon Kim lib_infop->version = SMHBA;
7769e86db79SHyon Kim }
7779e86db79SHyon Kim } else {
7789e86db79SHyon Kim /* Call the registration function to get the list of pointers */
7799e86db79SHyon Kim RegisterV2Func = (HBARegisterLibraryV2Func)GetProcAddress(
7809e86db79SHyon Kim lib_infop->hLibrary, "HBA_RegisterLibraryV2");
7819e86db79SHyon Kim if (RegisterV2Func != NULL) {
7829e86db79SHyon Kim /*
7839e86db79SHyon Kim * Load the function pointers directly into
7849e86db79SHyon Kim * the table of functions
7859e86db79SHyon Kim */
7869e86db79SHyon Kim status = ((RegisterV2Func)
7879e86db79SHyon Kim (HBA_ENTRYPOINTSV2 *)(&lib_infop->ftable.functionTable));
7889e86db79SHyon Kim if (status != HBA_STATUS_OK) {
7899e86db79SHyon Kim /* library not loaded */
7909e86db79SHyon Kim /* ???Opportunity to send error msg, library error? */
7919e86db79SHyon Kim goto dud_library;
7929e86db79SHyon Kim } else {
7939e86db79SHyon Kim lib_infop->version = HBAAPIV2;
7949e86db79SHyon Kim }
7959e86db79SHyon Kim } else {
7969e86db79SHyon Kim /* Maybe the vendor library is only Rev1 */
7979e86db79SHyon Kim RegisterFunc = (HBARegisterLibraryFunc)
7989e86db79SHyon Kim GetProcAddress(lib_infop->hLibrary, "HBA_RegisterLibrary");
7999e86db79SHyon Kim if (RegisterFunc == NULL) {
8009e86db79SHyon Kim /* ???Opportunity to send error msg, library error? */
8019e86db79SHyon Kim goto dud_library;
8029e86db79SHyon Kim }
8039e86db79SHyon Kim /*
8049e86db79SHyon Kim * Load the function points directly into
8059e86db79SHyon Kim * the Rev 2 table of functions
8069e86db79SHyon Kim */
8079e86db79SHyon Kim status = ((RegisterFunc)(
8089e86db79SHyon Kim (HBA_ENTRYPOINTS *)(&lib_infop->ftable.functionTable)));
8099e86db79SHyon Kim if (status != HBA_STATUS_OK) {
8109e86db79SHyon Kim /* library not loaded */
8119e86db79SHyon Kim /* ???Opportunity to send error msg, library error? */
8129e86db79SHyon Kim goto dud_library;
8139e86db79SHyon Kim } else {
8149e86db79SHyon Kim lib_infop->version = HBAAPI;
8159e86db79SHyon Kim }
8169e86db79SHyon Kim }
8179e86db79SHyon Kim }
8189e86db79SHyon Kim
8199e86db79SHyon Kim /* successfully loaded library */
8209e86db79SHyon Kim /*
8219e86db79SHyon Kim * SM-HBA and HBAAPI has a seperate handler for GetVersion but
8229e86db79SHyon Kim * they have the same function signature so use the same variable here.
8239e86db79SHyon Kim */
8249e86db79SHyon Kim GetVersionFunc = FUNCCOMMON(lib_infop, GetVersionHandler);
8259e86db79SHyon Kim if (GetVersionFunc != NULL) {
8269e86db79SHyon Kim if (lib_infop->version == SMHBA) {
8279e86db79SHyon Kim /* Check the version of this library before loading */
8289e86db79SHyon Kim libversion = ((GetVersionFunc)());
8299e86db79SHyon Kim #ifdef NOTDEF /* save for a later time... when it matters */
8309e86db79SHyon Kim if (libversion < SMHBA_LIBVERSION) {
8319e86db79SHyon Kim goto dud_library;
8329e86db79SHyon Kim }
8339e86db79SHyon Kim #endif
8349e86db79SHyon Kim } else {
8359e86db79SHyon Kim /* Check the version of this library before loading */
8369e86db79SHyon Kim /* Actually... This wrapper is compatible with version 1 */
8379e86db79SHyon Kim libversion = ((GetVersionFunc)());
8389e86db79SHyon Kim #ifdef NOTDEF /* save for a later time... when it matters */
8399e86db79SHyon Kim if (libversion < HBA_LIBVERSION) {
8409e86db79SHyon Kim goto dud_library;
8419e86db79SHyon Kim }
8429e86db79SHyon Kim #endif
8439e86db79SHyon Kim }
8449e86db79SHyon Kim } else {
8459e86db79SHyon Kim /* ???Opportunity to send error msg, library error? */
8469e86db79SHyon Kim goto dud_library;
8479e86db79SHyon Kim }
8489e86db79SHyon Kim
8499e86db79SHyon Kim LoadLibraryFunc = FUNCCOMMON(lib_infop, LoadLibraryHandler);
8509e86db79SHyon Kim if (LoadLibraryFunc == NULL) {
8519e86db79SHyon Kim /* Hmmm, dont we need to flag this in a realy big way??? */
8529e86db79SHyon Kim /* How about messages to the system event logger ??? */
8539e86db79SHyon Kim /* ???Opportunity to send error msg, library error? */
8549e86db79SHyon Kim goto dud_library;
8559e86db79SHyon Kim }
8569e86db79SHyon Kim /* Initialize this library */
8579e86db79SHyon Kim status = ((LoadLibraryFunc)());
8589e86db79SHyon Kim if (status != HBA_STATUS_OK) {
8599e86db79SHyon Kim /* ???Opportunity to send error msg, library error? */
8609e86db79SHyon Kim continue;
8619e86db79SHyon Kim }
8629e86db79SHyon Kim /* successfully loaded library */
8639e86db79SHyon Kim lib_infop->status = HBA_LIBRARY_LOADED;
8649e86db79SHyon Kim
8659e86db79SHyon Kim dud_library: /* its also just the end of the loop */
8669e86db79SHyon Kim RegCloseKey(hkVendorLib);
8679e86db79SHyon Kim }
8689e86db79SHyon Kim RegCloseKey(hkSniaHba);
8699e86db79SHyon Kim
8709e86db79SHyon Kim #else /* Unix as opposed to Win32 */
8719e86db79SHyon Kim FILE *hbaconf;
8729e86db79SHyon Kim char fullline[512]; /* line read from HBA.conf */
8739e86db79SHyon Kim char *libraryname; /* Read in from file HBA.conf */
8749e86db79SHyon Kim char *librarypath; /* Read in from file HBA.conf */
8759e86db79SHyon Kim char hbaConfFilePath[256];
8769e86db79SHyon Kim char *charPtr;
8779e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
8789e86db79SHyon Kim
8799e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
8809e86db79SHyon Kim if (_hbaapi_librarylist != NULL) {
8819e86db79SHyon Kim (void) fprintf(stderr,
8829e86db79SHyon Kim "HBA_LoadLibrary: previously unfreed "
8839e86db79SHyon Kim "libraries exist, call HBA_FreeLibrary().\n");
8849e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
8859e86db79SHyon Kim return (HBA_STATUS_ERROR);
8869e86db79SHyon Kim }
8879e86db79SHyon Kim
8889e86db79SHyon Kim (void) strcpy(hbaConfFilePath, "/etc/smhba.conf");
8899e86db79SHyon Kim
8909e86db79SHyon Kim if ((hbaconf = fopen(hbaConfFilePath, "r")) == NULL) {
8919e86db79SHyon Kim (void) printf("Cannot open %s\n", hbaConfFilePath);
8929e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
8939e86db79SHyon Kim return (HBA_STATUS_ERROR);
8949e86db79SHyon Kim }
8959e86db79SHyon Kim
8969e86db79SHyon Kim /* Read in each line and load library */
8979e86db79SHyon Kim while ((hbaconf != NULL) &&
8989e86db79SHyon Kim (fgets(fullline, sizeof (fullline), hbaconf))) {
8999e86db79SHyon Kim /* Skip the comments... */
9009e86db79SHyon Kim if ((fullline[0] == '#') || (fullline[0] == '\n')) {
9019e86db79SHyon Kim continue;
9029e86db79SHyon Kim }
9039e86db79SHyon Kim
9049e86db79SHyon Kim /* grab first 'thing' in line (if its there) */
9059e86db79SHyon Kim if ((libraryname = strtok(fullline, " \t\n")) != NULL) {
9069e86db79SHyon Kim if (strlen(libraryname) >= 64) {
9079e86db79SHyon Kim (void) fprintf(stderr,
9089e86db79SHyon Kim "Library name(%s) in %s is > 64 characters\n",
9099e86db79SHyon Kim libraryname, hbaConfFilePath);
9109e86db79SHyon Kim }
9119e86db79SHyon Kim }
9129e86db79SHyon Kim /* grab second 'thing' in line (if its there) */
9139e86db79SHyon Kim if ((librarypath = strtok(NULL, " \t\n")) != NULL) {
9149e86db79SHyon Kim if (strlen(librarypath) >= 256) {
9159e86db79SHyon Kim (void) fprintf(stderr,
9169e86db79SHyon Kim "Library path(%s) in %s is > 256 characters\n",
9179e86db79SHyon Kim librarypath, hbaConfFilePath);
9189e86db79SHyon Kim }
9199e86db79SHyon Kim }
9209e86db79SHyon Kim
9219e86db79SHyon Kim /* there should be no more 'things' in the line */
9229e86db79SHyon Kim if ((charPtr = strtok(NULL, " \n\t")) != NULL) {
9239e86db79SHyon Kim (void) fprintf(stderr, "Extraneous characters (\"%s\") in %s\n",
9249e86db79SHyon Kim charPtr, hbaConfFilePath);
9259e86db79SHyon Kim }
9269e86db79SHyon Kim
9279e86db79SHyon Kim /* Continue to the next line if library name or path is invalid */
9289e86db79SHyon Kim if (libraryname == NULL ||
9299e86db79SHyon Kim strlen(libraryname) == 0 ||
9309e86db79SHyon Kim librarypath == NULL ||
9319e86db79SHyon Kim (strlen(librarypath) == 0)) {
9329e86db79SHyon Kim continue;
9339e86db79SHyon Kim }
9349e86db79SHyon Kim
9359e86db79SHyon Kim /*
9369e86db79SHyon Kim * Special case....
9379e86db79SHyon Kim * Look for loglevel
9389e86db79SHyon Kim */
9399e86db79SHyon Kim if (strcmp(libraryname, "debuglevel") == 0) {
9409e86db79SHyon Kim _hbaapi_debuglevel = strtol(librarypath, NULL, 10);
9419e86db79SHyon Kim /* error handling does the right thing automagically */
9429e86db79SHyon Kim continue;
9439e86db79SHyon Kim }
9449e86db79SHyon Kim
9459e86db79SHyon Kim lib_infop = (HBA_LIBRARY_INFO *)calloc(1, sizeof (HBA_LIBRARY_INFO));
9469e86db79SHyon Kim if (lib_infop == NULL) {
9479e86db79SHyon Kim (void) fprintf(stderr, "HBA_LoadLibrary: out of memeory\n");
9489e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
949*17c4dadfSRick McNeal fclose(hbaconf);
9509e86db79SHyon Kim return (HBA_STATUS_ERROR);
9519e86db79SHyon Kim }
9529e86db79SHyon Kim lib_infop->status = HBA_LIBRARY_NOT_LOADED;
9539e86db79SHyon Kim lib_infop->LibraryName = strdup(libraryname);
9549e86db79SHyon Kim lib_infop->LibraryPath = strdup(librarypath);
9559e86db79SHyon Kim lib_infop->numOfAdapters = 0;
9569e86db79SHyon Kim lib_infop->version = UNKNOWN;
9579e86db79SHyon Kim lib_infop->index = _hbaapi_total_library_count;
9589e86db79SHyon Kim _hbaapi_total_library_count++;
9599e86db79SHyon Kim lib_infop->next = _hbaapi_librarylist;
9609e86db79SHyon Kim _hbaapi_librarylist = lib_infop;
9619e86db79SHyon Kim
9629e86db79SHyon Kim /* Load the DLL now */
9639e86db79SHyon Kim if ((lib_infop->hLibrary = dlopen(librarypath, RTLD_LAZY)) == NULL) {
9649e86db79SHyon Kim /* printf("unable to load library %s\n", librarypath); */
9659e86db79SHyon Kim continue;
9669e86db79SHyon Kim }
9679e86db79SHyon Kim /* Call the registration function to get the list of pointers */
9689e86db79SHyon Kim RegisterSMHBAFunc = (SMHBARegisterLibraryFunc)
9699e86db79SHyon Kim dlsym(lib_infop->hLibrary, "SMHBA_RegisterLibrary");
9709e86db79SHyon Kim if (RegisterSMHBAFunc != NULL) {
9719e86db79SHyon Kim /*
9729e86db79SHyon Kim * Load the function points directly into
9739e86db79SHyon Kim * the table of functions
9749e86db79SHyon Kim */
9759e86db79SHyon Kim status = ((RegisterSMHBAFunc)
9769e86db79SHyon Kim (&lib_infop->ftable.smhbafunctionTable));
9779e86db79SHyon Kim if (status != HBA_STATUS_OK) {
9789e86db79SHyon Kim /* library not loaded */
9799e86db79SHyon Kim continue;
9809e86db79SHyon Kim } else {
9819e86db79SHyon Kim lib_infop->version = SMHBA;
9829e86db79SHyon Kim }
9839e86db79SHyon Kim } else {
9849e86db79SHyon Kim RegisterV2Func = (HBARegisterLibraryV2Func)
9859e86db79SHyon Kim dlsym(lib_infop->hLibrary, "HBA_RegisterLibraryV2");
9869e86db79SHyon Kim if (RegisterV2Func != NULL) {
9879e86db79SHyon Kim /*
9889e86db79SHyon Kim * Load the function points directly into
9899e86db79SHyon Kim * the table of functions
9909e86db79SHyon Kim */
9919e86db79SHyon Kim status = ((RegisterV2Func)((HBA_ENTRYPOINTSV2 *)
9929e86db79SHyon Kim (&lib_infop->ftable.functionTable)));
9939e86db79SHyon Kim if (status != HBA_STATUS_OK) {
9949e86db79SHyon Kim /* library not loaded */
9959e86db79SHyon Kim continue;
9969e86db79SHyon Kim } else {
9979e86db79SHyon Kim lib_infop->version = HBAAPIV2;
9989e86db79SHyon Kim }
9999e86db79SHyon Kim } else {
10009e86db79SHyon Kim /* Maybe the vendor library is only Rev1 */
10019e86db79SHyon Kim RegisterFunc = (HBARegisterLibraryFunc)
10029e86db79SHyon Kim dlsym(lib_infop->hLibrary, "HBA_RegisterLibrary");
10039e86db79SHyon Kim if (RegisterFunc == NULL) {
10049e86db79SHyon Kim /* This function is required */
10059e86db79SHyon Kim (void) fprintf(stderr,
10069e86db79SHyon Kim "HBA_LoadLibrary: vendor specific RegisterLibrary "
10079e86db79SHyon Kim "function not found. lib: %s\n", librarypath);
10089e86db79SHyon Kim DEBUG(1, "HBA_LoadLibrary: vendor specific "
10099e86db79SHyon Kim "RegisterLibrary function not found. lib: %s\n",
10109e86db79SHyon Kim librarypath, 0, 0);
10119e86db79SHyon Kim continue;
10129e86db79SHyon Kim }
10139e86db79SHyon Kim /*
10149e86db79SHyon Kim * Load the function points directly into
10159e86db79SHyon Kim * the table of functions
10169e86db79SHyon Kim */
10179e86db79SHyon Kim status = ((RegisterFunc)
10189e86db79SHyon Kim ((HBA_ENTRYPOINTS *)(&lib_infop->ftable.functionTable)));
10199e86db79SHyon Kim if (status != HBA_STATUS_OK) {
10209e86db79SHyon Kim /* library not loaded */
10219e86db79SHyon Kim (void) fprintf(stderr,
10229e86db79SHyon Kim "HBA_LoadLibrary: vendor specific RegisterLibrary "
10239e86db79SHyon Kim "function encountered an error. lib: %s\n",
10249e86db79SHyon Kim librarypath);
10259e86db79SHyon Kim DEBUG(1,
10269e86db79SHyon Kim "HBA_LoadLibrary: vendor specific RegisterLibrary "
10279e86db79SHyon Kim "function encountered an error. lib: %s\n",
10289e86db79SHyon Kim librarypath, 0, 0);
10299e86db79SHyon Kim continue;
10309e86db79SHyon Kim } else {
10319e86db79SHyon Kim lib_infop->version = HBAAPI;
10329e86db79SHyon Kim }
10339e86db79SHyon Kim }
10349e86db79SHyon Kim }
10359e86db79SHyon Kim
10369e86db79SHyon Kim /* successfully loaded library */
10379e86db79SHyon Kim /*
10389e86db79SHyon Kim * SM-HBA and HBAAPI has a seperate handler for GetVersion but
10399e86db79SHyon Kim * they have the same function signature so use the same variable here.
10409e86db79SHyon Kim */
10419e86db79SHyon Kim if ((GetVersionFunc = FUNCCOMMON(lib_infop, GetVersionHandler))
10429e86db79SHyon Kim == NULL) {
10439e86db79SHyon Kim continue;
10449e86db79SHyon Kim }
10459e86db79SHyon Kim if (lib_infop->version == SMHBA) {
10469e86db79SHyon Kim libversion = ((GetVersionFunc)());
10479e86db79SHyon Kim if (libversion < SMHBA_LIBVERSION) {
10489e86db79SHyon Kim (void) printf("Library version mismatch."
10499e86db79SHyon Kim "Got %d expected %d.\n",
10509e86db79SHyon Kim libversion, SMHBA_LIBVERSION);
10519e86db79SHyon Kim continue;
10529e86db79SHyon Kim }
10539e86db79SHyon Kim } else {
10549e86db79SHyon Kim libversion = ((GetVersionFunc)());
10559e86db79SHyon Kim /* Check the version of this library before loading */
10569e86db79SHyon Kim /* Actually... This wrapper is compatible with version 1 */
10579e86db79SHyon Kim if (libversion < HBA_LIBVERSION) {
10589e86db79SHyon Kim (void) printf("Library version mismatch."
10599e86db79SHyon Kim "Got %d expected %d.\n",
10609e86db79SHyon Kim libversion, HBA_LIBVERSION);
10619e86db79SHyon Kim continue;
10629e86db79SHyon Kim }
10639e86db79SHyon Kim }
10649e86db79SHyon Kim
10659e86db79SHyon Kim DEBUG(1, "%s libversion = %d", librarypath, libversion, 0);
10669e86db79SHyon Kim LoadLibraryFunc = FUNCCOMMON(lib_infop, LoadLibraryHandler);
10679e86db79SHyon Kim if (LoadLibraryFunc == NULL) {
10689e86db79SHyon Kim /* this function is required */
10699e86db79SHyon Kim (void) fprintf(stderr,
10709e86db79SHyon Kim "HBA_LoadLibrary: vendor specific LoadLibrary "
10719e86db79SHyon Kim "function not found. lib: %s\n", librarypath);
10729e86db79SHyon Kim DEBUG(1, "HBA_LoadLibrary: vendor specific LoadLibrary "
10739e86db79SHyon Kim "function not found. lib: %s\n", librarypath, 0, 0);
10749e86db79SHyon Kim continue;
10759e86db79SHyon Kim }
10769e86db79SHyon Kim /* Initialize this library */
10779e86db79SHyon Kim if ((status = ((LoadLibraryFunc)())) != HBA_STATUS_OK) {
10789e86db79SHyon Kim /* maybe this should be a printf so that we CANNOT miss it */
10799e86db79SHyon Kim (void) fprintf(stderr,
10809e86db79SHyon Kim "HBA_LoadLibrary: Encounterd and error loading: %s",
10819e86db79SHyon Kim librarypath);
10829e86db79SHyon Kim DEBUG(1, "Encounterd and error loading: %s", librarypath, 0, 0);
10839e86db79SHyon Kim DEBUG(1, " HBA_STATUS: %d", status, 0, 0);
10849e86db79SHyon Kim continue;
10859e86db79SHyon Kim }
10869e86db79SHyon Kim /* successfully loaded library */
10879e86db79SHyon Kim lib_infop->status = HBA_LIBRARY_LOADED;
10889e86db79SHyon Kim }
1089*17c4dadfSRick McNeal fclose(hbaconf);
10909e86db79SHyon Kim #endif /* WIN32 or UNIX */
10919e86db79SHyon Kim #ifdef POSIX_THREADS
10929e86db79SHyon Kim /*
10939e86db79SHyon Kim * The _hbaapi_LL_mutex is already grabbed to proctect the caller of
10949e86db79SHyon Kim * HBA_FreeLibrary() during loading.
10959e86db79SHyon Kim * The mutexes are already initialized
10969e86db79SHyon Kim * with PTHREAD_MUTEX_INITIALIZER. Do we need to init again?
10979e86db79SHyon Kim * Keeping the code from HBAAPI source...
10989e86db79SHyon Kim */
10999e86db79SHyon Kim ret = pthread_mutex_init(&_hbaapi_AL_mutex, NULL);
11009e86db79SHyon Kim if (ret == 0) {
11019e86db79SHyon Kim ret = pthread_mutex_init(&_hbaapi_AAE_mutex, NULL);
11029e86db79SHyon Kim }
11039e86db79SHyon Kim if (ret == 0) {
11049e86db79SHyon Kim ret = pthread_mutex_init(&_hbaapi_AE_mutex, NULL);
11059e86db79SHyon Kim }
11069e86db79SHyon Kim if (ret == 0) {
11079e86db79SHyon Kim ret = pthread_mutex_init(&_hbaapi_APE_mutex, NULL);
11089e86db79SHyon Kim }
11099e86db79SHyon Kim if (ret == 0) {
11109e86db79SHyon Kim ret = pthread_mutex_init(&_hbaapi_APSE_mutex, NULL);
11119e86db79SHyon Kim }
11129e86db79SHyon Kim if (ret == 0) {
11139e86db79SHyon Kim ret = pthread_mutex_init(&_hbaapi_TE_mutex, NULL);
11149e86db79SHyon Kim }
11159e86db79SHyon Kim if (ret == 0) {
11169e86db79SHyon Kim ret = pthread_mutex_init(&_smhba_AAE_mutex, NULL);
11179e86db79SHyon Kim }
11189e86db79SHyon Kim if (ret == 0) {
11199e86db79SHyon Kim ret = pthread_mutex_init(&_smhba_AE_mutex, NULL);
11209e86db79SHyon Kim }
11219e86db79SHyon Kim if (ret == 0) {
11229e86db79SHyon Kim ret = pthread_mutex_init(&_smhba_APE_mutex, NULL);
11239e86db79SHyon Kim }
11249e86db79SHyon Kim if (ret == 0) {
11259e86db79SHyon Kim ret = pthread_mutex_init(&_smhba_APSE_mutex, NULL);
11269e86db79SHyon Kim }
11279e86db79SHyon Kim if (ret == 0) {
11289e86db79SHyon Kim ret = pthread_mutex_init(&_smhba_TE_mutex, NULL);
11299e86db79SHyon Kim }
11309e86db79SHyon Kim if (ret == 0) {
11319e86db79SHyon Kim ret = pthread_mutex_init(&_hbaapi_LE_mutex, NULL);
11329e86db79SHyon Kim }
11339e86db79SHyon Kim if (ret != 0) {
11349e86db79SHyon Kim perror("pthread_mutex_init - HBA_LoadLibrary");
11359e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
11369e86db79SHyon Kim return (HBA_STATUS_ERROR);
11379e86db79SHyon Kim }
11389e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
11399e86db79SHyon Kim #elif defined(WIN32)
11409e86db79SHyon Kim InitializeCriticalSection(&_hbaapi_LL_mutex);
11419e86db79SHyon Kim InitializeCriticalSection(&_hbaapi_AL_mutex);
11429e86db79SHyon Kim InitializeCriticalSection(&_hbaapi_AAE_mutex);
11439e86db79SHyon Kim InitializeCriticalSection(&_hbaapi_AE_mutex);
11449e86db79SHyon Kim InitializeCriticalSection(&_hbaapi_APE_mutex);
11459e86db79SHyon Kim InitializeCriticalSection(&_hbaapi_APSE_mutex);
11469e86db79SHyon Kim InitializeCriticalSection(&_hbaapi_TE_mutex);
11479e86db79SHyon Kim InitializeCriticalSection(&_hbaapi_LE_mutex);
11489e86db79SHyon Kim InitializeCriticalSection(&_smhba_AAE_mutex);
11499e86db79SHyon Kim InitializeCriticalSection(&_smhba_AE_mutex);
11509e86db79SHyon Kim InitializeCriticalSection(&_smhba_APE_mutex);
11519e86db79SHyon Kim InitializeCriticalSection(&_smhba_APSE_mutex);
11529e86db79SHyon Kim InitializeCriticalSection(&_smhba_TE_mutex);
11539e86db79SHyon Kim #endif
11549e86db79SHyon Kim
11559e86db79SHyon Kim return (HBA_STATUS_OK);
11569e86db79SHyon Kim }
11579e86db79SHyon Kim
11589e86db79SHyon Kim HBA_STATUS
HBA_FreeLibrary()11599e86db79SHyon Kim HBA_FreeLibrary() {
11609e86db79SHyon Kim HBAFreeLibraryFunc FreeLibraryFunc;
11619e86db79SHyon Kim /* LINTED E_FUNC_SET_NOT_USED */
1162e8dc66e7SToomas Soome HBA_STATUS status __unused;
11639e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
11649e86db79SHyon Kim HBA_LIBRARY_INFO *lib_next;
11659e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM
11669e86db79SHyon Kim ***listp;
11679e86db79SHyon Kim HBA_ADAPTER_INFO *adapt_infop;
11689e86db79SHyon Kim HBA_ADAPTER_INFO *adapt_next;
11699e86db79SHyon Kim
11709e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
11719e86db79SHyon Kim if (_hbaapi_librarylist == NULL) {
11729e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
11739e86db79SHyon Kim return (HBA_STATUS_ERROR_NOT_LOADED);
11749e86db79SHyon Kim }
11759e86db79SHyon Kim
11769e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AL_mutex);
11779e86db79SHyon Kim
11789e86db79SHyon Kim DEBUG(1, "HBA_FreeLibrary()", 0, 0, 0);
11799e86db79SHyon Kim for (lib_infop = _hbaapi_librarylist; lib_infop != NULL;
11809e86db79SHyon Kim lib_infop = lib_next) {
11819e86db79SHyon Kim lib_next = lib_infop->next;
11829e86db79SHyon Kim if (lib_infop->status == HBA_LIBRARY_LOADED) {
11839e86db79SHyon Kim FreeLibraryFunc = FUNCCOMMON(lib_infop, FreeLibraryHandler);
11849e86db79SHyon Kim if (FreeLibraryFunc != NULL) {
11859e86db79SHyon Kim /* Free this library */
11869e86db79SHyon Kim status = ((FreeLibraryFunc)());
11879e86db79SHyon Kim DEBUG(1, "HBA_FreeLibrary() Failed %d", status, 0, 0);
11889e86db79SHyon Kim }
11899e86db79SHyon Kim #ifdef WIN32
11909e86db79SHyon Kim FreeLibrary(lib_infop->hLibrary); /* Unload DLL from memory */
11919e86db79SHyon Kim #else
11929e86db79SHyon Kim (void) dlclose(lib_infop->hLibrary); /* Unload DLL from memory */
11939e86db79SHyon Kim #endif
11949e86db79SHyon Kim }
11959e86db79SHyon Kim #ifndef WIN32
11969e86db79SHyon Kim free(lib_infop->LibraryName);
11979e86db79SHyon Kim #endif
11989e86db79SHyon Kim free(lib_infop->LibraryPath);
11999e86db79SHyon Kim free(lib_infop);
12009e86db79SHyon Kim
12019e86db79SHyon Kim }
12029e86db79SHyon Kim _hbaapi_librarylist = NULL;
12039e86db79SHyon Kim /*
12049e86db79SHyon Kim * OK, now all functions are disabled except for LoadLibrary,
12059e86db79SHyon Kim * Hope no other thread calls it before we have returned
12069e86db79SHyon Kim */
12079e86db79SHyon Kim _hbaapi_total_library_count = 0;
12089e86db79SHyon Kim
12099e86db79SHyon Kim for (adapt_infop = _hbaapi_adapterlist;
12109e86db79SHyon Kim adapt_infop != NULL;
12119e86db79SHyon Kim adapt_infop = adapt_next) {
12129e86db79SHyon Kim adapt_next = adapt_infop->next;
12139e86db79SHyon Kim free(adapt_infop->name);
12149e86db79SHyon Kim free(adapt_infop);
12159e86db79SHyon Kim }
12169e86db79SHyon Kim _hbaapi_adapterlist = NULL;
12179e86db79SHyon Kim _hbaapi_total_adapter_count = 0;
12189e86db79SHyon Kim
12199e86db79SHyon Kim /*
12209e86db79SHyon Kim * Free up the callbacks, this is not the most efficient, but it works
12219e86db79SHyon Kim */
12229e86db79SHyon Kim while ((volatile HBA_ADAPTERCALLBACK_ELEM *)
12239e86db79SHyon Kim _hbaapi_adapteraddevents_callback_list
12249e86db79SHyon Kim != NULL) {
12259e86db79SHyon Kim (void) local_remove_callback((HBA_CALLBACKHANDLE)
12269e86db79SHyon Kim _hbaapi_adapteraddevents_callback_list);
12279e86db79SHyon Kim }
12289e86db79SHyon Kim while ((volatile HBA_ADAPTERCALLBACK_ELEM *)
12299e86db79SHyon Kim _smhba_adapteraddevents_callback_list
12309e86db79SHyon Kim != NULL) {
12319e86db79SHyon Kim (void) local_remove_callback((HBA_CALLBACKHANDLE)
12329e86db79SHyon Kim _smhba_adapteraddevents_callback_list);
12339e86db79SHyon Kim }
12349e86db79SHyon Kim for (listp = cb_lists_array; *listp != NULL; listp++) {
12359e86db79SHyon Kim while ((volatile HBA_ADAPTERCALLBACK_ELEM ***)**listp != NULL) {
12369e86db79SHyon Kim (void) local_remove_callback((HBA_CALLBACKHANDLE)**listp);
12379e86db79SHyon Kim }
12389e86db79SHyon Kim }
12399e86db79SHyon Kim
12409e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AL_mutex);
12419e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
12429e86db79SHyon Kim
12439e86db79SHyon Kim #ifdef USESYSLOG
12449e86db79SHyon Kim closelog();
12459e86db79SHyon Kim #endif
12469e86db79SHyon Kim #ifdef USELOGFILE
12479e86db79SHyon Kim if (_hbaapi_debug_fd != NULL) {
12489e86db79SHyon Kim fclose(_hbaapi_debug_fd);
12499e86db79SHyon Kim }
12509e86db79SHyon Kim _hbaapi_debug_fd = NULL;
12519e86db79SHyon Kim #endif
12529e86db79SHyon Kim #ifdef POSIX_THREADS
12539e86db79SHyon Kim /* this will unlock them as well, but who cares */
12549e86db79SHyon Kim (void) pthread_mutex_destroy(&_hbaapi_LE_mutex);
12559e86db79SHyon Kim (void) pthread_mutex_destroy(&_hbaapi_TE_mutex);
12569e86db79SHyon Kim (void) pthread_mutex_destroy(&_hbaapi_APSE_mutex);
12579e86db79SHyon Kim (void) pthread_mutex_destroy(&_hbaapi_APE_mutex);
12589e86db79SHyon Kim (void) pthread_mutex_destroy(&_hbaapi_AE_mutex);
12599e86db79SHyon Kim (void) pthread_mutex_destroy(&_hbaapi_AAE_mutex);
12609e86db79SHyon Kim (void) pthread_mutex_destroy(&_smhba_TE_mutex);
12619e86db79SHyon Kim (void) pthread_mutex_destroy(&_smhba_APSE_mutex);
12629e86db79SHyon Kim (void) pthread_mutex_destroy(&_smhba_APE_mutex);
12639e86db79SHyon Kim (void) pthread_mutex_destroy(&_smhba_AE_mutex);
12649e86db79SHyon Kim (void) pthread_mutex_destroy(&_smhba_AAE_mutex);
12659e86db79SHyon Kim (void) pthread_mutex_destroy(&_hbaapi_AL_mutex);
12669e86db79SHyon Kim (void) pthread_mutex_destroy(&_hbaapi_LL_mutex);
12679e86db79SHyon Kim #elif defined(WIN32)
12689e86db79SHyon Kim DeleteCriticalSection(&_hbaapi_LL_mutex);
12699e86db79SHyon Kim DeleteCriticalSection(&_hbaapi_AL_mutex);
12709e86db79SHyon Kim DeleteCriticalSection(&_hbaapi_AAE_mutex);
12719e86db79SHyon Kim DeleteCriticalSection(&_hbaapi_AE_mutex);
12729e86db79SHyon Kim DeleteCriticalSection(&_hbaapi_APE_mutex);
12739e86db79SHyon Kim DeleteCriticalSection(&_hbaapi_APSE_mutex);
12749e86db79SHyon Kim DeleteCriticalSection(&_hbaapi_TE_mutex);
12759e86db79SHyon Kim DeleteCriticalSection(&_hbaapi_LE_mutex);
12769e86db79SHyon Kim DeleteCriticalSection(&_smhba_TE_mutex);
12779e86db79SHyon Kim DeleteCriticalSection(&_smhba_APSE_mutex);
12789e86db79SHyon Kim DeleteCriticalSection(&_smhba_APE_mutex);
12799e86db79SHyon Kim DeleteCriticalSection(&_smhba_AE_mutex);
12809e86db79SHyon Kim DeleteCriticalSection(&_smhba_AAE_mutex);
12819e86db79SHyon Kim #endif
12829e86db79SHyon Kim
12839e86db79SHyon Kim return (HBA_STATUS_OK);
12849e86db79SHyon Kim }
12859e86db79SHyon Kim
12869e86db79SHyon Kim /*
12879e86db79SHyon Kim * The API used to use fixed size tables as its primary data structure.
12889e86db79SHyon Kim * Indexing from 1 to N identified each adapters. Now the adapters are
12899e86db79SHyon Kim * on a linked list. There is a unique "index" foreach each adapter.
12909e86db79SHyon Kim * Adapters always keep their index, even if they are removed from the
12919e86db79SHyon Kim * hardware. The only time the indexing is reset is on HBA_FreeLibrary
12929e86db79SHyon Kim */
12939e86db79SHyon Kim HBA_UINT32
HBA_GetNumberOfAdapters()12949e86db79SHyon Kim HBA_GetNumberOfAdapters()
12959e86db79SHyon Kim {
12969e86db79SHyon Kim int j = 0;
12979e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
12989e86db79SHyon Kim HBAGetNumberOfAdaptersFunc GetNumberOfAdaptersFunc;
12999e86db79SHyon Kim HBAGetAdapterNameFunc GetAdapterNameFunc;
13009e86db79SHyon Kim HBA_BOOLEAN found_name;
13019e86db79SHyon Kim HBA_ADAPTER_INFO *adapt_infop;
13029e86db79SHyon Kim HBA_STATUS status;
13039e86db79SHyon Kim
13049e86db79SHyon Kim char adaptername[256];
13059e86db79SHyon Kim int num_adapters; /* local */
13069e86db79SHyon Kim
13079e86db79SHyon Kim if (_hbaapi_librarylist == NULL) {
13089e86db79SHyon Kim return (0);
13099e86db79SHyon Kim }
13109e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex); /* pay attention to order */
13119e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AL_mutex);
13129e86db79SHyon Kim
13139e86db79SHyon Kim for (lib_infop = _hbaapi_librarylist;
13149e86db79SHyon Kim lib_infop != NULL;
13159e86db79SHyon Kim lib_infop = lib_infop->next) {
13169e86db79SHyon Kim
13179e86db79SHyon Kim if (lib_infop->status != HBA_LIBRARY_LOADED) {
13189e86db79SHyon Kim continue;
13199e86db79SHyon Kim }
13209e86db79SHyon Kim
13219e86db79SHyon Kim GetNumberOfAdaptersFunc =
13229e86db79SHyon Kim FUNCCOMMON(lib_infop, GetNumberOfAdaptersHandler);
13239e86db79SHyon Kim if (GetNumberOfAdaptersFunc == NULL) {
13249e86db79SHyon Kim continue;
13259e86db79SHyon Kim }
13269e86db79SHyon Kim num_adapters = ((GetNumberOfAdaptersFunc)());
13279e86db79SHyon Kim #ifndef WIN32
13289e86db79SHyon Kim DEBUG(1, "HBAAPI: num_adapters for %s = %d\n",
13299e86db79SHyon Kim lib_infop->LibraryName, num_adapters, 0);
13309e86db79SHyon Kim #else
13319e86db79SHyon Kim DEBUG(1, "HBAAPI: num_adapters for %s = %d\n",
13329e86db79SHyon Kim lib_infop->LibraryPath, num_adapters, 0);
13339e86db79SHyon Kim #endif
13349e86db79SHyon Kim
13359e86db79SHyon Kim /* Also get the names of all the adapters here and cache */
13369e86db79SHyon Kim GetAdapterNameFunc = FUNCCOMMON(lib_infop, GetAdapterNameHandler);
13379e86db79SHyon Kim if (GetAdapterNameFunc == NULL) {
13389e86db79SHyon Kim continue;
13399e86db79SHyon Kim }
13409e86db79SHyon Kim
13419e86db79SHyon Kim for (j = 0; j < num_adapters; j++) {
13429e86db79SHyon Kim found_name = 0;
13439e86db79SHyon Kim status = (GetAdapterNameFunc)(j, (char *)&adaptername);
13449e86db79SHyon Kim if (status == HBA_STATUS_OK) {
13459e86db79SHyon Kim for (adapt_infop = _hbaapi_adapterlist;
13469e86db79SHyon Kim adapt_infop != NULL;
13479e86db79SHyon Kim adapt_infop = adapt_infop->next) {
13489e86db79SHyon Kim /*
13499e86db79SHyon Kim * check for duplicates, really,
13509e86db79SHyon Kim * this may just be a second
13519e86db79SHyon Kim * call to this function
13529e86db79SHyon Kim * ??? how do we know when a name becomes stale?
13539e86db79SHyon Kim */
13549e86db79SHyon Kim if (strcmp(adaptername, adapt_infop->name) == 0) {
13559e86db79SHyon Kim /* already got this one */
13569e86db79SHyon Kim found_name++;
13579e86db79SHyon Kim break;
13589e86db79SHyon Kim }
13599e86db79SHyon Kim }
13609e86db79SHyon Kim if (found_name != 0) {
13619e86db79SHyon Kim continue;
13629e86db79SHyon Kim }
13639e86db79SHyon Kim }
13649e86db79SHyon Kim
13659e86db79SHyon Kim adapt_infop = (HBA_ADAPTER_INFO *)
13669e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTER_INFO));
13679e86db79SHyon Kim if (adapt_infop == NULL) {
13689e86db79SHyon Kim #ifndef WIN32
13699e86db79SHyon Kim (void) fprintf(stderr,
13709e86db79SHyon Kim "HBA_GetNumberOfAdapters: calloc failed"
13719e86db79SHyon Kim " on sizeof:%lu\n",
13729e86db79SHyon Kim (unsigned long)(sizeof (HBA_ADAPTER_INFO)));
13739e86db79SHyon Kim #endif
13749e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AL_mutex);
13759e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex,
13769e86db79SHyon Kim _hbaapi_total_adapter_count);
13779e86db79SHyon Kim }
13789e86db79SHyon Kim if ((adapt_infop->GNstatus = status) == HBA_STATUS_OK) {
13799e86db79SHyon Kim adapt_infop->name = strdup(adaptername);
13809e86db79SHyon Kim } else {
13819e86db79SHyon Kim char dummyname[512];
13829e86db79SHyon Kim (void) sprintf(dummyname, "NULLADAPTER-%255s-%03d",
13839e86db79SHyon Kim lib_infop->LibraryPath, _hbaapi_total_adapter_count);
13849e86db79SHyon Kim dummyname[511] = '\0';
13859e86db79SHyon Kim adapt_infop->name = strdup(dummyname);
13869e86db79SHyon Kim }
13879e86db79SHyon Kim lib_infop->numOfAdapters++;
13889e86db79SHyon Kim adapt_infop->library = lib_infop;
13899e86db79SHyon Kim adapt_infop->next = _hbaapi_adapterlist;
13909e86db79SHyon Kim adapt_infop->index = _hbaapi_total_adapter_count;
13919e86db79SHyon Kim _hbaapi_adapterlist = adapt_infop;
13929e86db79SHyon Kim _hbaapi_total_adapter_count++;
13939e86db79SHyon Kim }
13949e86db79SHyon Kim }
13959e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AL_mutex);
13969e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, _hbaapi_total_adapter_count);
13979e86db79SHyon Kim }
13989e86db79SHyon Kim
13999e86db79SHyon Kim HBA_STATUS
HBA_GetAdapterName(HBA_UINT32 adapterindex,char * adaptername)14009e86db79SHyon Kim HBA_GetAdapterName(
14019e86db79SHyon Kim HBA_UINT32 adapterindex,
14029e86db79SHyon Kim char *adaptername)
14039e86db79SHyon Kim {
14049e86db79SHyon Kim HBA_ADAPTER_INFO *adapt_infop;
14059e86db79SHyon Kim HBA_STATUS ret = HBA_STATUS_ERROR_ILLEGAL_INDEX;
14069e86db79SHyon Kim
14079e86db79SHyon Kim if (adaptername == NULL) {
14080778188fSHengqing Hu DEBUG(1, "HBA_GetAdapterName: NULL pointer adaptername",
14099e86db79SHyon Kim 0, 0, 0);
14109e86db79SHyon Kim return (HBA_STATUS_ERROR_ARG);
14119e86db79SHyon Kim }
14129e86db79SHyon Kim
14139e86db79SHyon Kim /*
14149e86db79SHyon Kim * The adapter index is from old code, but we have
14159e86db79SHyon Kim * to support it. Go down the list looking for
14169e86db79SHyon Kim * the adapter
14179e86db79SHyon Kim */
14189e86db79SHyon Kim ARE_WE_INITED();
14199e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AL_mutex);
14209e86db79SHyon Kim *adaptername = '\0';
14219e86db79SHyon Kim for (adapt_infop = _hbaapi_adapterlist;
14229e86db79SHyon Kim adapt_infop != NULL;
14239e86db79SHyon Kim adapt_infop = adapt_infop->next) {
14249e86db79SHyon Kim
14259e86db79SHyon Kim if (adapt_infop->index == adapterindex) {
14269e86db79SHyon Kim if (adapt_infop->name != NULL &&
14279e86db79SHyon Kim adapt_infop->GNstatus == HBA_STATUS_OK) {
14289e86db79SHyon Kim (void) strcpy(adaptername, adapt_infop->name);
14299e86db79SHyon Kim } else {
14309e86db79SHyon Kim *adaptername = '\0';
14319e86db79SHyon Kim }
14329e86db79SHyon Kim ret = adapt_infop->GNstatus;
14339e86db79SHyon Kim break;
14349e86db79SHyon Kim }
14359e86db79SHyon Kim }
14369e86db79SHyon Kim DEBUG(2, "GetAdapterName for index:%d ->%s",
14379e86db79SHyon Kim adapterindex, adaptername, 0);
14389e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_AL_mutex, ret);
14399e86db79SHyon Kim }
14409e86db79SHyon Kim
14419e86db79SHyon Kim HBA_HANDLE
HBA_OpenAdapter(char * adaptername)14429e86db79SHyon Kim HBA_OpenAdapter(char *adaptername)
14439e86db79SHyon Kim {
14449e86db79SHyon Kim HBA_HANDLE handle;
14459e86db79SHyon Kim HBAOpenAdapterFunc OpenAdapterFunc;
14469e86db79SHyon Kim HBA_ADAPTER_INFO *adapt_infop;
14479e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
14489e86db79SHyon Kim
14499e86db79SHyon Kim DEBUG(2, "OpenAdapter: %s", adaptername, 0, 0);
14509e86db79SHyon Kim
14519e86db79SHyon Kim handle = HBA_HANDLE_INVALID;
14529e86db79SHyon Kim if (_hbaapi_librarylist == NULL) {
14539e86db79SHyon Kim return (handle);
14549e86db79SHyon Kim }
14559e86db79SHyon Kim if (adaptername == NULL) {
14560778188fSHengqing Hu DEBUG(1, "HBA_OpenAdapter: NULL pointer adaptername",
14579e86db79SHyon Kim 0, 0, 0);
14589e86db79SHyon Kim return (handle);
14599e86db79SHyon Kim }
14609e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AL_mutex);
14619e86db79SHyon Kim for (adapt_infop = _hbaapi_adapterlist;
14629e86db79SHyon Kim adapt_infop != NULL;
14639e86db79SHyon Kim adapt_infop = adapt_infop->next) {
14649e86db79SHyon Kim if (strcmp(adaptername, adapt_infop->name) != 0) {
14659e86db79SHyon Kim continue;
14669e86db79SHyon Kim }
14679e86db79SHyon Kim lib_infop = adapt_infop->library;
14689e86db79SHyon Kim OpenAdapterFunc = FUNCCOMMON(lib_infop, OpenAdapterHandler);
14699e86db79SHyon Kim
14709e86db79SHyon Kim if (OpenAdapterFunc != NULL) {
14719e86db79SHyon Kim /* retrieve the vendor handle */
14729e86db79SHyon Kim handle = (OpenAdapterFunc)(adaptername);
14739e86db79SHyon Kim if (handle != 0) {
14749e86db79SHyon Kim /* or this with the library index to get the common handle */
14759e86db79SHyon Kim handle = HBA_HANDLE_FROM_LOCAL(lib_infop->index, handle);
14769e86db79SHyon Kim }
14779e86db79SHyon Kim }
14789e86db79SHyon Kim break;
14799e86db79SHyon Kim }
14809e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_AL_mutex, handle);
14819e86db79SHyon Kim }
14829e86db79SHyon Kim
14839e86db79SHyon Kim /*
14849e86db79SHyon Kim * Finding an adapter with matching WWN.
14859e86db79SHyon Kim */
14869e86db79SHyon Kim HBA_STATUS
HBA_OpenAdapterByWWN(HBA_HANDLE * phandle,HBA_WWN nodeWWN)14879e86db79SHyon Kim HBA_OpenAdapterByWWN(HBA_HANDLE *phandle, HBA_WWN nodeWWN) {
14889e86db79SHyon Kim HBA_HANDLE handle;
14899e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
14909e86db79SHyon Kim HBAGetNumberOfAdaptersFunc
14919e86db79SHyon Kim GetNumberOfAdaptersFunc;
14929e86db79SHyon Kim HBAOpenAdapterByWWNFunc
14939e86db79SHyon Kim OpenAdapterFunc;
14949e86db79SHyon Kim HBA_STATUS status;
14959e86db79SHyon Kim
14969e86db79SHyon Kim DEBUG(2, "OpenAdapterByWWN: %s", WWN2STR1(&nodeWWN), 0, 0);
14979e86db79SHyon Kim ARE_WE_INITED();
14989e86db79SHyon Kim
14999e86db79SHyon Kim *phandle = HBA_HANDLE_INVALID;
15009e86db79SHyon Kim
15019e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
15029e86db79SHyon Kim for (lib_infop = _hbaapi_librarylist;
15039e86db79SHyon Kim lib_infop != NULL;
15049e86db79SHyon Kim lib_infop = lib_infop->next) {
15059e86db79SHyon Kim
15069e86db79SHyon Kim status = HBA_STATUS_ERROR_ILLEGAL_WWN;
15079e86db79SHyon Kim
15089e86db79SHyon Kim if (lib_infop->status != HBA_LIBRARY_LOADED) {
15099e86db79SHyon Kim continue;
15109e86db79SHyon Kim }
15119e86db79SHyon Kim
15129e86db79SHyon Kim /* only for HBAAPIV2 */
15139e86db79SHyon Kim if (lib_infop->version != HBAAPIV2) {
15149e86db79SHyon Kim continue;
15159e86db79SHyon Kim }
15169e86db79SHyon Kim
15179e86db79SHyon Kim GetNumberOfAdaptersFunc =
15189e86db79SHyon Kim FUNCCOMMON(lib_infop, GetNumberOfAdaptersHandler);
15199e86db79SHyon Kim if (GetNumberOfAdaptersFunc == NULL) {
15209e86db79SHyon Kim continue;
15219e86db79SHyon Kim }
15229e86db79SHyon Kim
15239e86db79SHyon Kim /* look for new hardware */
15249e86db79SHyon Kim (void) ((GetNumberOfAdaptersFunc)());
15259e86db79SHyon Kim
15269e86db79SHyon Kim OpenAdapterFunc =
15279e86db79SHyon Kim lib_infop->ftable.functionTable.OpenAdapterByWWNHandler;
15289e86db79SHyon Kim if (OpenAdapterFunc == NULL) {
15299e86db79SHyon Kim continue;
15309e86db79SHyon Kim }
15319e86db79SHyon Kim /*
15329e86db79SHyon Kim * We do not know if the WWN is known by this vendor,
15339e86db79SHyon Kim * just try it
15349e86db79SHyon Kim */
15359e86db79SHyon Kim if ((status = (OpenAdapterFunc)(&handle, nodeWWN)) != HBA_STATUS_OK) {
15369e86db79SHyon Kim continue;
15379e86db79SHyon Kim }
15389e86db79SHyon Kim /* OK, make a vendor non-specific handle */
15399e86db79SHyon Kim *phandle = HBA_HANDLE_FROM_LOCAL(lib_infop->index, handle);
15409e86db79SHyon Kim status = HBA_STATUS_OK;
15419e86db79SHyon Kim break;
15429e86db79SHyon Kim }
15439e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
15449e86db79SHyon Kim }
15459e86db79SHyon Kim
15469e86db79SHyon Kim void
HBA_RefreshAdapterConfiguration()15479e86db79SHyon Kim HBA_RefreshAdapterConfiguration() {
15489e86db79SHyon Kim DEBUG(2, "HBA_RefreshAdapterConfiguration", 0, 0, 0);
15499e86db79SHyon Kim (void) HBA_GetNumberOfAdapters();
15509e86db79SHyon Kim }
15519e86db79SHyon Kim
15529e86db79SHyon Kim HBA_UINT32
HBA_GetVersion()15539e86db79SHyon Kim HBA_GetVersion() {
15549e86db79SHyon Kim DEBUG(2, "HBA_GetVersion", 0, 0, 0);
15559e86db79SHyon Kim return (HBA_LIBVERSION);
15569e86db79SHyon Kim }
15579e86db79SHyon Kim
15589e86db79SHyon Kim /*
15599e86db79SHyon Kim * This function is VERY OS dependent. Wing it as best you can.
15609e86db79SHyon Kim */
15619e86db79SHyon Kim HBA_UINT32
HBA_GetWrapperLibraryAttributes(HBA_LIBRARYATTRIBUTES * attributes)15629e86db79SHyon Kim HBA_GetWrapperLibraryAttributes(
15639e86db79SHyon Kim HBA_LIBRARYATTRIBUTES *attributes)
15649e86db79SHyon Kim {
15659e86db79SHyon Kim
15669e86db79SHyon Kim DEBUG(2, "HBA_GetWrapperLibraryAttributes", 0, 0, 0);
15679e86db79SHyon Kim
15689e86db79SHyon Kim if (attributes == NULL) {
15699e86db79SHyon Kim DEBUG(1, "HBA_GetWrapperLibraryAttributes:"
15709e86db79SHyon Kim "NULL pointer attributes",
15719e86db79SHyon Kim 0, 0, 0);
15729e86db79SHyon Kim return (HBA_STATUS_ERROR_ARG);
15739e86db79SHyon Kim }
15749e86db79SHyon Kim
15759e86db79SHyon Kim (void) memset(attributes, 0, sizeof (HBA_LIBRARYATTRIBUTES));
15769e86db79SHyon Kim
15779e86db79SHyon Kim #if defined(SOLARIS)
15789e86db79SHyon Kim if ((handle = dlopen("libHBAAPI.so", RTLD_NOW)) != NULL) {
15799e86db79SHyon Kim if (dlinfo(handle, RTLD_DI_LINKMAP, &map) >= 0) {
15809e86db79SHyon Kim for (mp = map; mp != NULL; mp = mp->l_next) {
15819e86db79SHyon Kim if (strlen(map->l_name) < 256) {
15829e86db79SHyon Kim (void) strcpy(attributes->LibPath, map->l_name);
15839e86db79SHyon Kim }
15849e86db79SHyon Kim }
15859e86db79SHyon Kim }
15869e86db79SHyon Kim }
15879e86db79SHyon Kim #elif defined(WIN32)
15889e86db79SHyon Kim HMODULE module;
15899e86db79SHyon Kim
15909e86db79SHyon Kim /* No need to do anything with the module handle */
15919e86db79SHyon Kim /* It wasn't alloocated so it doesn't need to be freed */
15929e86db79SHyon Kim module = GetModuleHandle("HBAAPI");
15939e86db79SHyon Kim if (module != NULL) {
15949e86db79SHyon Kim if (GetModuleFileName(module, attributes->LibPath,
15959e86db79SHyon Kim sizeof (attributes->LibPath)) == 0) {
15969e86db79SHyon Kim attributes->LibPath[0] = '\0';
15979e86db79SHyon Kim }
15989e86db79SHyon Kim }
15999e86db79SHyon Kim #endif
16009e86db79SHyon Kim #if defined(VENDOR)
16019e86db79SHyon Kim (void) strcpy(attributes->VName, VENDOR);
16029e86db79SHyon Kim #else
16039e86db79SHyon Kim attributes->VName[0] = '\0';
16049e86db79SHyon Kim #endif
16059e86db79SHyon Kim #if defined(VERSION)
16069e86db79SHyon Kim (void) strcpy(attributes->VVersion, VERSION);
16079e86db79SHyon Kim #else
16089e86db79SHyon Kim attributes->VVersion[0] = '\0';
16099e86db79SHyon Kim #endif
16109e86db79SHyon Kim #if defined(BUILD_DATE)
16119e86db79SHyon Kim #if defined(WIN32)
16129e86db79SHyon Kim int matchCount;
16139e86db79SHyon Kim matchCount = sscanf(BUILD_DATE, "%u/%u/%u %u:%u:%u",
16149e86db79SHyon Kim &attributes->build_date.tm_year,
16159e86db79SHyon Kim &attributes->build_date.tm_mon,
16169e86db79SHyon Kim &attributes->build_date.tm_mday,
16179e86db79SHyon Kim &attributes->build_date.tm_hour,
16189e86db79SHyon Kim &attributes->build_date.tm_min,
16199e86db79SHyon Kim &attributes->build_date.tm_sec);
16209e86db79SHyon Kim
16219e86db79SHyon Kim if (matchCount != 6) {
16229e86db79SHyon Kim memset(&attributes->build_date, 0, sizeof (struct tm));
16239e86db79SHyon Kim } else {
16249e86db79SHyon Kim attributes->build_date.tm_year -= 1900;
16259e86db79SHyon Kim attributes->build_date.tm_isdst = -1;
16269e86db79SHyon Kim }
16279e86db79SHyon Kim #else
16289e86db79SHyon Kim if (strptime(BUILD_DATE,
16299e86db79SHyon Kim "%Y/%m/%d %T %Z", &(attributes->build_date)) == NULL) {
16309e86db79SHyon Kim (void) memset(&attributes->build_date, 0, sizeof (struct tm));
16319e86db79SHyon Kim }
16329e86db79SHyon Kim #endif
16339e86db79SHyon Kim #else
16349e86db79SHyon Kim (void) memset(&attributes->build_date, 0, sizeof (struct tm));
16359e86db79SHyon Kim #endif
16369e86db79SHyon Kim return (2);
16379e86db79SHyon Kim }
16389e86db79SHyon Kim
16399e86db79SHyon Kim /*
16409e86db79SHyon Kim * Callback registation and handling
16419e86db79SHyon Kim */
16429e86db79SHyon Kim HBA_STATUS
HBA_RemoveCallback(HBA_CALLBACKHANDLE cbhandle)16439e86db79SHyon Kim HBA_RemoveCallback(HBA_CALLBACKHANDLE cbhandle) {
16449e86db79SHyon Kim HBA_STATUS status;
16459e86db79SHyon Kim
16469e86db79SHyon Kim DEBUG(2, "HBA_RemoveCallback", 0, 0, 0);
16479e86db79SHyon Kim ARE_WE_INITED();
16489e86db79SHyon Kim
16499e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
16509e86db79SHyon Kim status = local_remove_callback(cbhandle);
16519e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
16529e86db79SHyon Kim }
16539e86db79SHyon Kim
16549e86db79SHyon Kim /* Adapter Add Events ************************************************* */
16559e86db79SHyon Kim static void
16569e86db79SHyon Kim /* LINTED E_FUNC_ARG_UNUSED */
adapteraddevents_callback(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType)16579e86db79SHyon Kim adapteraddevents_callback(void *data, HBA_WWN PortWWN, HBA_UINT32 eventType) {
16589e86db79SHyon Kim HBA_ALLADAPTERSCALLBACK_ELEM *cbp;
16599e86db79SHyon Kim
16609e86db79SHyon Kim DEBUG(3, "AddAdapterEvent, port: %s", WWN2STR1(&PortWWN), 0, 0);
16619e86db79SHyon Kim
16629e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AAE_mutex);
16639e86db79SHyon Kim for (cbp = _hbaapi_adapteraddevents_callback_list;
16649e86db79SHyon Kim cbp != NULL;
16659e86db79SHyon Kim cbp = cbp->next) {
16669e86db79SHyon Kim (*cbp->callback)(data, PortWWN, HBA_EVENT_ADAPTER_ADD);
16679e86db79SHyon Kim }
16689e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AAE_mutex);
16699e86db79SHyon Kim
16709e86db79SHyon Kim }
16719e86db79SHyon Kim
16729e86db79SHyon Kim HBA_STATUS
HBA_RegisterForAdapterAddEvents(void (* callback)(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType),void * userData,HBA_CALLBACKHANDLE * callbackHandle)16739e86db79SHyon Kim HBA_RegisterForAdapterAddEvents(
16749e86db79SHyon Kim void (*callback)(
16759e86db79SHyon Kim void *data,
16769e86db79SHyon Kim HBA_WWN PortWWN,
16779e86db79SHyon Kim HBA_UINT32 eventType),
16789e86db79SHyon Kim void *userData,
16799e86db79SHyon Kim HBA_CALLBACKHANDLE *callbackHandle) {
16809e86db79SHyon Kim
16819e86db79SHyon Kim HBA_ALLADAPTERSCALLBACK_ELEM *cbp;
16829e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vcbp;
16839e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vendorhandlelist;
16849e86db79SHyon Kim HBARegisterForAdapterAddEventsFunc registeredfunc;
16859e86db79SHyon Kim HBA_STATUS status = HBA_STATUS_OK;
16869e86db79SHyon Kim HBA_STATUS failure = HBA_STATUS_OK;
16879e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
16889e86db79SHyon Kim int registered_cnt = 0;
16899e86db79SHyon Kim int vendor_cnt = 0;
16909e86db79SHyon Kim int not_supported_cnt = 0;
16919e86db79SHyon Kim int status_OK_bar_cnt = 0;
16929e86db79SHyon Kim int status_OK_cnt = 0;
16939e86db79SHyon Kim
16949e86db79SHyon Kim DEBUG(2, "HBA_RegisterForAdapterAddEvents", 0, 0, 0);
16959e86db79SHyon Kim ARE_WE_INITED();
16969e86db79SHyon Kim
16979e86db79SHyon Kim cbp = (HBA_ALLADAPTERSCALLBACK_ELEM *)
16989e86db79SHyon Kim calloc(1, sizeof (HBA_ALLADAPTERSCALLBACK_ELEM));
16999e86db79SHyon Kim *callbackHandle = (HBA_CALLBACKHANDLE) cbp;
17009e86db79SHyon Kim if (cbp == NULL) {
17019e86db79SHyon Kim #ifndef WIN32
17029e86db79SHyon Kim (void) fprintf(stderr,
17039e86db79SHyon Kim "HBA_RegisterForAdapterAddEvents: calloc failed "
17049e86db79SHyon Kim "for %lu bytes\n",
17059e86db79SHyon Kim (unsigned long)(sizeof (HBA_ALLADAPTERSCALLBACK_ELEM)));
17069e86db79SHyon Kim #endif
17079e86db79SHyon Kim return (HBA_STATUS_ERROR);
17089e86db79SHyon Kim }
17099e86db79SHyon Kim
17109e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
17119e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AAE_mutex);
17129e86db79SHyon Kim cbp->callback = callback;
17139e86db79SHyon Kim cbp->next = _hbaapi_adapteraddevents_callback_list;
17149e86db79SHyon Kim _hbaapi_adapteraddevents_callback_list = cbp;
17159e86db79SHyon Kim /*
17169e86db79SHyon Kim * Need to release the mutex now incase the vendor function invokes the
17179e86db79SHyon Kim * callback. We will grap the mutex later to attach the vendor handle
17189e86db79SHyon Kim * list to the callback structure
17199e86db79SHyon Kim */
17209e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AAE_mutex);
17219e86db79SHyon Kim
17229e86db79SHyon Kim /*
17239e86db79SHyon Kim * now create a list of vendors (vendor libraryies, NOT ADAPTERS)
17249e86db79SHyon Kim * that have successfully registerred
17259e86db79SHyon Kim */
17269e86db79SHyon Kim vendorhandlelist = NULL;
17279e86db79SHyon Kim for (lib_infop = _hbaapi_librarylist;
17289e86db79SHyon Kim lib_infop != NULL;
17299e86db79SHyon Kim lib_infop = lib_infop->next) {
17309e86db79SHyon Kim
17319e86db79SHyon Kim /* only for HBAAPI V2 */
17329e86db79SHyon Kim if ((lib_infop->version != HBAAPIV2)) {
17339e86db79SHyon Kim continue;
17349e86db79SHyon Kim } else {
17359e86db79SHyon Kim vendor_cnt++;
17369e86db79SHyon Kim }
17379e86db79SHyon Kim
17389e86db79SHyon Kim registeredfunc =
17399e86db79SHyon Kim lib_infop->ftable.functionTable.RegisterForAdapterAddEventsHandler;
17409e86db79SHyon Kim if (registeredfunc == NULL) {
17419e86db79SHyon Kim continue;
17429e86db79SHyon Kim }
17439e86db79SHyon Kim
17449e86db79SHyon Kim vcbp = (HBA_VENDORCALLBACK_ELEM *)
17459e86db79SHyon Kim calloc(1, sizeof (HBA_VENDORCALLBACK_ELEM));
17469e86db79SHyon Kim if (vcbp == NULL) {
17479e86db79SHyon Kim #ifndef WIN32
17489e86db79SHyon Kim (void) fprintf(stderr,
17499e86db79SHyon Kim "HBA_RegisterForAdapterAddEvents: "
17509e86db79SHyon Kim "calloc failed for %lu bytes\n",
17519e86db79SHyon Kim (unsigned long)(sizeof (HBA_VENDORCALLBACK_ELEM)));
17529e86db79SHyon Kim #endif
17539e86db79SHyon Kim freevendorhandlelist(vendorhandlelist);
17549e86db79SHyon Kim status = HBA_STATUS_ERROR;
17559e86db79SHyon Kim break;
17569e86db79SHyon Kim }
17579e86db79SHyon Kim
17589e86db79SHyon Kim registered_cnt++;
17599e86db79SHyon Kim status = (registeredfunc)(adapteraddevents_callback,
17609e86db79SHyon Kim userData, &vcbp->vendorcbhandle);
17619e86db79SHyon Kim if (status == HBA_STATUS_ERROR_NOT_SUPPORTED) {
17629e86db79SHyon Kim not_supported_cnt++;
17639e86db79SHyon Kim free(vcbp);
17649e86db79SHyon Kim continue;
17659e86db79SHyon Kim } else if (status != HBA_STATUS_OK) {
17669e86db79SHyon Kim status_OK_bar_cnt++;
17679e86db79SHyon Kim DEBUG(1,
17689e86db79SHyon Kim "HBA_RegisterForAdapterAddEvents: Library->%s, Error->%d",
17699e86db79SHyon Kim lib_infop->LibraryPath, status, 0);
17709e86db79SHyon Kim #ifndef WIN32
17719e86db79SHyon Kim (void) fprintf(stderr,
17729e86db79SHyon Kim "HBA_RegisterForAdapterAddEvents: Library->%s, Error->%d",
17739e86db79SHyon Kim lib_infop->LibraryPath, status);
17749e86db79SHyon Kim #endif
17759e86db79SHyon Kim failure = status;
17769e86db79SHyon Kim free(vcbp);
17779e86db79SHyon Kim continue;
17789e86db79SHyon Kim } else {
17799e86db79SHyon Kim status_OK_cnt++;
17809e86db79SHyon Kim }
17819e86db79SHyon Kim vcbp->lib_info = lib_infop;
17829e86db79SHyon Kim vcbp->next = vendorhandlelist;
17839e86db79SHyon Kim vendorhandlelist = vcbp;
17849e86db79SHyon Kim }
17859e86db79SHyon Kim if (vendor_cnt == 0) {
17869e86db79SHyon Kim /* no HBAAPIV2 is deteced. should be okay? */
17879e86db79SHyon Kim status = HBA_STATUS_ERROR;
17889e86db79SHyon Kim } else if (registered_cnt == 0) {
17899e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
17909e86db79SHyon Kim freevendorhandlelist(vendorhandlelist);
17919e86db79SHyon Kim (void) local_remove_callback((HBA_CALLBACKHANDLE) cbp);
17929e86db79SHyon Kim } else if (status_OK_cnt == 0 && not_supported_cnt != 0) {
17939e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
17949e86db79SHyon Kim } else if (status_OK_cnt == 0) {
17959e86db79SHyon Kim /*
17969e86db79SHyon Kim * At least one vendor library registered this function, but no
17979e86db79SHyon Kim * vendor call succeeded
17989e86db79SHyon Kim */
17999e86db79SHyon Kim (void) local_remove_callback((HBA_CALLBACKHANDLE) cbp);
18009e86db79SHyon Kim status = failure;
18019e86db79SHyon Kim } else {
18029e86db79SHyon Kim /* we have had atleast some success, now finish up */
18039e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AAE_mutex);
18049e86db79SHyon Kim /*
18059e86db79SHyon Kim * this seems silly, but what if another thread called
18069e86db79SHyon Kim * the callback remove
18079e86db79SHyon Kim */
18089e86db79SHyon Kim for (cbp = _hbaapi_adapteraddevents_callback_list;
18099e86db79SHyon Kim cbp != NULL; cbp = cbp->next) {
18109e86db79SHyon Kim if ((HBA_CALLBACKHANDLE)cbp == *callbackHandle) {
18119e86db79SHyon Kim /* yup, its still there, hooray */
18129e86db79SHyon Kim cbp->vendorhandlelist = vendorhandlelist;
18139e86db79SHyon Kim vendorhandlelist = NULL;
18149e86db79SHyon Kim break;
18159e86db79SHyon Kim }
18169e86db79SHyon Kim }
18179e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AAE_mutex);
18189e86db79SHyon Kim if (vendorhandlelist != NULL) {
18199e86db79SHyon Kim /*
18209e86db79SHyon Kim * bummer, somebody removed the callback before we finished
18219e86db79SHyon Kim * registration, probably will never happen
18229e86db79SHyon Kim */
18239e86db79SHyon Kim freevendorhandlelist(vendorhandlelist);
18249e86db79SHyon Kim DEBUG(1,
18259e86db79SHyon Kim "HBA_RegisterForAdapterAddEvents: HBA_RemoveCallback was "
18269e86db79SHyon Kim "called for a handle before registration was finished.",
18279e86db79SHyon Kim 0, 0, 0);
18289e86db79SHyon Kim status = HBA_STATUS_ERROR;
18299e86db79SHyon Kim } else {
18309e86db79SHyon Kim status = HBA_STATUS_OK;
18319e86db79SHyon Kim }
18329e86db79SHyon Kim }
18339e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
18349e86db79SHyon Kim }
18359e86db79SHyon Kim
18369e86db79SHyon Kim /* Adapter Events (other than add) ************************************** */
18379e86db79SHyon Kim static void
adapterevents_callback(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType)18389e86db79SHyon Kim adapterevents_callback(void *data,
18399e86db79SHyon Kim HBA_WWN PortWWN,
18409e86db79SHyon Kim HBA_UINT32 eventType) {
18419e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
18429e86db79SHyon Kim
18439e86db79SHyon Kim DEBUG(3, "AdapterEvent, port:%s, eventType:%d", WWN2STR1(&PortWWN),
18449e86db79SHyon Kim eventType, 0);
18459e86db79SHyon Kim
18469e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AE_mutex);
18479e86db79SHyon Kim for (acbp = _hbaapi_adapterevents_callback_list;
18489e86db79SHyon Kim acbp != NULL;
18499e86db79SHyon Kim acbp = acbp->next) {
18509e86db79SHyon Kim if (data == (void *)acbp) {
18519e86db79SHyon Kim (*acbp->callback)(acbp->userdata, PortWWN, eventType);
18529e86db79SHyon Kim break;
18539e86db79SHyon Kim }
18549e86db79SHyon Kim }
18559e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AE_mutex);
18569e86db79SHyon Kim }
18579e86db79SHyon Kim HBA_STATUS
HBA_RegisterForAdapterEvents(void (* callback)(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType),void * userData,HBA_HANDLE handle,HBA_CALLBACKHANDLE * callbackHandle)18589e86db79SHyon Kim HBA_RegisterForAdapterEvents(
18599e86db79SHyon Kim void (*callback) (
18609e86db79SHyon Kim void *data,
18619e86db79SHyon Kim HBA_WWN PortWWN,
18629e86db79SHyon Kim HBA_UINT32 eventType),
18639e86db79SHyon Kim void *userData,
18649e86db79SHyon Kim HBA_HANDLE handle,
18659e86db79SHyon Kim HBA_CALLBACKHANDLE *callbackHandle) {
18669e86db79SHyon Kim
18679e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
18689e86db79SHyon Kim HBARegisterForAdapterEventsFunc registeredfunc;
18699e86db79SHyon Kim HBA_STATUS status;
18709e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
18719e86db79SHyon Kim HBA_HANDLE vendorHandle;
18729e86db79SHyon Kim
18739e86db79SHyon Kim DEBUG(2, "HBA_RegisterForAdapterEvents", 0, 0, 0);
18749e86db79SHyon Kim
18759e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
18769e86db79SHyon Kim
18779e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
18789e86db79SHyon Kim
18799e86db79SHyon Kim registeredfunc =
18809e86db79SHyon Kim lib_infop->ftable.functionTable.RegisterForAdapterEventsHandler;
18819e86db79SHyon Kim if (registeredfunc == NULL) {
18829e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
18839e86db79SHyon Kim }
18849e86db79SHyon Kim
18859e86db79SHyon Kim /*
18869e86db79SHyon Kim * that allocated memory is used both as the handle for the
18879e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
18889e86db79SHyon Kim * callback the specific registration may be recalled
18899e86db79SHyon Kim */
18909e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
18919e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
18929e86db79SHyon Kim if (acbp == NULL) {
18939e86db79SHyon Kim #ifndef WIN32
18949e86db79SHyon Kim (void) fprintf(stderr,
18959e86db79SHyon Kim "HBA_RegisterForAdapterEvents: calloc failed for %lu bytes\n",
18969e86db79SHyon Kim (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
18979e86db79SHyon Kim #endif
18989e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
18999e86db79SHyon Kim }
19009e86db79SHyon Kim *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
19019e86db79SHyon Kim acbp->callback = callback;
19029e86db79SHyon Kim acbp->userdata = userData;
19039e86db79SHyon Kim acbp->lib_info = lib_infop;
19049e86db79SHyon Kim
19059e86db79SHyon Kim status = (registeredfunc)(adapterevents_callback,
19069e86db79SHyon Kim (void *)acbp,
19079e86db79SHyon Kim vendorHandle,
19089e86db79SHyon Kim &acbp->vendorcbhandle);
19099e86db79SHyon Kim if (status != HBA_STATUS_OK) {
19109e86db79SHyon Kim free(acbp);
19119e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
19129e86db79SHyon Kim }
19139e86db79SHyon Kim
19149e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AE_mutex);
19159e86db79SHyon Kim acbp->next = _hbaapi_adapterevents_callback_list;
19169e86db79SHyon Kim _hbaapi_adapterevents_callback_list = acbp;
19179e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AE_mutex);
19189e86db79SHyon Kim
19199e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
19209e86db79SHyon Kim }
19219e86db79SHyon Kim
19229e86db79SHyon Kim /* Adapter Port Events ************************************************** */
19239e86db79SHyon Kim static void
adapterportevents_callback(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType,HBA_UINT32 fabricPortID)19249e86db79SHyon Kim adapterportevents_callback(void *data,
19259e86db79SHyon Kim HBA_WWN PortWWN,
19269e86db79SHyon Kim HBA_UINT32 eventType,
19279e86db79SHyon Kim HBA_UINT32 fabricPortID) {
19289e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
19299e86db79SHyon Kim
19309e86db79SHyon Kim DEBUG(3, "AdapterPortEvent, port:%s, eventType:%d fabricPortID:0X%06x",
19319e86db79SHyon Kim WWN2STR1(&PortWWN), eventType, fabricPortID);
19329e86db79SHyon Kim
19339e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_APE_mutex);
19349e86db79SHyon Kim
19359e86db79SHyon Kim for (acbp = _hbaapi_adapterportevents_callback_list;
19369e86db79SHyon Kim acbp != NULL;
19379e86db79SHyon Kim acbp = acbp->next) {
19389e86db79SHyon Kim if (data == (void *)acbp) {
19399e86db79SHyon Kim (*acbp->callback)(acbp->userdata, PortWWN, eventType, fabricPortID);
19409e86db79SHyon Kim break;
19419e86db79SHyon Kim }
19429e86db79SHyon Kim }
19439e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_APE_mutex);
19449e86db79SHyon Kim }
19459e86db79SHyon Kim
19469e86db79SHyon Kim HBA_STATUS
HBA_RegisterForAdapterPortEvents(void (* callback)(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType,HBA_UINT32 fabricPortID),void * userData,HBA_HANDLE handle,HBA_WWN PortWWN,HBA_CALLBACKHANDLE * callbackHandle)19479e86db79SHyon Kim HBA_RegisterForAdapterPortEvents(
19489e86db79SHyon Kim void (*callback) (
19499e86db79SHyon Kim void *data,
19509e86db79SHyon Kim HBA_WWN PortWWN,
19519e86db79SHyon Kim HBA_UINT32 eventType,
19529e86db79SHyon Kim HBA_UINT32 fabricPortID),
19539e86db79SHyon Kim void *userData,
19549e86db79SHyon Kim HBA_HANDLE handle,
19559e86db79SHyon Kim HBA_WWN PortWWN,
19569e86db79SHyon Kim HBA_CALLBACKHANDLE *callbackHandle) {
19579e86db79SHyon Kim
19589e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
19599e86db79SHyon Kim HBARegisterForAdapterPortEventsFunc registeredfunc;
19609e86db79SHyon Kim HBA_STATUS status;
19619e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
19629e86db79SHyon Kim HBA_HANDLE vendorHandle;
19639e86db79SHyon Kim
19649e86db79SHyon Kim DEBUG(2, "HBA_RegisterForAdapterPortEvents for port: %s",
19659e86db79SHyon Kim WWN2STR1(&PortWWN), 0, 0);
19669e86db79SHyon Kim
19679e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
19689e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
19699e86db79SHyon Kim
19709e86db79SHyon Kim registeredfunc =
19719e86db79SHyon Kim lib_infop->ftable.functionTable.RegisterForAdapterPortEventsHandler;
19729e86db79SHyon Kim if (registeredfunc == NULL) {
19739e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
19749e86db79SHyon Kim }
19759e86db79SHyon Kim
19769e86db79SHyon Kim /*
19779e86db79SHyon Kim * that allocated memory is used both as the handle for the
19789e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
19799e86db79SHyon Kim * callback the specific registration may be recalled
19809e86db79SHyon Kim */
19819e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
19829e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
19839e86db79SHyon Kim if (acbp == NULL) {
19849e86db79SHyon Kim #ifndef WIN32
19859e86db79SHyon Kim (void) fprintf(stderr,
19869e86db79SHyon Kim "HBA_RegisterForAdapterPortEvents: "
19879e86db79SHyon Kim "calloc failed for %lu bytes\n",
19889e86db79SHyon Kim (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
19899e86db79SHyon Kim #endif
19909e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
19919e86db79SHyon Kim
19929e86db79SHyon Kim }
19939e86db79SHyon Kim *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
19949e86db79SHyon Kim acbp->callback = callback;
19959e86db79SHyon Kim acbp->userdata = userData;
19969e86db79SHyon Kim acbp->lib_info = lib_infop;
19979e86db79SHyon Kim
19989e86db79SHyon Kim status = (registeredfunc)(adapterportevents_callback,
19999e86db79SHyon Kim (void *)acbp,
20009e86db79SHyon Kim vendorHandle,
20019e86db79SHyon Kim PortWWN,
20029e86db79SHyon Kim &acbp->vendorcbhandle);
20039e86db79SHyon Kim if (status != HBA_STATUS_OK) {
20049e86db79SHyon Kim free(acbp);
20059e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
20069e86db79SHyon Kim }
20079e86db79SHyon Kim
20089e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_APE_mutex);
20099e86db79SHyon Kim acbp->next = _hbaapi_adapterportevents_callback_list;
20109e86db79SHyon Kim _hbaapi_adapterportevents_callback_list = acbp;
20119e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_APE_mutex);
20129e86db79SHyon Kim
20139e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
20149e86db79SHyon Kim }
20159e86db79SHyon Kim
20169e86db79SHyon Kim /* Adapter State Events ************************************************ */
20179e86db79SHyon Kim static void
adapterportstatevents_callback(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType)20189e86db79SHyon Kim adapterportstatevents_callback(void *data,
20199e86db79SHyon Kim HBA_WWN PortWWN,
20209e86db79SHyon Kim HBA_UINT32 eventType) {
20219e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
20229e86db79SHyon Kim
20239e86db79SHyon Kim DEBUG(3, "AdapterPortStatEvent, port:%s, eventType:%d",
20249e86db79SHyon Kim WWN2STR1(&PortWWN),
20259e86db79SHyon Kim eventType, 0);
20269e86db79SHyon Kim
20279e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_APSE_mutex);
20289e86db79SHyon Kim for (acbp = _hbaapi_adapterportstatevents_callback_list;
20299e86db79SHyon Kim acbp != NULL;
20309e86db79SHyon Kim acbp = acbp->next) {
20319e86db79SHyon Kim if (data == (void *)acbp) {
20329e86db79SHyon Kim (*acbp->callback)(acbp->userdata, PortWWN, eventType);
20339e86db79SHyon Kim return;
20349e86db79SHyon Kim }
20359e86db79SHyon Kim }
20369e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_APSE_mutex);
20379e86db79SHyon Kim }
20389e86db79SHyon Kim HBA_STATUS
HBA_RegisterForAdapterPortStatEvents(void (* callback)(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType),void * userData,HBA_HANDLE handle,HBA_WWN PortWWN,HBA_PORTSTATISTICS stats,HBA_UINT32 statType,HBA_CALLBACKHANDLE * callbackHandle)20399e86db79SHyon Kim HBA_RegisterForAdapterPortStatEvents(
20409e86db79SHyon Kim void (*callback) (
20419e86db79SHyon Kim void *data,
20429e86db79SHyon Kim HBA_WWN PortWWN,
20439e86db79SHyon Kim HBA_UINT32 eventType),
20449e86db79SHyon Kim void *userData,
20459e86db79SHyon Kim HBA_HANDLE handle,
20469e86db79SHyon Kim HBA_WWN PortWWN,
20479e86db79SHyon Kim HBA_PORTSTATISTICS stats,
20489e86db79SHyon Kim HBA_UINT32 statType,
20499e86db79SHyon Kim HBA_CALLBACKHANDLE *callbackHandle) {
20509e86db79SHyon Kim
20519e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
20529e86db79SHyon Kim HBARegisterForAdapterPortStatEventsFunc
20539e86db79SHyon Kim registeredfunc;
20549e86db79SHyon Kim HBA_STATUS status;
20559e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
20569e86db79SHyon Kim HBA_HANDLE vendorHandle;
20579e86db79SHyon Kim
20589e86db79SHyon Kim DEBUG(2, "HBA_RegisterForAdapterPortStatEvents for port: %s",
20599e86db79SHyon Kim WWN2STR1(&PortWWN), 0, 0);
20609e86db79SHyon Kim
20619e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
20629e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
20639e86db79SHyon Kim
20649e86db79SHyon Kim registeredfunc =
20659e86db79SHyon Kim lib_infop->ftable.functionTable.RegisterForAdapterPortStatEventsHandler;
20669e86db79SHyon Kim if (registeredfunc == NULL) {
20679e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
20689e86db79SHyon Kim }
20699e86db79SHyon Kim
20709e86db79SHyon Kim /*
20719e86db79SHyon Kim * that allocated memory is used both as the handle for the
20729e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
20739e86db79SHyon Kim * callback the specific registration may be recalled
20749e86db79SHyon Kim */
20759e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
20769e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
20779e86db79SHyon Kim if (acbp == NULL) {
20789e86db79SHyon Kim #ifndef WIN32
20799e86db79SHyon Kim (void) fprintf(stderr,
20809e86db79SHyon Kim "HBA_RegisterForAdapterPortStatEvents: "
20819e86db79SHyon Kim "calloc failed for %lu bytes\n",
20829e86db79SHyon Kim (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
20839e86db79SHyon Kim #endif
20849e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
20859e86db79SHyon Kim }
20869e86db79SHyon Kim *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
20879e86db79SHyon Kim acbp->callback = callback;
20889e86db79SHyon Kim acbp->userdata = userData;
20899e86db79SHyon Kim acbp->lib_info = lib_infop;
20909e86db79SHyon Kim
20919e86db79SHyon Kim status = (registeredfunc)(adapterportstatevents_callback,
20929e86db79SHyon Kim (void *)acbp,
20939e86db79SHyon Kim vendorHandle,
20949e86db79SHyon Kim PortWWN,
20959e86db79SHyon Kim stats,
20969e86db79SHyon Kim statType,
20979e86db79SHyon Kim &acbp->vendorcbhandle);
20989e86db79SHyon Kim if (status != HBA_STATUS_OK) {
20999e86db79SHyon Kim free(acbp);
21009e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
21019e86db79SHyon Kim }
21029e86db79SHyon Kim
21039e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_APSE_mutex);
21049e86db79SHyon Kim acbp->next = _hbaapi_adapterportstatevents_callback_list;
21059e86db79SHyon Kim _hbaapi_adapterportstatevents_callback_list = acbp;
21069e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_APSE_mutex);
21079e86db79SHyon Kim
21089e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
21099e86db79SHyon Kim }
21109e86db79SHyon Kim
21119e86db79SHyon Kim /* Target Events ******************************************************* */
21129e86db79SHyon Kim static void
targetevents_callback(void * data,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_UINT32 eventType)21139e86db79SHyon Kim targetevents_callback(void *data,
21149e86db79SHyon Kim HBA_WWN hbaPortWWN,
21159e86db79SHyon Kim HBA_WWN discoveredPortWWN,
21169e86db79SHyon Kim HBA_UINT32 eventType) {
21179e86db79SHyon Kim
21189e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
21199e86db79SHyon Kim
21209e86db79SHyon Kim DEBUG(3, "TargetEvent, hbaPort:%s, discoveredPort:%s eventType:%d",
21219e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), eventType);
21229e86db79SHyon Kim
21239e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_TE_mutex);
21249e86db79SHyon Kim for (acbp = _hbaapi_targetevents_callback_list;
21259e86db79SHyon Kim acbp != NULL;
21269e86db79SHyon Kim acbp = acbp->next) {
21279e86db79SHyon Kim if (data == (void *)acbp) {
21289e86db79SHyon Kim (*acbp->callback)(acbp->userdata, hbaPortWWN,
21299e86db79SHyon Kim discoveredPortWWN, eventType);
21309e86db79SHyon Kim break;
21319e86db79SHyon Kim }
21329e86db79SHyon Kim }
21339e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_TE_mutex);
21349e86db79SHyon Kim }
21359e86db79SHyon Kim
21369e86db79SHyon Kim HBA_STATUS
HBA_RegisterForTargetEvents(void (* callback)(void * data,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_UINT32 eventType),void * userData,HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_CALLBACKHANDLE * callbackHandle,HBA_UINT32 allTargets)21379e86db79SHyon Kim HBA_RegisterForTargetEvents(
21389e86db79SHyon Kim void (*callback) (
21399e86db79SHyon Kim void *data,
21409e86db79SHyon Kim HBA_WWN hbaPortWWN,
21419e86db79SHyon Kim HBA_WWN discoveredPortWWN,
21429e86db79SHyon Kim HBA_UINT32 eventType),
21439e86db79SHyon Kim void *userData,
21449e86db79SHyon Kim HBA_HANDLE handle,
21459e86db79SHyon Kim HBA_WWN hbaPortWWN,
21469e86db79SHyon Kim HBA_WWN discoveredPortWWN,
21479e86db79SHyon Kim HBA_CALLBACKHANDLE *callbackHandle,
21489e86db79SHyon Kim HBA_UINT32 allTargets) {
21499e86db79SHyon Kim
21509e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM
21519e86db79SHyon Kim *acbp;
21529e86db79SHyon Kim HBARegisterForTargetEventsFunc
21539e86db79SHyon Kim registeredfunc;
21549e86db79SHyon Kim HBA_STATUS status;
21559e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
21569e86db79SHyon Kim HBA_HANDLE vendorHandle;
21579e86db79SHyon Kim
21589e86db79SHyon Kim DEBUG(2, "HBA_RegisterForTargetEvents, hbaPort: %s, discoveredPort: %s",
21599e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), 0);
21609e86db79SHyon Kim
21619e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
21629e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
21639e86db79SHyon Kim
21649e86db79SHyon Kim registeredfunc =
21659e86db79SHyon Kim lib_infop->ftable.functionTable.RegisterForTargetEventsHandler;
21669e86db79SHyon Kim if (registeredfunc == NULL) {
21679e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
21689e86db79SHyon Kim }
21699e86db79SHyon Kim
21709e86db79SHyon Kim /*
21719e86db79SHyon Kim * that allocated memory is used both as the handle for the
21729e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
21739e86db79SHyon Kim * callback the specific registration may be recalled
21749e86db79SHyon Kim */
21759e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
21769e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
21779e86db79SHyon Kim if (acbp == NULL) {
21789e86db79SHyon Kim #ifndef WIN32
21799e86db79SHyon Kim (void) fprintf(stderr,
21809e86db79SHyon Kim "HBA_RegisterForTargetEvents: calloc failed for %lu bytes\n",
21819e86db79SHyon Kim (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
21829e86db79SHyon Kim #endif
21839e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
21849e86db79SHyon Kim }
21859e86db79SHyon Kim *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
21869e86db79SHyon Kim acbp->callback = callback;
21879e86db79SHyon Kim acbp->userdata = userData;
21889e86db79SHyon Kim acbp->lib_info = lib_infop;
21899e86db79SHyon Kim
21909e86db79SHyon Kim status = (registeredfunc)(targetevents_callback,
21919e86db79SHyon Kim (void *)acbp,
21929e86db79SHyon Kim vendorHandle,
21939e86db79SHyon Kim hbaPortWWN,
21949e86db79SHyon Kim discoveredPortWWN,
21959e86db79SHyon Kim &acbp->vendorcbhandle,
21969e86db79SHyon Kim allTargets);
21979e86db79SHyon Kim if (status != HBA_STATUS_OK) {
21989e86db79SHyon Kim free(acbp);
21999e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
22009e86db79SHyon Kim }
22019e86db79SHyon Kim
22029e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_TE_mutex);
22039e86db79SHyon Kim acbp->next = _hbaapi_targetevents_callback_list;
22049e86db79SHyon Kim _hbaapi_targetevents_callback_list = acbp;
22059e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_TE_mutex);
22069e86db79SHyon Kim
22079e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
22089e86db79SHyon Kim }
22099e86db79SHyon Kim
22109e86db79SHyon Kim /* Link Events ********************************************************* */
22119e86db79SHyon Kim static void
linkevents_callback(void * data,HBA_WWN adapterWWN,HBA_UINT32 eventType,void * pRLIRBuffer,HBA_UINT32 RLIRBufferSize)22129e86db79SHyon Kim linkevents_callback(void *data,
22139e86db79SHyon Kim HBA_WWN adapterWWN,
22149e86db79SHyon Kim HBA_UINT32 eventType,
22159e86db79SHyon Kim void *pRLIRBuffer,
22169e86db79SHyon Kim HBA_UINT32 RLIRBufferSize) {
22179e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
22189e86db79SHyon Kim
22199e86db79SHyon Kim DEBUG(3, "LinkEvent, hbaWWN:%s, eventType:%d",
22209e86db79SHyon Kim WWN2STR1(&adapterWWN), eventType, 0);
22219e86db79SHyon Kim
22229e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LE_mutex);
22239e86db79SHyon Kim for (acbp = _hbaapi_linkevents_callback_list;
22249e86db79SHyon Kim acbp != NULL;
22259e86db79SHyon Kim acbp = acbp->next) {
22269e86db79SHyon Kim if (data == (void *)acbp) {
22279e86db79SHyon Kim (*acbp->callback)(acbp->userdata, adapterWWN,
22289e86db79SHyon Kim eventType, pRLIRBuffer, RLIRBufferSize);
22299e86db79SHyon Kim break;
22309e86db79SHyon Kim }
22319e86db79SHyon Kim }
22329e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LE_mutex);
22339e86db79SHyon Kim }
22349e86db79SHyon Kim HBA_STATUS
HBA_RegisterForLinkEvents(void (* callback)(void * data,HBA_WWN adapterWWN,HBA_UINT32 eventType,void * pRLIRBuffer,HBA_UINT32 RLIRBufferSize),void * userData,void * pRLIRBuffer,HBA_UINT32 RLIRBufferSize,HBA_HANDLE handle,HBA_CALLBACKHANDLE * callbackHandle)22359e86db79SHyon Kim HBA_RegisterForLinkEvents(
22369e86db79SHyon Kim void (*callback) (
22379e86db79SHyon Kim void *data,
22389e86db79SHyon Kim HBA_WWN adapterWWN,
22399e86db79SHyon Kim HBA_UINT32 eventType,
22409e86db79SHyon Kim void *pRLIRBuffer,
22419e86db79SHyon Kim HBA_UINT32 RLIRBufferSize),
22429e86db79SHyon Kim void *userData,
22439e86db79SHyon Kim void *pRLIRBuffer,
22449e86db79SHyon Kim HBA_UINT32 RLIRBufferSize,
22459e86db79SHyon Kim HBA_HANDLE handle,
22469e86db79SHyon Kim HBA_CALLBACKHANDLE *callbackHandle) {
22479e86db79SHyon Kim
22489e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
22499e86db79SHyon Kim HBARegisterForLinkEventsFunc
22509e86db79SHyon Kim registeredfunc;
22519e86db79SHyon Kim HBA_STATUS status;
22529e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
22539e86db79SHyon Kim HBA_HANDLE vendorHandle;
22549e86db79SHyon Kim
22559e86db79SHyon Kim DEBUG(2, "HBA_RegisterForLinkEvents", 0, 0, 0);
22569e86db79SHyon Kim
22579e86db79SHyon Kim CHECKLIBRARY();
22589e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
22599e86db79SHyon Kim
22609e86db79SHyon Kim registeredfunc = FUNCCOMMON(lib_infop, RegisterForLinkEventsHandler);
22619e86db79SHyon Kim
22629e86db79SHyon Kim if (registeredfunc == NULL) {
22639e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
22649e86db79SHyon Kim }
22659e86db79SHyon Kim
22669e86db79SHyon Kim /*
22679e86db79SHyon Kim * that allocated memory is used both as the handle for the
22689e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
22699e86db79SHyon Kim * callback the specific registration may be recalled
22709e86db79SHyon Kim */
22719e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
22729e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
22739e86db79SHyon Kim if (acbp == NULL) {
22749e86db79SHyon Kim #ifndef WIN32
22759e86db79SHyon Kim (void) fprintf(stderr,
22769e86db79SHyon Kim "HBA_RegisterForLinkEvents: calloc failed for %lu bytes\n",
22779e86db79SHyon Kim (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
22789e86db79SHyon Kim #endif
22799e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
22809e86db79SHyon Kim }
22819e86db79SHyon Kim *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
22829e86db79SHyon Kim acbp->callback = callback;
22839e86db79SHyon Kim acbp->userdata = userData;
22849e86db79SHyon Kim acbp->lib_info = lib_infop;
22859e86db79SHyon Kim
22869e86db79SHyon Kim status = (registeredfunc)(linkevents_callback,
22879e86db79SHyon Kim (void *)acbp,
22889e86db79SHyon Kim pRLIRBuffer,
22899e86db79SHyon Kim RLIRBufferSize,
22909e86db79SHyon Kim vendorHandle,
22919e86db79SHyon Kim &acbp->vendorcbhandle);
22929e86db79SHyon Kim if (status != HBA_STATUS_OK) {
22939e86db79SHyon Kim free(acbp);
22949e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
22959e86db79SHyon Kim }
22969e86db79SHyon Kim
22979e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LE_mutex);
22989e86db79SHyon Kim acbp->next = _hbaapi_linkevents_callback_list;
22999e86db79SHyon Kim _hbaapi_linkevents_callback_list = acbp;
23009e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LE_mutex);
23019e86db79SHyon Kim
23029e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
23039e86db79SHyon Kim }
23049e86db79SHyon Kim
23059e86db79SHyon Kim /*
23069e86db79SHyon Kim * All of the functions below are almost passthru functions to the
23079e86db79SHyon Kim * vendor specific function
23089e86db79SHyon Kim */
23099e86db79SHyon Kim
23109e86db79SHyon Kim void
HBA_CloseAdapter(HBA_HANDLE handle)23119e86db79SHyon Kim HBA_CloseAdapter(HBA_HANDLE handle) {
23129e86db79SHyon Kim HBA_STATUS status;
23139e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
23149e86db79SHyon Kim HBA_HANDLE vendorHandle;
23159e86db79SHyon Kim HBACloseAdapterFunc CloseAdapterFunc;
23169e86db79SHyon Kim
23179e86db79SHyon Kim DEBUG(2, "HBA_CloseAdapter", 0, 0, 0);
23189e86db79SHyon Kim
23199e86db79SHyon Kim status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
23209e86db79SHyon Kim if (status == HBA_STATUS_OK) {
23219e86db79SHyon Kim CloseAdapterFunc = FUNCCOMMON(lib_infop, CloseAdapterHandler);
23229e86db79SHyon Kim if (CloseAdapterFunc != NULL) {
23239e86db79SHyon Kim ((CloseAdapterFunc)(vendorHandle));
23249e86db79SHyon Kim }
23259e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
23269e86db79SHyon Kim }
23279e86db79SHyon Kim }
23289e86db79SHyon Kim
23299e86db79SHyon Kim HBA_STATUS
HBA_GetAdapterAttributes(HBA_HANDLE handle,HBA_ADAPTERATTRIBUTES * hbaattributes)23309e86db79SHyon Kim HBA_GetAdapterAttributes(
23319e86db79SHyon Kim HBA_HANDLE handle,
23329e86db79SHyon Kim HBA_ADAPTERATTRIBUTES
23339e86db79SHyon Kim *hbaattributes)
23349e86db79SHyon Kim {
23359e86db79SHyon Kim HBA_STATUS status;
23369e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
23379e86db79SHyon Kim HBA_HANDLE vendorHandle;
23389e86db79SHyon Kim HBAGetAdapterAttributesFunc GetAdapterAttributesFunc;
23399e86db79SHyon Kim
23409e86db79SHyon Kim DEBUG(2, "HBA_GetAdapterAttributes", 0, 0, 0);
23419e86db79SHyon Kim
23429e86db79SHyon Kim CHECKLIBRARY();
23439e86db79SHyon Kim
23449e86db79SHyon Kim if (lib_infop->version == SMHBA) {
23459e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
23469e86db79SHyon Kim }
23479e86db79SHyon Kim
23489e86db79SHyon Kim GetAdapterAttributesFunc =
23499e86db79SHyon Kim lib_infop->ftable.functionTable.GetAdapterAttributesHandler;
23509e86db79SHyon Kim if (GetAdapterAttributesFunc != NULL) {
23519e86db79SHyon Kim status = ((GetAdapterAttributesFunc)(vendorHandle, hbaattributes));
23529e86db79SHyon Kim } else {
23539e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
23549e86db79SHyon Kim }
23559e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
23569e86db79SHyon Kim }
23579e86db79SHyon Kim
23589e86db79SHyon Kim HBA_STATUS
HBA_GetAdapterPortAttributes(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_PORTATTRIBUTES * portattributes)23599e86db79SHyon Kim HBA_GetAdapterPortAttributes(
23609e86db79SHyon Kim HBA_HANDLE handle,
23619e86db79SHyon Kim HBA_UINT32 portindex,
23629e86db79SHyon Kim HBA_PORTATTRIBUTES *portattributes)
23639e86db79SHyon Kim {
23649e86db79SHyon Kim HBA_STATUS status;
23659e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
23669e86db79SHyon Kim HBA_HANDLE vendorHandle;
23679e86db79SHyon Kim HBAGetAdapterPortAttributesFunc
23689e86db79SHyon Kim GetAdapterPortAttributesFunc;
23699e86db79SHyon Kim
23709e86db79SHyon Kim DEBUG(2, "HBA_GetAdapterPortAttributes", 0, 0, 0);
23719e86db79SHyon Kim
23729e86db79SHyon Kim CHECKLIBRARY();
23739e86db79SHyon Kim if (lib_infop->version == SMHBA) {
23749e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
23759e86db79SHyon Kim }
23769e86db79SHyon Kim
23779e86db79SHyon Kim GetAdapterPortAttributesFunc =
23789e86db79SHyon Kim lib_infop->ftable.functionTable.GetAdapterPortAttributesHandler;
23799e86db79SHyon Kim if (GetAdapterPortAttributesFunc != NULL) {
23809e86db79SHyon Kim status = ((GetAdapterPortAttributesFunc)
23819e86db79SHyon Kim (vendorHandle, portindex, portattributes));
23829e86db79SHyon Kim } else {
23839e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
23849e86db79SHyon Kim }
23859e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
23869e86db79SHyon Kim }
23879e86db79SHyon Kim
23889e86db79SHyon Kim HBA_STATUS
HBA_GetPortStatistics(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_PORTSTATISTICS * portstatistics)23899e86db79SHyon Kim HBA_GetPortStatistics(
23909e86db79SHyon Kim HBA_HANDLE handle,
23919e86db79SHyon Kim HBA_UINT32 portindex,
23929e86db79SHyon Kim HBA_PORTSTATISTICS *portstatistics)
23939e86db79SHyon Kim {
23949e86db79SHyon Kim HBA_STATUS status;
23959e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
23969e86db79SHyon Kim HBA_HANDLE vendorHandle;
23979e86db79SHyon Kim HBAGetPortStatisticsFunc
23989e86db79SHyon Kim GetPortStatisticsFunc;
23999e86db79SHyon Kim
24009e86db79SHyon Kim DEBUG(2, "HBA_GetPortStatistics", 0, 0, 0);
24019e86db79SHyon Kim
24029e86db79SHyon Kim CHECKLIBRARY();
24039e86db79SHyon Kim if (lib_infop->version == SMHBA) {
24049e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
24059e86db79SHyon Kim }
24069e86db79SHyon Kim
24079e86db79SHyon Kim GetPortStatisticsFunc =
24089e86db79SHyon Kim lib_infop->ftable.functionTable.GetPortStatisticsHandler;
24099e86db79SHyon Kim if (GetPortStatisticsFunc != NULL) {
24109e86db79SHyon Kim status = ((GetPortStatisticsFunc)
24119e86db79SHyon Kim (vendorHandle, portindex, portstatistics));
24129e86db79SHyon Kim } else {
24139e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
24149e86db79SHyon Kim }
24159e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
24169e86db79SHyon Kim }
24179e86db79SHyon Kim
24189e86db79SHyon Kim HBA_STATUS
HBA_GetDiscoveredPortAttributes(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_UINT32 discoveredportindex,HBA_PORTATTRIBUTES * portattributes)24199e86db79SHyon Kim HBA_GetDiscoveredPortAttributes(
24209e86db79SHyon Kim HBA_HANDLE handle,
24219e86db79SHyon Kim HBA_UINT32 portindex,
24229e86db79SHyon Kim HBA_UINT32 discoveredportindex,
24239e86db79SHyon Kim HBA_PORTATTRIBUTES *portattributes)
24249e86db79SHyon Kim {
24259e86db79SHyon Kim HBA_STATUS status;
24269e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
24279e86db79SHyon Kim HBA_HANDLE vendorHandle;
24289e86db79SHyon Kim HBAGetDiscoveredPortAttributesFunc
24299e86db79SHyon Kim GetDiscoveredPortAttributesFunc;
24309e86db79SHyon Kim
24319e86db79SHyon Kim DEBUG(2, "HBA_GetDiscoveredPortAttributes", 0, 0, 0);
24329e86db79SHyon Kim
24339e86db79SHyon Kim CHECKLIBRARY();
24349e86db79SHyon Kim if (lib_infop->version == SMHBA) {
24359e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
24369e86db79SHyon Kim }
24379e86db79SHyon Kim
24389e86db79SHyon Kim GetDiscoveredPortAttributesFunc =
24399e86db79SHyon Kim lib_infop->ftable.functionTable.GetDiscoveredPortAttributesHandler;
24409e86db79SHyon Kim if (GetDiscoveredPortAttributesFunc != NULL) {
24419e86db79SHyon Kim status = ((GetDiscoveredPortAttributesFunc)
24429e86db79SHyon Kim (vendorHandle, portindex, discoveredportindex,
24439e86db79SHyon Kim portattributes));
24449e86db79SHyon Kim } else {
24459e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
24469e86db79SHyon Kim }
24479e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
24489e86db79SHyon Kim }
24499e86db79SHyon Kim
24509e86db79SHyon Kim HBA_STATUS
HBA_GetPortAttributesByWWN(HBA_HANDLE handle,HBA_WWN PortWWN,HBA_PORTATTRIBUTES * portattributes)24519e86db79SHyon Kim HBA_GetPortAttributesByWWN(
24529e86db79SHyon Kim HBA_HANDLE handle,
24539e86db79SHyon Kim HBA_WWN PortWWN,
24549e86db79SHyon Kim HBA_PORTATTRIBUTES *portattributes)
24559e86db79SHyon Kim {
24569e86db79SHyon Kim HBA_STATUS status;
24579e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
24589e86db79SHyon Kim HBA_HANDLE vendorHandle;
24599e86db79SHyon Kim HBAGetPortAttributesByWWNFunc
24609e86db79SHyon Kim GetPortAttributesByWWNFunc;
24619e86db79SHyon Kim
24629e86db79SHyon Kim DEBUG(2, "HBA_GetPortAttributesByWWN: %s", WWN2STR1(&PortWWN), 0, 0);
24639e86db79SHyon Kim
24649e86db79SHyon Kim CHECKLIBRARY();
24659e86db79SHyon Kim if (lib_infop->version == SMHBA) {
24669e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
24679e86db79SHyon Kim }
24689e86db79SHyon Kim
24699e86db79SHyon Kim GetPortAttributesByWWNFunc =
24709e86db79SHyon Kim lib_infop->ftable.functionTable.GetPortAttributesByWWNHandler;
24719e86db79SHyon Kim if (GetPortAttributesByWWNFunc != NULL) {
24729e86db79SHyon Kim status = ((GetPortAttributesByWWNFunc)
24739e86db79SHyon Kim (vendorHandle, PortWWN, portattributes));
24749e86db79SHyon Kim } else {
24759e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
24769e86db79SHyon Kim }
24779e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
24789e86db79SHyon Kim }
24799e86db79SHyon Kim
24809e86db79SHyon Kim HBA_STATUS
HBA_SendCTPassThru(HBA_HANDLE handle,void * pReqBuffer,HBA_UINT32 ReqBufferSize,void * pRspBuffer,HBA_UINT32 RspBufferSize)24819e86db79SHyon Kim HBA_SendCTPassThru(
24829e86db79SHyon Kim HBA_HANDLE handle,
24839e86db79SHyon Kim void *pReqBuffer,
24849e86db79SHyon Kim HBA_UINT32 ReqBufferSize,
24859e86db79SHyon Kim void *pRspBuffer,
24869e86db79SHyon Kim HBA_UINT32 RspBufferSize)
24879e86db79SHyon Kim {
24889e86db79SHyon Kim HBA_STATUS status;
24899e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
24909e86db79SHyon Kim HBA_HANDLE vendorHandle;
24919e86db79SHyon Kim HBASendCTPassThruFunc
24929e86db79SHyon Kim SendCTPassThruFunc;
24939e86db79SHyon Kim
24949e86db79SHyon Kim DEBUG(2, "HBA_SendCTPassThru", 0, 0, 0);
24959e86db79SHyon Kim
24969e86db79SHyon Kim CHECKLIBRARY();
24979e86db79SHyon Kim if (lib_infop->version == SMHBA) {
24989e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
24999e86db79SHyon Kim }
25009e86db79SHyon Kim
25019e86db79SHyon Kim SendCTPassThruFunc =
25029e86db79SHyon Kim lib_infop->ftable.functionTable.SendCTPassThruHandler;
25039e86db79SHyon Kim if (SendCTPassThruFunc != NULL) {
25049e86db79SHyon Kim status = (SendCTPassThruFunc)
25059e86db79SHyon Kim (vendorHandle,
25069e86db79SHyon Kim pReqBuffer, ReqBufferSize,
25079e86db79SHyon Kim pRspBuffer, RspBufferSize);
25089e86db79SHyon Kim } else {
25099e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
25109e86db79SHyon Kim }
25119e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
25129e86db79SHyon Kim }
25139e86db79SHyon Kim
25149e86db79SHyon Kim HBA_STATUS
HBA_SendCTPassThruV2(HBA_HANDLE handle,HBA_WWN hbaPortWWN,void * pReqBuffer,HBA_UINT32 ReqBufferSize,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)25159e86db79SHyon Kim HBA_SendCTPassThruV2(
25169e86db79SHyon Kim HBA_HANDLE handle,
25179e86db79SHyon Kim HBA_WWN hbaPortWWN,
25189e86db79SHyon Kim void *pReqBuffer,
25199e86db79SHyon Kim HBA_UINT32 ReqBufferSize,
25209e86db79SHyon Kim void *pRspBuffer,
25219e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
25229e86db79SHyon Kim {
25239e86db79SHyon Kim HBA_STATUS status;
25249e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
25259e86db79SHyon Kim HBA_HANDLE vendorHandle;
25269e86db79SHyon Kim HBASendCTPassThruV2Func
25279e86db79SHyon Kim registeredfunc;
25289e86db79SHyon Kim
25299e86db79SHyon Kim DEBUG(2, "HBA_SendCTPassThruV2m hbaPortWWN: %s",
25309e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
25319e86db79SHyon Kim
25329e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
25339e86db79SHyon Kim registeredfunc = FUNCCOMMON(lib_infop, SendCTPassThruV2Handler);
25349e86db79SHyon Kim if (registeredfunc != NULL) {
25359e86db79SHyon Kim status = (registeredfunc)
25369e86db79SHyon Kim (vendorHandle, hbaPortWWN,
25379e86db79SHyon Kim pReqBuffer, ReqBufferSize,
25389e86db79SHyon Kim pRspBuffer, pRspBufferSize);
25399e86db79SHyon Kim } else {
25409e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
25419e86db79SHyon Kim }
25429e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
25439e86db79SHyon Kim }
25449e86db79SHyon Kim
25459e86db79SHyon Kim HBA_STATUS
HBA_GetEventBuffer(HBA_HANDLE handle,PHBA_EVENTINFO EventBuffer,HBA_UINT32 * EventBufferCount)25469e86db79SHyon Kim HBA_GetEventBuffer(
25479e86db79SHyon Kim HBA_HANDLE handle,
25489e86db79SHyon Kim PHBA_EVENTINFO EventBuffer,
25499e86db79SHyon Kim HBA_UINT32 *EventBufferCount)
25509e86db79SHyon Kim {
25519e86db79SHyon Kim HBA_STATUS status;
25529e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
25539e86db79SHyon Kim HBA_HANDLE vendorHandle;
25549e86db79SHyon Kim HBAGetEventBufferFunc
25559e86db79SHyon Kim GetEventBufferFunc;
25569e86db79SHyon Kim
25579e86db79SHyon Kim DEBUG(2, "HBA_GetEventBuffer", 0, 0, 0);
25589e86db79SHyon Kim
25599e86db79SHyon Kim CHECKLIBRARY();
25609e86db79SHyon Kim if (lib_infop->version == SMHBA) {
25619e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
25629e86db79SHyon Kim }
25639e86db79SHyon Kim
25649e86db79SHyon Kim GetEventBufferFunc =
25659e86db79SHyon Kim lib_infop->ftable.functionTable.GetEventBufferHandler;
25669e86db79SHyon Kim if (GetEventBufferFunc != NULL) {
25679e86db79SHyon Kim status = (GetEventBufferFunc)
25689e86db79SHyon Kim (vendorHandle, EventBuffer, EventBufferCount);
25699e86db79SHyon Kim } else {
25709e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
25719e86db79SHyon Kim }
25729e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
25739e86db79SHyon Kim }
25749e86db79SHyon Kim
25759e86db79SHyon Kim HBA_STATUS
HBA_SetRNIDMgmtInfo(HBA_HANDLE handle,HBA_MGMTINFO Info)25769e86db79SHyon Kim HBA_SetRNIDMgmtInfo(HBA_HANDLE handle, HBA_MGMTINFO Info) {
25779e86db79SHyon Kim HBA_STATUS status;
25789e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
25799e86db79SHyon Kim HBA_HANDLE vendorHandle;
25809e86db79SHyon Kim HBASetRNIDMgmtInfoFunc
25819e86db79SHyon Kim SetRNIDMgmtInfoFunc;
25829e86db79SHyon Kim
25839e86db79SHyon Kim DEBUG(2, "HBA_SetRNIDMgmtInfo", 0, 0, 0);
25849e86db79SHyon Kim
25859e86db79SHyon Kim CHECKLIBRARY();
25869e86db79SHyon Kim SetRNIDMgmtInfoFunc = FUNCCOMMON(lib_infop, SetRNIDMgmtInfoHandler);
25879e86db79SHyon Kim if (SetRNIDMgmtInfoFunc != NULL) {
25889e86db79SHyon Kim status = (SetRNIDMgmtInfoFunc)(vendorHandle, Info);
25899e86db79SHyon Kim } else {
25909e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
25919e86db79SHyon Kim }
25929e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
25939e86db79SHyon Kim }
25949e86db79SHyon Kim
25959e86db79SHyon Kim HBA_STATUS
HBA_GetRNIDMgmtInfo(HBA_HANDLE handle,HBA_MGMTINFO * pInfo)25969e86db79SHyon Kim HBA_GetRNIDMgmtInfo(HBA_HANDLE handle, HBA_MGMTINFO *pInfo) {
25979e86db79SHyon Kim HBA_STATUS status;
25989e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
25999e86db79SHyon Kim HBA_HANDLE vendorHandle;
26009e86db79SHyon Kim HBAGetRNIDMgmtInfoFunc
26019e86db79SHyon Kim GetRNIDMgmtInfoFunc;
26029e86db79SHyon Kim
26039e86db79SHyon Kim DEBUG(2, "HBA_GetRNIDMgmtInfo", 0, 0, 0);
26049e86db79SHyon Kim
26059e86db79SHyon Kim CHECKLIBRARY();
26069e86db79SHyon Kim GetRNIDMgmtInfoFunc = FUNCCOMMON(lib_infop, GetRNIDMgmtInfoHandler);
26079e86db79SHyon Kim if (GetRNIDMgmtInfoFunc != NULL) {
26089e86db79SHyon Kim status = (GetRNIDMgmtInfoFunc)(vendorHandle, pInfo);
26099e86db79SHyon Kim } else {
26109e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
26119e86db79SHyon Kim }
26129e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
26139e86db79SHyon Kim }
26149e86db79SHyon Kim
26159e86db79SHyon Kim HBA_STATUS
HBA_SendRNID(HBA_HANDLE handle,HBA_WWN wwn,HBA_WWNTYPE wwntype,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)26169e86db79SHyon Kim HBA_SendRNID(
26179e86db79SHyon Kim HBA_HANDLE handle,
26189e86db79SHyon Kim HBA_WWN wwn,
26199e86db79SHyon Kim HBA_WWNTYPE wwntype,
26209e86db79SHyon Kim void *pRspBuffer,
26219e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
26229e86db79SHyon Kim {
26239e86db79SHyon Kim HBA_STATUS status;
26249e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
26259e86db79SHyon Kim HBA_HANDLE vendorHandle;
26269e86db79SHyon Kim HBASendRNIDFunc SendRNIDFunc;
26279e86db79SHyon Kim
26289e86db79SHyon Kim DEBUG(2, "HBA_SendRNID for wwn: %s", WWN2STR1(&wwn), 0, 0);
26299e86db79SHyon Kim
26309e86db79SHyon Kim CHECKLIBRARY();
26319e86db79SHyon Kim if (lib_infop->version == SMHBA) {
26329e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
26339e86db79SHyon Kim }
26349e86db79SHyon Kim
26359e86db79SHyon Kim SendRNIDFunc = lib_infop->ftable.functionTable.SendRNIDHandler;
26369e86db79SHyon Kim if (SendRNIDFunc != NULL) {
26379e86db79SHyon Kim status = ((SendRNIDFunc)(vendorHandle, wwn, wwntype,
26389e86db79SHyon Kim pRspBuffer, pRspBufferSize));
26399e86db79SHyon Kim } else {
26409e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
26419e86db79SHyon Kim }
26429e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
26439e86db79SHyon Kim }
26449e86db79SHyon Kim
26459e86db79SHyon Kim HBA_STATUS
HBA_SendRNIDV2(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN destWWN,HBA_UINT32 destFCID,HBA_UINT32 NodeIdDataFormat,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)26469e86db79SHyon Kim HBA_SendRNIDV2(
26479e86db79SHyon Kim HBA_HANDLE handle,
26489e86db79SHyon Kim HBA_WWN hbaPortWWN,
26499e86db79SHyon Kim HBA_WWN destWWN,
26509e86db79SHyon Kim HBA_UINT32 destFCID,
26519e86db79SHyon Kim HBA_UINT32 NodeIdDataFormat,
26529e86db79SHyon Kim void *pRspBuffer,
26539e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
26549e86db79SHyon Kim {
26559e86db79SHyon Kim HBA_STATUS status;
26569e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
26579e86db79SHyon Kim HBA_HANDLE vendorHandle;
26589e86db79SHyon Kim HBASendRNIDV2Func registeredfunc;
26599e86db79SHyon Kim
26609e86db79SHyon Kim DEBUG(2, "HBA_SendRNIDV2, hbaPortWWN: %s", WWN2STR1(&hbaPortWWN), 0, 0);
26619e86db79SHyon Kim
26629e86db79SHyon Kim CHECKLIBRARY();
26639e86db79SHyon Kim registeredfunc = FUNCCOMMON(lib_infop, SendRNIDV2Handler);
26649e86db79SHyon Kim if (registeredfunc != NULL) {
26659e86db79SHyon Kim status = (registeredfunc)
26669e86db79SHyon Kim (vendorHandle, hbaPortWWN, destWWN, destFCID, NodeIdDataFormat,
26679e86db79SHyon Kim pRspBuffer, pRspBufferSize);
26689e86db79SHyon Kim } else {
26699e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
26709e86db79SHyon Kim }
26719e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
26729e86db79SHyon Kim }
26739e86db79SHyon Kim
26749e86db79SHyon Kim void
HBA_RefreshInformation(HBA_HANDLE handle)26759e86db79SHyon Kim HBA_RefreshInformation(HBA_HANDLE handle) {
26769e86db79SHyon Kim HBA_STATUS status;
26779e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
26789e86db79SHyon Kim HBA_HANDLE vendorHandle;
26799e86db79SHyon Kim HBARefreshInformationFunc
26809e86db79SHyon Kim RefreshInformationFunc;
26819e86db79SHyon Kim
26829e86db79SHyon Kim DEBUG(2, "HBA_RefreshInformation", 0, 0, 0);
26839e86db79SHyon Kim
26849e86db79SHyon Kim status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
26859e86db79SHyon Kim if (status == HBA_STATUS_OK) {
26869e86db79SHyon Kim RefreshInformationFunc =
26879e86db79SHyon Kim FUNCCOMMON(lib_infop, RefreshInformationHandler);
26889e86db79SHyon Kim if (RefreshInformationFunc != NULL) {
26899e86db79SHyon Kim ((RefreshInformationFunc)(vendorHandle));
26909e86db79SHyon Kim }
26919e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
26929e86db79SHyon Kim }
26939e86db79SHyon Kim }
26949e86db79SHyon Kim
26959e86db79SHyon Kim void
HBA_ResetStatistics(HBA_HANDLE handle,HBA_UINT32 portindex)26969e86db79SHyon Kim HBA_ResetStatistics(HBA_HANDLE handle, HBA_UINT32 portindex) {
26979e86db79SHyon Kim HBA_STATUS status;
26989e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
26999e86db79SHyon Kim HBA_HANDLE vendorHandle;
27009e86db79SHyon Kim HBAResetStatisticsFunc
27019e86db79SHyon Kim ResetStatisticsFunc;
27029e86db79SHyon Kim
27039e86db79SHyon Kim DEBUG(2, "HBA_ResetStatistics", 0, 0, 0);
27049e86db79SHyon Kim
27059e86db79SHyon Kim status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
27069e86db79SHyon Kim if (status == HBA_STATUS_OK) {
27079e86db79SHyon Kim if (lib_infop->version == SMHBA) {
27089e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
27099e86db79SHyon Kim }
27109e86db79SHyon Kim
27119e86db79SHyon Kim ResetStatisticsFunc =
27129e86db79SHyon Kim lib_infop->ftable.functionTable.ResetStatisticsHandler;
27139e86db79SHyon Kim if (ResetStatisticsFunc != NULL) {
27149e86db79SHyon Kim ((ResetStatisticsFunc)(vendorHandle, portindex));
27159e86db79SHyon Kim }
27169e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_LL_mutex);
27179e86db79SHyon Kim }
27189e86db79SHyon Kim }
27199e86db79SHyon Kim
27209e86db79SHyon Kim HBA_STATUS
HBA_GetFcpTargetMapping(HBA_HANDLE handle,PHBA_FCPTARGETMAPPING mapping)27219e86db79SHyon Kim HBA_GetFcpTargetMapping(HBA_HANDLE handle, PHBA_FCPTARGETMAPPING mapping) {
27229e86db79SHyon Kim HBA_STATUS status;
27239e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
27249e86db79SHyon Kim HBA_HANDLE vendorHandle;
27259e86db79SHyon Kim HBAGetFcpTargetMappingFunc GetFcpTargetMappingFunc;
27269e86db79SHyon Kim
27279e86db79SHyon Kim DEBUG(2, "HBA_GetFcpTargetMapping", 0, 0, 0);
27289e86db79SHyon Kim
27299e86db79SHyon Kim CHECKLIBRARY();
27309e86db79SHyon Kim if (lib_infop->version == SMHBA) {
27319e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
27329e86db79SHyon Kim }
27339e86db79SHyon Kim
27349e86db79SHyon Kim GetFcpTargetMappingFunc =
27359e86db79SHyon Kim lib_infop->ftable.functionTable.GetFcpTargetMappingHandler;
27369e86db79SHyon Kim if (GetFcpTargetMappingFunc != NULL) {
27379e86db79SHyon Kim status = ((GetFcpTargetMappingFunc)(vendorHandle, mapping));
27389e86db79SHyon Kim } else {
27399e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
27409e86db79SHyon Kim }
27419e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
27429e86db79SHyon Kim }
27439e86db79SHyon Kim
27449e86db79SHyon Kim HBA_STATUS
HBA_GetFcpTargetMappingV2(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_FCPTARGETMAPPINGV2 * pmapping)27459e86db79SHyon Kim HBA_GetFcpTargetMappingV2(
27469e86db79SHyon Kim HBA_HANDLE handle,
27479e86db79SHyon Kim HBA_WWN hbaPortWWN,
27489e86db79SHyon Kim HBA_FCPTARGETMAPPINGV2 *pmapping)
27499e86db79SHyon Kim {
27509e86db79SHyon Kim HBA_STATUS status;
27519e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
27529e86db79SHyon Kim HBA_HANDLE vendorHandle;
27539e86db79SHyon Kim HBAGetFcpTargetMappingV2Func
27549e86db79SHyon Kim registeredfunc;
27559e86db79SHyon Kim
27569e86db79SHyon Kim DEBUG(2, "HBA_GetFcpTargetMapping", 0, 0, 0);
27579e86db79SHyon Kim
27589e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
27599e86db79SHyon Kim
27609e86db79SHyon Kim registeredfunc =
27619e86db79SHyon Kim lib_infop->ftable.functionTable.GetFcpTargetMappingV2Handler;
27629e86db79SHyon Kim if (registeredfunc != NULL) {
27639e86db79SHyon Kim status = ((registeredfunc)(vendorHandle, hbaPortWWN, pmapping));
27649e86db79SHyon Kim } else {
27659e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
27669e86db79SHyon Kim }
27679e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
27689e86db79SHyon Kim }
27699e86db79SHyon Kim
27709e86db79SHyon Kim HBA_STATUS
HBA_GetFcpPersistentBinding(HBA_HANDLE handle,PHBA_FCPBINDING binding)27719e86db79SHyon Kim HBA_GetFcpPersistentBinding(HBA_HANDLE handle, PHBA_FCPBINDING binding) {
27729e86db79SHyon Kim HBA_STATUS status;
27739e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
27749e86db79SHyon Kim HBA_HANDLE vendorHandle;
27759e86db79SHyon Kim HBAGetFcpPersistentBindingFunc
27769e86db79SHyon Kim GetFcpPersistentBindingFunc;
27779e86db79SHyon Kim
27789e86db79SHyon Kim DEBUG(2, "HBA_GetFcpPersistentBinding", 0, 0, 0);
27799e86db79SHyon Kim
27809e86db79SHyon Kim CHECKLIBRARY();
27819e86db79SHyon Kim if (lib_infop->version == SMHBA) {
27829e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
27839e86db79SHyon Kim }
27849e86db79SHyon Kim
27859e86db79SHyon Kim GetFcpPersistentBindingFunc =
27869e86db79SHyon Kim lib_infop->ftable.functionTable.GetFcpPersistentBindingHandler;
27879e86db79SHyon Kim if (GetFcpPersistentBindingFunc != NULL) {
27889e86db79SHyon Kim status = ((GetFcpPersistentBindingFunc)(vendorHandle, binding));
27899e86db79SHyon Kim } else {
27909e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
27919e86db79SHyon Kim }
27929e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
27939e86db79SHyon Kim }
27949e86db79SHyon Kim
27959e86db79SHyon Kim HBA_STATUS
HBA_ScsiInquiryV2(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_UINT64 fcLUN,HBA_UINT8 CDB_Byte1,HBA_UINT8 CDB_Byte2,void * pRspBuffer,HBA_UINT32 * pRspBufferSize,HBA_UINT8 * pScsiStatus,void * pSenseBuffer,HBA_UINT32 * pSenseBufferSize)27969e86db79SHyon Kim HBA_ScsiInquiryV2(
27979e86db79SHyon Kim HBA_HANDLE handle,
27989e86db79SHyon Kim HBA_WWN hbaPortWWN,
27999e86db79SHyon Kim HBA_WWN discoveredPortWWN,
28009e86db79SHyon Kim HBA_UINT64 fcLUN,
28019e86db79SHyon Kim HBA_UINT8 CDB_Byte1,
28029e86db79SHyon Kim HBA_UINT8 CDB_Byte2,
28039e86db79SHyon Kim void *pRspBuffer,
28049e86db79SHyon Kim HBA_UINT32 *pRspBufferSize,
28059e86db79SHyon Kim HBA_UINT8 *pScsiStatus,
28069e86db79SHyon Kim void *pSenseBuffer,
28079e86db79SHyon Kim HBA_UINT32 *pSenseBufferSize)
28089e86db79SHyon Kim {
28099e86db79SHyon Kim HBA_STATUS status;
28109e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
28119e86db79SHyon Kim HBA_HANDLE vendorHandle;
28129e86db79SHyon Kim HBAScsiInquiryV2Func ScsiInquiryV2Func;
28139e86db79SHyon Kim
28149e86db79SHyon Kim DEBUG(2, "HBA_ScsiInquiryV2 to discoveredPortWWN: %s",
28159e86db79SHyon Kim WWN2STR1(&discoveredPortWWN), 0, 0);
28169e86db79SHyon Kim
28179e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
28189e86db79SHyon Kim
28199e86db79SHyon Kim ScsiInquiryV2Func =
28209e86db79SHyon Kim lib_infop->ftable.functionTable.ScsiInquiryV2Handler;
28219e86db79SHyon Kim if (ScsiInquiryV2Func != NULL) {
28229e86db79SHyon Kim status = ((ScsiInquiryV2Func)(
28239e86db79SHyon Kim vendorHandle, hbaPortWWN, discoveredPortWWN, fcLUN, CDB_Byte1,
28249e86db79SHyon Kim CDB_Byte2, pRspBuffer, pRspBufferSize, pScsiStatus,
28259e86db79SHyon Kim pSenseBuffer, pSenseBufferSize));
28269e86db79SHyon Kim } else {
28279e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
28289e86db79SHyon Kim }
28299e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
28309e86db79SHyon Kim }
28319e86db79SHyon Kim
28329e86db79SHyon Kim HBA_STATUS
HBA_SendScsiInquiry(HBA_HANDLE handle,HBA_WWN PortWWN,HBA_UINT64 fcLUN,HBA_UINT8 EVPD,HBA_UINT32 PageCode,void * pRspBuffer,HBA_UINT32 RspBufferSize,void * pSenseBuffer,HBA_UINT32 SenseBufferSize)28339e86db79SHyon Kim HBA_SendScsiInquiry(
28349e86db79SHyon Kim HBA_HANDLE handle,
28359e86db79SHyon Kim HBA_WWN PortWWN,
28369e86db79SHyon Kim HBA_UINT64 fcLUN,
28379e86db79SHyon Kim HBA_UINT8 EVPD,
28389e86db79SHyon Kim HBA_UINT32 PageCode,
28399e86db79SHyon Kim void *pRspBuffer,
28409e86db79SHyon Kim HBA_UINT32 RspBufferSize,
28419e86db79SHyon Kim void *pSenseBuffer,
28429e86db79SHyon Kim HBA_UINT32 SenseBufferSize)
28439e86db79SHyon Kim {
28449e86db79SHyon Kim HBA_STATUS status;
28459e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
28469e86db79SHyon Kim HBA_HANDLE vendorHandle;
28479e86db79SHyon Kim HBASendScsiInquiryFunc SendScsiInquiryFunc;
28489e86db79SHyon Kim
28499e86db79SHyon Kim DEBUG(2, "HBA_SendScsiInquiry to PortWWN: %s",
28509e86db79SHyon Kim WWN2STR1(&PortWWN), 0, 0);
28519e86db79SHyon Kim
28529e86db79SHyon Kim CHECKLIBRARY();
28539e86db79SHyon Kim if (lib_infop->version == SMHBA) {
28549e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
28559e86db79SHyon Kim }
28569e86db79SHyon Kim
28579e86db79SHyon Kim SendScsiInquiryFunc =
28589e86db79SHyon Kim lib_infop->ftable.functionTable.ScsiInquiryHandler;
28599e86db79SHyon Kim if (SendScsiInquiryFunc != NULL) {
28609e86db79SHyon Kim status = ((SendScsiInquiryFunc)(
28619e86db79SHyon Kim vendorHandle, PortWWN, fcLUN, EVPD, PageCode, pRspBuffer,
28629e86db79SHyon Kim RspBufferSize, pSenseBuffer, SenseBufferSize));
28639e86db79SHyon Kim } else {
28649e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
28659e86db79SHyon Kim }
28669e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
28679e86db79SHyon Kim }
28689e86db79SHyon Kim
28699e86db79SHyon Kim HBA_STATUS
HBA_ScsiReportLUNsV2(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,void * pRespBuffer,HBA_UINT32 * pRespBufferSize,HBA_UINT8 * pScsiStatus,void * pSenseBuffer,HBA_UINT32 * pSenseBufferSize)28709e86db79SHyon Kim HBA_ScsiReportLUNsV2(
28719e86db79SHyon Kim HBA_HANDLE handle,
28729e86db79SHyon Kim HBA_WWN hbaPortWWN,
28739e86db79SHyon Kim HBA_WWN discoveredPortWWN,
28749e86db79SHyon Kim void *pRespBuffer,
28759e86db79SHyon Kim HBA_UINT32 *pRespBufferSize,
28769e86db79SHyon Kim HBA_UINT8 *pScsiStatus,
28779e86db79SHyon Kim void *pSenseBuffer,
28789e86db79SHyon Kim HBA_UINT32 *pSenseBufferSize)
28799e86db79SHyon Kim {
28809e86db79SHyon Kim HBA_STATUS status;
28819e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
28829e86db79SHyon Kim HBA_HANDLE vendorHandle;
28839e86db79SHyon Kim HBAScsiReportLUNsV2Func ScsiReportLUNsV2Func;
28849e86db79SHyon Kim
28859e86db79SHyon Kim DEBUG(2, "HBA_ScsiReportLUNsV2 to discoveredPortWWN: %s",
28869e86db79SHyon Kim WWN2STR1(&discoveredPortWWN), 0, 0);
28879e86db79SHyon Kim
28889e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
28899e86db79SHyon Kim
28909e86db79SHyon Kim ScsiReportLUNsV2Func =
28919e86db79SHyon Kim lib_infop->ftable.functionTable.ScsiReportLUNsV2Handler;
28929e86db79SHyon Kim if (ScsiReportLUNsV2Func != NULL) {
28939e86db79SHyon Kim status = ((ScsiReportLUNsV2Func)(
28949e86db79SHyon Kim vendorHandle, hbaPortWWN, discoveredPortWWN,
28959e86db79SHyon Kim pRespBuffer, pRespBufferSize,
28969e86db79SHyon Kim pScsiStatus,
28979e86db79SHyon Kim pSenseBuffer, pSenseBufferSize));
28989e86db79SHyon Kim } else {
28999e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
29009e86db79SHyon Kim }
29019e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
29029e86db79SHyon Kim }
29039e86db79SHyon Kim
29049e86db79SHyon Kim HBA_STATUS
HBA_SendReportLUNs(HBA_HANDLE handle,HBA_WWN portWWN,void * pRspBuffer,HBA_UINT32 RspBufferSize,void * pSenseBuffer,HBA_UINT32 SenseBufferSize)29059e86db79SHyon Kim HBA_SendReportLUNs(
29069e86db79SHyon Kim HBA_HANDLE handle,
29079e86db79SHyon Kim HBA_WWN portWWN,
29089e86db79SHyon Kim void *pRspBuffer,
29099e86db79SHyon Kim HBA_UINT32 RspBufferSize,
29109e86db79SHyon Kim void *pSenseBuffer,
29119e86db79SHyon Kim HBA_UINT32 SenseBufferSize)
29129e86db79SHyon Kim {
29139e86db79SHyon Kim HBA_STATUS status;
29149e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
29159e86db79SHyon Kim HBA_HANDLE vendorHandle;
29169e86db79SHyon Kim HBASendReportLUNsFunc SendReportLUNsFunc;
29179e86db79SHyon Kim
29189e86db79SHyon Kim DEBUG(2, "HBA_SendReportLUNs to PortWWN: %s", WWN2STR1(&portWWN), 0, 0);
29199e86db79SHyon Kim
29209e86db79SHyon Kim CHECKLIBRARY();
29219e86db79SHyon Kim if (lib_infop->version == SMHBA) {
29229e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
29239e86db79SHyon Kim }
29249e86db79SHyon Kim
29259e86db79SHyon Kim SendReportLUNsFunc = lib_infop->ftable.functionTable.ReportLUNsHandler;
29269e86db79SHyon Kim if (SendReportLUNsFunc != NULL) {
29279e86db79SHyon Kim status = ((SendReportLUNsFunc)(
29289e86db79SHyon Kim vendorHandle, portWWN, pRspBuffer,
29299e86db79SHyon Kim RspBufferSize, pSenseBuffer, SenseBufferSize));
29309e86db79SHyon Kim } else {
29319e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
29329e86db79SHyon Kim }
29339e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
29349e86db79SHyon Kim }
29359e86db79SHyon Kim
29369e86db79SHyon Kim HBA_STATUS
HBA_ScsiReadCapacityV2(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_UINT64 fcLUN,void * pRspBuffer,HBA_UINT32 * pRspBufferSize,HBA_UINT8 * pScsiStatus,void * pSenseBuffer,HBA_UINT32 * SenseBufferSize)29379e86db79SHyon Kim HBA_ScsiReadCapacityV2(
29389e86db79SHyon Kim HBA_HANDLE handle,
29399e86db79SHyon Kim HBA_WWN hbaPortWWN,
29409e86db79SHyon Kim HBA_WWN discoveredPortWWN,
29419e86db79SHyon Kim HBA_UINT64 fcLUN,
29429e86db79SHyon Kim void *pRspBuffer,
29439e86db79SHyon Kim HBA_UINT32 *pRspBufferSize,
29449e86db79SHyon Kim HBA_UINT8 *pScsiStatus,
29459e86db79SHyon Kim void *pSenseBuffer,
29469e86db79SHyon Kim HBA_UINT32 *SenseBufferSize)
29479e86db79SHyon Kim {
29489e86db79SHyon Kim HBA_STATUS status;
29499e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
29509e86db79SHyon Kim HBA_HANDLE vendorHandle;
29519e86db79SHyon Kim HBAScsiReadCapacityV2Func ScsiReadCapacityV2Func;
29529e86db79SHyon Kim
29539e86db79SHyon Kim DEBUG(2, "HBA_ScsiReadCapacityV2 to discoveredPortWWN: %s",
29549e86db79SHyon Kim WWN2STR1(&discoveredPortWWN), 0, 0);
29559e86db79SHyon Kim
29569e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
29579e86db79SHyon Kim
29589e86db79SHyon Kim ScsiReadCapacityV2Func =
29599e86db79SHyon Kim lib_infop->ftable.functionTable.ScsiReadCapacityV2Handler;
29609e86db79SHyon Kim if (ScsiReadCapacityV2Func != NULL) {
29619e86db79SHyon Kim status = ((ScsiReadCapacityV2Func)(
29629e86db79SHyon Kim vendorHandle, hbaPortWWN, discoveredPortWWN, fcLUN,
29639e86db79SHyon Kim pRspBuffer, pRspBufferSize,
29649e86db79SHyon Kim pScsiStatus,
29659e86db79SHyon Kim pSenseBuffer, SenseBufferSize));
29669e86db79SHyon Kim } else {
29679e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
29689e86db79SHyon Kim }
29699e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
29709e86db79SHyon Kim }
29719e86db79SHyon Kim
29729e86db79SHyon Kim HBA_STATUS
HBA_SendReadCapacity(HBA_HANDLE handle,HBA_WWN portWWN,HBA_UINT64 fcLUN,void * pRspBuffer,HBA_UINT32 RspBufferSize,void * pSenseBuffer,HBA_UINT32 SenseBufferSize)29739e86db79SHyon Kim HBA_SendReadCapacity(
29749e86db79SHyon Kim HBA_HANDLE handle,
29759e86db79SHyon Kim HBA_WWN portWWN,
29769e86db79SHyon Kim HBA_UINT64 fcLUN,
29779e86db79SHyon Kim void *pRspBuffer,
29789e86db79SHyon Kim HBA_UINT32 RspBufferSize,
29799e86db79SHyon Kim void *pSenseBuffer,
29809e86db79SHyon Kim HBA_UINT32 SenseBufferSize)
29819e86db79SHyon Kim {
29829e86db79SHyon Kim HBA_STATUS status;
29839e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
29849e86db79SHyon Kim HBA_HANDLE vendorHandle;
29859e86db79SHyon Kim HBASendReadCapacityFunc SendReadCapacityFunc;
29869e86db79SHyon Kim
29879e86db79SHyon Kim DEBUG(2, "HBA_SendReadCapacity to portWWN: %s",
29889e86db79SHyon Kim WWN2STR1(&portWWN), 0, 0);
29899e86db79SHyon Kim
29909e86db79SHyon Kim CHECKLIBRARY();
29919e86db79SHyon Kim if (lib_infop->version == SMHBA) {
29929e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
29939e86db79SHyon Kim }
29949e86db79SHyon Kim
29959e86db79SHyon Kim SendReadCapacityFunc =
29969e86db79SHyon Kim lib_infop->ftable.functionTable.ReadCapacityHandler;
29979e86db79SHyon Kim if (SendReadCapacityFunc != NULL) {
29989e86db79SHyon Kim status = ((SendReadCapacityFunc)
29999e86db79SHyon Kim (vendorHandle, portWWN, fcLUN, pRspBuffer,
30009e86db79SHyon Kim RspBufferSize, pSenseBuffer, SenseBufferSize));
30019e86db79SHyon Kim } else {
30029e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
30039e86db79SHyon Kim }
30049e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
30059e86db79SHyon Kim }
30069e86db79SHyon Kim
30079e86db79SHyon Kim HBA_STATUS
HBA_SendRPL(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN agent_wwn,HBA_UINT32 agent_domain,HBA_UINT32 portindex,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)30089e86db79SHyon Kim HBA_SendRPL(
30099e86db79SHyon Kim HBA_HANDLE handle,
30109e86db79SHyon Kim HBA_WWN hbaPortWWN,
30119e86db79SHyon Kim HBA_WWN agent_wwn,
30129e86db79SHyon Kim HBA_UINT32 agent_domain,
30139e86db79SHyon Kim HBA_UINT32 portindex,
30149e86db79SHyon Kim void *pRspBuffer,
30159e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
30169e86db79SHyon Kim {
30179e86db79SHyon Kim HBA_STATUS status;
30189e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
30199e86db79SHyon Kim HBA_HANDLE vendorHandle;
30209e86db79SHyon Kim HBASendRPLFunc registeredfunc;
30219e86db79SHyon Kim
30229e86db79SHyon Kim DEBUG(2, "HBA_SendRPL to agent_wwn: %s:%d",
30239e86db79SHyon Kim WWN2STR1(&agent_wwn), agent_domain, 0);
30249e86db79SHyon Kim
30259e86db79SHyon Kim CHECKLIBRARY();
30269e86db79SHyon Kim registeredfunc = FUNCCOMMON(lib_infop, SendRPLHandler);
30279e86db79SHyon Kim if (registeredfunc != NULL) {
30289e86db79SHyon Kim status = (registeredfunc)(
30299e86db79SHyon Kim vendorHandle, hbaPortWWN, agent_wwn, agent_domain, portindex,
30309e86db79SHyon Kim pRspBuffer, pRspBufferSize);
30319e86db79SHyon Kim } else {
30329e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
30339e86db79SHyon Kim }
30349e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
30359e86db79SHyon Kim }
30369e86db79SHyon Kim
30379e86db79SHyon Kim HBA_STATUS
HBA_SendRPS(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN agent_wwn,HBA_UINT32 agent_domain,HBA_WWN object_wwn,HBA_UINT32 object_port_number,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)30389e86db79SHyon Kim HBA_SendRPS(
30399e86db79SHyon Kim HBA_HANDLE handle,
30409e86db79SHyon Kim HBA_WWN hbaPortWWN,
30419e86db79SHyon Kim HBA_WWN agent_wwn,
30429e86db79SHyon Kim HBA_UINT32 agent_domain,
30439e86db79SHyon Kim HBA_WWN object_wwn,
30449e86db79SHyon Kim HBA_UINT32 object_port_number,
30459e86db79SHyon Kim void *pRspBuffer,
30469e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
30479e86db79SHyon Kim {
30489e86db79SHyon Kim HBA_STATUS status;
30499e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
30509e86db79SHyon Kim HBA_HANDLE vendorHandle;
30519e86db79SHyon Kim HBASendRPSFunc registeredfunc;
30529e86db79SHyon Kim
30539e86db79SHyon Kim DEBUG(2, "HBA_SendRPS to agent_wwn: %s:%d",
30549e86db79SHyon Kim WWN2STR1(&agent_wwn), agent_domain, 0);
30559e86db79SHyon Kim
30569e86db79SHyon Kim CHECKLIBRARY();
30579e86db79SHyon Kim registeredfunc = FUNCCOMMON(lib_infop, SendRPSHandler);
30589e86db79SHyon Kim if (registeredfunc != NULL) {
30599e86db79SHyon Kim status = (registeredfunc)(
30609e86db79SHyon Kim vendorHandle, hbaPortWWN, agent_wwn, agent_domain,
30619e86db79SHyon Kim object_wwn, object_port_number,
30629e86db79SHyon Kim pRspBuffer, pRspBufferSize);
30639e86db79SHyon Kim } else {
30649e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
30659e86db79SHyon Kim }
30669e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
30679e86db79SHyon Kim }
30689e86db79SHyon Kim
30699e86db79SHyon Kim HBA_STATUS
HBA_SendSRL(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN wwn,HBA_UINT32 domain,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)30709e86db79SHyon Kim HBA_SendSRL(
30719e86db79SHyon Kim HBA_HANDLE handle,
30729e86db79SHyon Kim HBA_WWN hbaPortWWN,
30739e86db79SHyon Kim HBA_WWN wwn,
30749e86db79SHyon Kim HBA_UINT32 domain,
30759e86db79SHyon Kim void *pRspBuffer,
30769e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
30779e86db79SHyon Kim {
30789e86db79SHyon Kim HBA_STATUS status;
30799e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
30809e86db79SHyon Kim HBA_HANDLE vendorHandle;
30819e86db79SHyon Kim HBASendSRLFunc registeredfunc;
30829e86db79SHyon Kim
30839e86db79SHyon Kim DEBUG(2, "HBA_SendSRL to wwn:%s domain:%d", WWN2STR1(&wwn), domain, 0);
30849e86db79SHyon Kim
30859e86db79SHyon Kim CHECKLIBRARY();
30869e86db79SHyon Kim registeredfunc = FUNCCOMMON(lib_infop, SendSRLHandler);
30879e86db79SHyon Kim if (registeredfunc != NULL) {
30889e86db79SHyon Kim status = (registeredfunc)(
30899e86db79SHyon Kim vendorHandle, hbaPortWWN, wwn, domain,
30909e86db79SHyon Kim pRspBuffer, pRspBufferSize);
30919e86db79SHyon Kim } else {
30929e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
30939e86db79SHyon Kim }
30949e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
30959e86db79SHyon Kim }
30969e86db79SHyon Kim HBA_STATUS
HBA_SendRLS(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN destWWN,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)30979e86db79SHyon Kim HBA_SendRLS(
30989e86db79SHyon Kim HBA_HANDLE handle,
30999e86db79SHyon Kim HBA_WWN hbaPortWWN,
31009e86db79SHyon Kim HBA_WWN destWWN,
31019e86db79SHyon Kim void *pRspBuffer,
31029e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
31039e86db79SHyon Kim {
31049e86db79SHyon Kim HBA_STATUS status;
31059e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
31069e86db79SHyon Kim HBA_HANDLE vendorHandle;
31079e86db79SHyon Kim HBASendRLSFunc registeredfunc;
31089e86db79SHyon Kim
31099e86db79SHyon Kim DEBUG(2, "HBA_SendRLS dest_wwn: %s",
31109e86db79SHyon Kim WWN2STR1(&destWWN), 0, 0);
31119e86db79SHyon Kim
31129e86db79SHyon Kim CHECKLIBRARY();
31139e86db79SHyon Kim registeredfunc = FUNCCOMMON(lib_infop, SendRLSHandler);
31149e86db79SHyon Kim if (registeredfunc != NULL) {
31159e86db79SHyon Kim status = (registeredfunc)(
31169e86db79SHyon Kim vendorHandle, hbaPortWWN, destWWN,
31179e86db79SHyon Kim pRspBuffer, pRspBufferSize);
31189e86db79SHyon Kim } else {
31199e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
31209e86db79SHyon Kim }
31219e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
31229e86db79SHyon Kim }
31239e86db79SHyon Kim
31249e86db79SHyon Kim HBA_STATUS
HBA_SendLIRR(HBA_HANDLE handle,HBA_WWN sourceWWN,HBA_WWN destWWN,HBA_UINT8 function,HBA_UINT8 type,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)31259e86db79SHyon Kim HBA_SendLIRR(
31269e86db79SHyon Kim HBA_HANDLE handle,
31279e86db79SHyon Kim HBA_WWN sourceWWN,
31289e86db79SHyon Kim HBA_WWN destWWN,
31299e86db79SHyon Kim HBA_UINT8 function,
31309e86db79SHyon Kim HBA_UINT8 type,
31319e86db79SHyon Kim void *pRspBuffer,
31329e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
31339e86db79SHyon Kim {
31349e86db79SHyon Kim HBA_STATUS status;
31359e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
31369e86db79SHyon Kim HBA_HANDLE vendorHandle;
31379e86db79SHyon Kim HBASendLIRRFunc registeredfunc;
31389e86db79SHyon Kim
31399e86db79SHyon Kim DEBUG(2, "HBA_SendLIRR destWWN:%s", WWN2STR1(&destWWN), 0, 0);
31409e86db79SHyon Kim
31419e86db79SHyon Kim CHECKLIBRARY();
31429e86db79SHyon Kim registeredfunc = FUNCCOMMON(lib_infop, SendLIRRHandler);
31439e86db79SHyon Kim if (registeredfunc != NULL) {
31449e86db79SHyon Kim status = (registeredfunc)(
31459e86db79SHyon Kim vendorHandle, sourceWWN, destWWN, function, type,
31469e86db79SHyon Kim pRspBuffer, pRspBufferSize);
31479e86db79SHyon Kim } else {
31489e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
31499e86db79SHyon Kim }
31509e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
31519e86db79SHyon Kim }
31529e86db79SHyon Kim
31539e86db79SHyon Kim HBA_STATUS
HBA_GetBindingCapability(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_BIND_CAPABILITY * pcapability)31549e86db79SHyon Kim HBA_GetBindingCapability(
31559e86db79SHyon Kim HBA_HANDLE handle,
31569e86db79SHyon Kim HBA_WWN hbaPortWWN,
31579e86db79SHyon Kim HBA_BIND_CAPABILITY *pcapability)
31589e86db79SHyon Kim {
31599e86db79SHyon Kim HBA_STATUS status;
31609e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
31619e86db79SHyon Kim HBA_HANDLE vendorHandle;
31629e86db79SHyon Kim HBAGetBindingCapabilityFunc
31639e86db79SHyon Kim registeredfunc;
31649e86db79SHyon Kim
31659e86db79SHyon Kim DEBUG(2, "HBA_GetBindingCapability", 0, 0, 0);
31669e86db79SHyon Kim
31679e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
31689e86db79SHyon Kim
31699e86db79SHyon Kim registeredfunc =
31709e86db79SHyon Kim lib_infop->ftable.functionTable.GetBindingCapabilityHandler;
31719e86db79SHyon Kim if (registeredfunc != NULL) {
31729e86db79SHyon Kim status = (registeredfunc)(vendorHandle, hbaPortWWN, pcapability);
31739e86db79SHyon Kim } else {
31749e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
31759e86db79SHyon Kim }
31769e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
31779e86db79SHyon Kim }
31789e86db79SHyon Kim
31799e86db79SHyon Kim HBA_STATUS
HBA_GetBindingSupport(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_BIND_CAPABILITY * pcapability)31809e86db79SHyon Kim HBA_GetBindingSupport(
31819e86db79SHyon Kim HBA_HANDLE handle,
31829e86db79SHyon Kim HBA_WWN hbaPortWWN,
31839e86db79SHyon Kim HBA_BIND_CAPABILITY *pcapability)
31849e86db79SHyon Kim {
31859e86db79SHyon Kim HBA_STATUS status;
31869e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
31879e86db79SHyon Kim HBA_HANDLE vendorHandle;
31889e86db79SHyon Kim HBAGetBindingSupportFunc
31899e86db79SHyon Kim registeredfunc;
31909e86db79SHyon Kim
31919e86db79SHyon Kim DEBUG(2, "HBA_GetBindingSupport", 0, 0, 0);
31929e86db79SHyon Kim
31939e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
31949e86db79SHyon Kim
31959e86db79SHyon Kim registeredfunc =
31969e86db79SHyon Kim lib_infop->ftable.functionTable.GetBindingSupportHandler;
31979e86db79SHyon Kim if (registeredfunc != NULL) {
31989e86db79SHyon Kim status = (registeredfunc)(vendorHandle, hbaPortWWN, pcapability);
31999e86db79SHyon Kim } else {
32009e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
32019e86db79SHyon Kim }
32029e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
32039e86db79SHyon Kim }
32049e86db79SHyon Kim
32059e86db79SHyon Kim HBA_STATUS
HBA_SetBindingSupport(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_BIND_CAPABILITY capability)32069e86db79SHyon Kim HBA_SetBindingSupport(
32079e86db79SHyon Kim HBA_HANDLE handle,
32089e86db79SHyon Kim HBA_WWN hbaPortWWN,
32099e86db79SHyon Kim HBA_BIND_CAPABILITY capability)
32109e86db79SHyon Kim {
32119e86db79SHyon Kim HBA_STATUS status;
32129e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
32139e86db79SHyon Kim HBA_HANDLE vendorHandle;
32149e86db79SHyon Kim HBASetBindingSupportFunc
32159e86db79SHyon Kim registeredfunc;
32169e86db79SHyon Kim
32179e86db79SHyon Kim DEBUG(2, "HBA_SetBindingSupport", 0, 0, 0);
32189e86db79SHyon Kim
32199e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
32209e86db79SHyon Kim
32219e86db79SHyon Kim registeredfunc =
32229e86db79SHyon Kim lib_infop->ftable.functionTable.SetBindingSupportHandler;
32239e86db79SHyon Kim if (registeredfunc != NULL) {
32249e86db79SHyon Kim status = (registeredfunc)(vendorHandle, hbaPortWWN, capability);
32259e86db79SHyon Kim } else {
32269e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
32279e86db79SHyon Kim }
32289e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
32299e86db79SHyon Kim }
32309e86db79SHyon Kim
32319e86db79SHyon Kim HBA_STATUS
HBA_SetPersistentBindingV2(HBA_HANDLE handle,HBA_WWN hbaPortWWN,const HBA_FCPBINDING2 * pbinding)32329e86db79SHyon Kim HBA_SetPersistentBindingV2(
32339e86db79SHyon Kim HBA_HANDLE handle,
32349e86db79SHyon Kim HBA_WWN hbaPortWWN,
32359e86db79SHyon Kim const HBA_FCPBINDING2 *pbinding)
32369e86db79SHyon Kim {
32379e86db79SHyon Kim HBA_STATUS status;
32389e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
32399e86db79SHyon Kim HBA_HANDLE vendorHandle;
32409e86db79SHyon Kim HBASetPersistentBindingV2Func
32419e86db79SHyon Kim registeredfunc;
32429e86db79SHyon Kim
32439e86db79SHyon Kim DEBUG(2, "HBA_SetPersistentBindingV2 port: %s",
32449e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
32459e86db79SHyon Kim
32469e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
32479e86db79SHyon Kim
32489e86db79SHyon Kim registeredfunc =
32499e86db79SHyon Kim lib_infop->ftable.functionTable.SetPersistentBindingV2Handler;
32509e86db79SHyon Kim if (registeredfunc != NULL) {
32519e86db79SHyon Kim status = (registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
32529e86db79SHyon Kim } else {
32539e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
32549e86db79SHyon Kim }
32559e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
32569e86db79SHyon Kim }
32579e86db79SHyon Kim
32589e86db79SHyon Kim HBA_STATUS
HBA_GetPersistentBindingV2(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_FCPBINDING2 * pbinding)32599e86db79SHyon Kim HBA_GetPersistentBindingV2(
32609e86db79SHyon Kim HBA_HANDLE handle,
32619e86db79SHyon Kim HBA_WWN hbaPortWWN,
32629e86db79SHyon Kim HBA_FCPBINDING2 *pbinding)
32639e86db79SHyon Kim {
32649e86db79SHyon Kim HBA_STATUS status;
32659e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
32669e86db79SHyon Kim HBA_HANDLE vendorHandle;
32679e86db79SHyon Kim HBAGetPersistentBindingV2Func
32689e86db79SHyon Kim registeredfunc;
32699e86db79SHyon Kim
32709e86db79SHyon Kim DEBUG(2, "HBA_GetPersistentBindingV2 port: %s",
32719e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
32729e86db79SHyon Kim
32739e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
32749e86db79SHyon Kim
32759e86db79SHyon Kim registeredfunc =
32769e86db79SHyon Kim lib_infop->ftable.functionTable.GetPersistentBindingV2Handler;
32779e86db79SHyon Kim if (registeredfunc != NULL) {
32789e86db79SHyon Kim status = (registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
32799e86db79SHyon Kim } else {
32809e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
32819e86db79SHyon Kim }
32829e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
32839e86db79SHyon Kim }
32849e86db79SHyon Kim
32859e86db79SHyon Kim HBA_STATUS
HBA_RemovePersistentBinding(HBA_HANDLE handle,HBA_WWN hbaPortWWN,const HBA_FCPBINDING2 * pbinding)32869e86db79SHyon Kim HBA_RemovePersistentBinding(
32879e86db79SHyon Kim HBA_HANDLE handle,
32889e86db79SHyon Kim HBA_WWN hbaPortWWN,
32899e86db79SHyon Kim const HBA_FCPBINDING2
32909e86db79SHyon Kim *pbinding)
32919e86db79SHyon Kim {
32929e86db79SHyon Kim HBA_STATUS status;
32939e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
32949e86db79SHyon Kim HBA_HANDLE vendorHandle;
32959e86db79SHyon Kim HBARemovePersistentBindingFunc
32969e86db79SHyon Kim registeredfunc;
32979e86db79SHyon Kim
32989e86db79SHyon Kim DEBUG(2, "HBA_RemovePersistentBinding", 0, 0, 0);
32999e86db79SHyon Kim
33009e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
33019e86db79SHyon Kim
33029e86db79SHyon Kim registeredfunc =
33039e86db79SHyon Kim lib_infop->ftable.functionTable.RemovePersistentBindingHandler;
33049e86db79SHyon Kim if (registeredfunc != NULL) {
33059e86db79SHyon Kim status = (registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
33069e86db79SHyon Kim } else {
33079e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
33089e86db79SHyon Kim }
33099e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
33109e86db79SHyon Kim }
33119e86db79SHyon Kim
33129e86db79SHyon Kim HBA_STATUS
HBA_RemoveAllPersistentBindings(HBA_HANDLE handle,HBA_WWN hbaPortWWN)33139e86db79SHyon Kim HBA_RemoveAllPersistentBindings(
33149e86db79SHyon Kim HBA_HANDLE handle,
33159e86db79SHyon Kim HBA_WWN hbaPortWWN)
33169e86db79SHyon Kim {
33179e86db79SHyon Kim HBA_STATUS status;
33189e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
33199e86db79SHyon Kim HBA_HANDLE vendorHandle;
33209e86db79SHyon Kim HBARemoveAllPersistentBindingsFunc
33219e86db79SHyon Kim registeredfunc;
33229e86db79SHyon Kim
33239e86db79SHyon Kim DEBUG(2, "HBA_RemoveAllPersistentBindings", 0, 0, 0);
33249e86db79SHyon Kim
33259e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
33269e86db79SHyon Kim
33279e86db79SHyon Kim registeredfunc =
33289e86db79SHyon Kim lib_infop->ftable.functionTable.RemoveAllPersistentBindingsHandler;
33299e86db79SHyon Kim if (registeredfunc != NULL) {
33309e86db79SHyon Kim status = (registeredfunc)(vendorHandle, hbaPortWWN);
33319e86db79SHyon Kim } else {
33329e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
33339e86db79SHyon Kim }
33349e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
33359e86db79SHyon Kim }
33369e86db79SHyon Kim
33379e86db79SHyon Kim HBA_STATUS
HBA_GetFC4Statistics(HBA_HANDLE handle,HBA_WWN portWWN,HBA_UINT8 FC4type,HBA_FC4STATISTICS * pstatistics)33389e86db79SHyon Kim HBA_GetFC4Statistics(
33399e86db79SHyon Kim HBA_HANDLE handle,
33409e86db79SHyon Kim HBA_WWN portWWN,
33419e86db79SHyon Kim HBA_UINT8 FC4type,
33429e86db79SHyon Kim HBA_FC4STATISTICS *pstatistics)
33439e86db79SHyon Kim {
33449e86db79SHyon Kim HBA_STATUS status;
33459e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
33469e86db79SHyon Kim HBA_HANDLE vendorHandle;
33479e86db79SHyon Kim HBAGetFC4StatisticsFunc
33489e86db79SHyon Kim registeredfunc;
33499e86db79SHyon Kim
33509e86db79SHyon Kim DEBUG(2, "HBA_GetFC4Statistics port: %s", WWN2STR1(&portWWN), 0, 0);
33519e86db79SHyon Kim
33529e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
33539e86db79SHyon Kim
33549e86db79SHyon Kim registeredfunc =
33559e86db79SHyon Kim lib_infop->ftable.functionTable.GetFC4StatisticsHandler;
33569e86db79SHyon Kim if (registeredfunc != NULL) {
33579e86db79SHyon Kim status = (registeredfunc)
33589e86db79SHyon Kim (vendorHandle, portWWN, FC4type, pstatistics);
33599e86db79SHyon Kim } else {
33609e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
33619e86db79SHyon Kim }
33629e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
33639e86db79SHyon Kim }
33649e86db79SHyon Kim
33659e86db79SHyon Kim HBA_STATUS
HBA_GetFCPStatistics(HBA_HANDLE handle,const HBA_SCSIID * lunit,HBA_FC4STATISTICS * pstatistics)33669e86db79SHyon Kim HBA_GetFCPStatistics(
33679e86db79SHyon Kim HBA_HANDLE handle,
33689e86db79SHyon Kim const HBA_SCSIID *lunit,
33699e86db79SHyon Kim HBA_FC4STATISTICS *pstatistics)
33709e86db79SHyon Kim {
33719e86db79SHyon Kim HBA_STATUS status;
33729e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
33739e86db79SHyon Kim HBA_HANDLE vendorHandle;
33749e86db79SHyon Kim HBAGetFCPStatisticsFunc
33759e86db79SHyon Kim registeredfunc;
33769e86db79SHyon Kim
33779e86db79SHyon Kim DEBUG(2, "HBA_GetFCPStatistics", 0, 0, 0);
33789e86db79SHyon Kim
33799e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
33809e86db79SHyon Kim
33819e86db79SHyon Kim registeredfunc =
33829e86db79SHyon Kim lib_infop->ftable.functionTable.GetFCPStatisticsHandler;
33839e86db79SHyon Kim if (registeredfunc != NULL) {
33849e86db79SHyon Kim status = (registeredfunc)(vendorHandle, lunit, pstatistics);
33859e86db79SHyon Kim } else {
33869e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
33879e86db79SHyon Kim }
33889e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
33899e86db79SHyon Kim }
33909e86db79SHyon Kim
33919e86db79SHyon Kim HBA_UINT32
HBA_GetVendorLibraryAttributes(HBA_UINT32 adapter_index,HBA_LIBRARYATTRIBUTES * attributes)33929e86db79SHyon Kim HBA_GetVendorLibraryAttributes(
33939e86db79SHyon Kim HBA_UINT32 adapter_index,
33949e86db79SHyon Kim HBA_LIBRARYATTRIBUTES *attributes)
33959e86db79SHyon Kim {
33969e86db79SHyon Kim HBA_ADAPTER_INFO *adapt_infop;
33979e86db79SHyon Kim HBAGetVendorLibraryAttributesFunc
33989e86db79SHyon Kim registeredfunc;
33999e86db79SHyon Kim HBA_UINT32 ret = 0;
34009e86db79SHyon Kim
34019e86db79SHyon Kim DEBUG(2, "HBA_GetVendorLibraryAttributes adapterindex:%d",
34029e86db79SHyon Kim adapter_index, 0, 0);
34039e86db79SHyon Kim if (_hbaapi_librarylist == NULL) {
34049e86db79SHyon Kim DEBUG(1, "HBAAPI not loaded yet.", 0, 0, 0);
34059e86db79SHyon Kim return (0);
34069e86db79SHyon Kim }
34079e86db79SHyon Kim
34089e86db79SHyon Kim if (attributes == NULL) {
34099e86db79SHyon Kim DEBUG(1,
34109e86db79SHyon Kim "HBA_GetVendorLibraryAttributes: NULL pointer attributes",
34119e86db79SHyon Kim 0, 0, 0);
34129e86db79SHyon Kim return (HBA_STATUS_ERROR_ARG);
34139e86db79SHyon Kim }
34149e86db79SHyon Kim
34159e86db79SHyon Kim (void) memset(attributes, 0, sizeof (HBA_LIBRARYATTRIBUTES));
34169e86db79SHyon Kim
34179e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
34189e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AL_mutex);
34199e86db79SHyon Kim for (adapt_infop = _hbaapi_adapterlist;
34209e86db79SHyon Kim adapt_infop != NULL;
34219e86db79SHyon Kim adapt_infop = adapt_infop->next) {
34229e86db79SHyon Kim
34239e86db79SHyon Kim if (adapt_infop->index == adapter_index) {
34249e86db79SHyon Kim
34259e86db79SHyon Kim if (adapt_infop->library->version == SMHBA) {
34269e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AL_mutex);
34279e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex,
34289e86db79SHyon Kim HBA_STATUS_ERROR_INCOMPATIBLE);
34299e86db79SHyon Kim }
34309e86db79SHyon Kim
34319e86db79SHyon Kim registeredfunc = adapt_infop->library->
34329e86db79SHyon Kim ftable.functionTable.GetVendorLibraryAttributesHandler;
34339e86db79SHyon Kim if (registeredfunc != NULL) {
34349e86db79SHyon Kim ret = (registeredfunc)(attributes);
34359e86db79SHyon Kim } else {
34369e86db79SHyon Kim /* Version 1 libary? */
34379e86db79SHyon Kim HBAGetVersionFunc GetVersionFunc;
34389e86db79SHyon Kim GetVersionFunc = adapt_infop->library->
34399e86db79SHyon Kim ftable.functionTable.GetVersionHandler;
34409e86db79SHyon Kim if (GetVersionFunc != NULL) {
34419e86db79SHyon Kim ret = ((GetVersionFunc)());
34429e86db79SHyon Kim }
34439e86db79SHyon Kim #ifdef NOTDEF
34449e86db79SHyon Kim else {
34459e86db79SHyon Kim /* This should not happen, dont think its going to */
34469e86db79SHyon Kim }
34479e86db79SHyon Kim #endif
34489e86db79SHyon Kim }
34499e86db79SHyon Kim if (attributes->LibPath[0] == '\0') {
34509e86db79SHyon Kim if (strlen(adapt_infop->library->LibraryPath) < 256) {
34519e86db79SHyon Kim (void) strcpy(attributes->LibPath,
34529e86db79SHyon Kim adapt_infop->library->LibraryPath);
34539e86db79SHyon Kim }
34549e86db79SHyon Kim }
34559e86db79SHyon Kim break;
34569e86db79SHyon Kim }
34579e86db79SHyon Kim }
34589e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AL_mutex);
34599e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, ret);
34609e86db79SHyon Kim }
34619e86db79SHyon Kim
34629e86db79SHyon Kim
34639e86db79SHyon Kim /*
34649e86db79SHyon Kim * This function returns SM-HBA version that the warpper library implemented.
34659e86db79SHyon Kim */
34669e86db79SHyon Kim HBA_UINT32
SMHBA_GetVersion()34679e86db79SHyon Kim SMHBA_GetVersion() {
34689e86db79SHyon Kim DEBUG(2, "SMHBA_GetVersion", 0, 0, 0);
34699e86db79SHyon Kim return (SMHBA_LIBVERSION);
34709e86db79SHyon Kim }
34719e86db79SHyon Kim
34729e86db79SHyon Kim /*
34739e86db79SHyon Kim * This function returns the attributes for the warpper library.
34749e86db79SHyon Kim */
34759e86db79SHyon Kim HBA_UINT32
SMHBA_GetWrapperLibraryAttributes(SMHBA_LIBRARYATTRIBUTES * attributes)34769e86db79SHyon Kim SMHBA_GetWrapperLibraryAttributes(
34779e86db79SHyon Kim SMHBA_LIBRARYATTRIBUTES *attributes)
34789e86db79SHyon Kim {
34799e86db79SHyon Kim
34809e86db79SHyon Kim struct timeval tv;
34819e86db79SHyon Kim struct tm tp;
34829e86db79SHyon Kim
34839e86db79SHyon Kim DEBUG(2, "SMHBA_GetWrapperLibraryAttributes", 0, 0, 0);
34849e86db79SHyon Kim
34859e86db79SHyon Kim if (attributes == NULL) {
34869e86db79SHyon Kim DEBUG(1, "SMHBA_GetWrapperLibraryAttributes: "
34879e86db79SHyon Kim "NULL pointer attributes",
34889e86db79SHyon Kim 0, 0, 0);
34899e86db79SHyon Kim return (HBA_STATUS_ERROR_ARG);
34909e86db79SHyon Kim }
34919e86db79SHyon Kim
34929e86db79SHyon Kim (void) memset(attributes, 0, sizeof (SMHBA_LIBRARYATTRIBUTES));
34939e86db79SHyon Kim
34949e86db79SHyon Kim #if defined(SOLARIS)
34959e86db79SHyon Kim if ((handle = dlopen("libSMHBAAPI.so", RTLD_NOW)) != NULL) {
34969e86db79SHyon Kim if (dlinfo(handle, RTLD_DI_LINKMAP, &map) >= 0) {
34979e86db79SHyon Kim for (mp = map; mp != NULL; mp = mp->l_next) {
34989e86db79SHyon Kim if (strlen(map->l_name) < 256) {
34999e86db79SHyon Kim (void) strcpy(attributes->LibPath, map->l_name);
35009e86db79SHyon Kim }
35019e86db79SHyon Kim }
35029e86db79SHyon Kim }
35039e86db79SHyon Kim }
35049e86db79SHyon Kim
35059e86db79SHyon Kim #endif
35069e86db79SHyon Kim
35079e86db79SHyon Kim #if defined(VENDOR)
35089e86db79SHyon Kim (void) strcpy(attributes->VName, VENDOR);
35099e86db79SHyon Kim #else
35109e86db79SHyon Kim attributes->VName[0] = '\0';
35119e86db79SHyon Kim #endif
35129e86db79SHyon Kim #if defined(VERSION)
35139e86db79SHyon Kim (void) strcpy(attributes->VVersion, VERSION);
35149e86db79SHyon Kim #else
35159e86db79SHyon Kim attributes->VVersion[0] = '\0';
35169e86db79SHyon Kim #endif
35179e86db79SHyon Kim
35189e86db79SHyon Kim if (gettimeofday(&tv, (void *)0) == 0) {
35199e86db79SHyon Kim if (localtime_r(&tv.tv_sec, &tp) != NULL) {
35209e86db79SHyon Kim attributes->build_date.tm_mday = tp.tm_mday;
35219e86db79SHyon Kim attributes->build_date.tm_mon = tp.tm_mon;
35229e86db79SHyon Kim attributes->build_date.tm_year = tp.tm_year;
35239e86db79SHyon Kim } else {
35249e86db79SHyon Kim (void) memset(&attributes->build_date, 0,
35259e86db79SHyon Kim sizeof (attributes->build_date));
35269e86db79SHyon Kim }
35279e86db79SHyon Kim (void) memset(&attributes->build_date, 0,
35289e86db79SHyon Kim sizeof (attributes->build_date));
35299e86db79SHyon Kim }
35309e86db79SHyon Kim
35319e86db79SHyon Kim return (1);
35329e86db79SHyon Kim }
35339e86db79SHyon Kim
35349e86db79SHyon Kim /*
35359e86db79SHyon Kim * This function returns the attributes for the warpper library.
35369e86db79SHyon Kim */
35379e86db79SHyon Kim HBA_UINT32
SMHBA_GetVendorLibraryAttributes(HBA_UINT32 adapter_index,SMHBA_LIBRARYATTRIBUTES * attributes)35389e86db79SHyon Kim SMHBA_GetVendorLibraryAttributes(
35399e86db79SHyon Kim HBA_UINT32 adapter_index,
35409e86db79SHyon Kim SMHBA_LIBRARYATTRIBUTES *attributes)
35419e86db79SHyon Kim {
35429e86db79SHyon Kim HBA_ADAPTER_INFO *adapt_infop;
35439e86db79SHyon Kim SMHBAGetVendorLibraryAttributesFunc
35449e86db79SHyon Kim registeredfunc;
35459e86db79SHyon Kim HBA_UINT32 ret = 0;
35469e86db79SHyon Kim
35479e86db79SHyon Kim DEBUG(2, "SMHBA_GetVendorLibraryAttributes adapterindex:%d",
35489e86db79SHyon Kim adapter_index, 0, 0);
35499e86db79SHyon Kim if (_hbaapi_librarylist == NULL) {
35509e86db79SHyon Kim DEBUG(1, "SMHBAAPI not loaded yet.", 0, 0, 0);
35519e86db79SHyon Kim return (0);
35529e86db79SHyon Kim }
35539e86db79SHyon Kim
35549e86db79SHyon Kim if (attributes == NULL) {
35559e86db79SHyon Kim DEBUG(1, "SMHBA_GetVendorLibraryAttributes: "
35569e86db79SHyon Kim "NULL pointer attributes",
35579e86db79SHyon Kim 0, 0, 0);
35589e86db79SHyon Kim return (HBA_STATUS_ERROR_ARG);
35599e86db79SHyon Kim }
35609e86db79SHyon Kim
35619e86db79SHyon Kim (void) memset(attributes, 0, sizeof (SMHBA_LIBRARYATTRIBUTES));
35629e86db79SHyon Kim
35639e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
35649e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AL_mutex);
35659e86db79SHyon Kim for (adapt_infop = _hbaapi_adapterlist;
35669e86db79SHyon Kim adapt_infop != NULL;
35679e86db79SHyon Kim adapt_infop = adapt_infop->next) {
35689e86db79SHyon Kim
35699e86db79SHyon Kim if (adapt_infop->index == adapter_index) {
35709e86db79SHyon Kim
35719e86db79SHyon Kim if (adapt_infop->library->version != SMHBA) {
35729e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AL_mutex);
35739e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex,
35749e86db79SHyon Kim HBA_STATUS_ERROR_INCOMPATIBLE);
35759e86db79SHyon Kim }
35769e86db79SHyon Kim
35779e86db79SHyon Kim registeredfunc = adapt_infop->library->
35789e86db79SHyon Kim ftable.smhbafunctionTable.GetVendorLibraryAttributesHandler;
35799e86db79SHyon Kim if (registeredfunc != NULL) {
35809e86db79SHyon Kim ret = (registeredfunc)(attributes);
35819e86db79SHyon Kim #ifdef NOTDEF
35829e86db79SHyon Kim } else {
35839e86db79SHyon Kim /* This should not happen since the VSL is already loaded. */
35849e86db79SHyon Kim #endif
35859e86db79SHyon Kim }
35869e86db79SHyon Kim if (attributes->LibPath[0] == '\0') {
35879e86db79SHyon Kim if (strlen(adapt_infop->library->LibraryPath) < 256) {
35889e86db79SHyon Kim (void) strcpy(attributes->LibPath,
35899e86db79SHyon Kim adapt_infop->library->LibraryPath);
35909e86db79SHyon Kim }
35919e86db79SHyon Kim }
35929e86db79SHyon Kim break;
35939e86db79SHyon Kim }
35949e86db79SHyon Kim }
35959e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AL_mutex);
35969e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, ret);
35979e86db79SHyon Kim }
35989e86db79SHyon Kim
35999e86db79SHyon Kim HBA_STATUS
SMHBA_GetAdapterAttributes(HBA_HANDLE handle,SMHBA_ADAPTERATTRIBUTES * hbaattributes)36009e86db79SHyon Kim SMHBA_GetAdapterAttributes(
36019e86db79SHyon Kim HBA_HANDLE handle,
36029e86db79SHyon Kim SMHBA_ADAPTERATTRIBUTES *hbaattributes)
36039e86db79SHyon Kim {
36049e86db79SHyon Kim HBA_STATUS status;
36059e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
36069e86db79SHyon Kim HBA_HANDLE vendorHandle;
36079e86db79SHyon Kim SMHBAGetAdapterAttributesFunc GetAdapterAttributesFunc;
36089e86db79SHyon Kim
36099e86db79SHyon Kim DEBUG(2, "SMHBA_GetAdapterAttributes", 0, 0, 0);
36109e86db79SHyon Kim
36119e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
36129e86db79SHyon Kim
36139e86db79SHyon Kim GetAdapterAttributesFunc =
36149e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetAdapterAttributesHandler;
36159e86db79SHyon Kim if (GetAdapterAttributesFunc != NULL) {
36169e86db79SHyon Kim status = ((GetAdapterAttributesFunc)(vendorHandle, hbaattributes));
36179e86db79SHyon Kim } else {
36189e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
36199e86db79SHyon Kim }
36209e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
36219e86db79SHyon Kim }
36229e86db79SHyon Kim
36239e86db79SHyon Kim HBA_STATUS
SMHBA_GetNumberOfPorts(HBA_HANDLE handle,HBA_UINT32 * numberofports)36249e86db79SHyon Kim SMHBA_GetNumberOfPorts(
36259e86db79SHyon Kim HBA_HANDLE handle,
36269e86db79SHyon Kim HBA_UINT32 *numberofports)
36279e86db79SHyon Kim {
36289e86db79SHyon Kim HBA_STATUS status;
36299e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
36309e86db79SHyon Kim HBA_HANDLE vendorHandle;
36319e86db79SHyon Kim SMHBAGetNumberOfPortsFunc GetNumberOfPortsFunc;
36329e86db79SHyon Kim
36339e86db79SHyon Kim DEBUG(2, "SMHBA_GetAdapterAttributes", 0, 0, 0);
36349e86db79SHyon Kim
36359e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
36369e86db79SHyon Kim
36379e86db79SHyon Kim GetNumberOfPortsFunc =
36389e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetNumberOfPortsHandler;
36399e86db79SHyon Kim if (GetNumberOfPortsFunc != NULL) {
36409e86db79SHyon Kim status = ((GetNumberOfPortsFunc)(vendorHandle, numberofports));
36419e86db79SHyon Kim } else {
36429e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
36439e86db79SHyon Kim }
36449e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
36459e86db79SHyon Kim }
36469e86db79SHyon Kim
36479e86db79SHyon Kim HBA_STATUS
SMHBA_GetPortType(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_PORTTYPE * porttype)36489e86db79SHyon Kim SMHBA_GetPortType(
36499e86db79SHyon Kim HBA_HANDLE handle,
36509e86db79SHyon Kim HBA_UINT32 portindex,
36519e86db79SHyon Kim HBA_PORTTYPE *porttype)
36529e86db79SHyon Kim {
36539e86db79SHyon Kim HBA_STATUS status;
36549e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
36559e86db79SHyon Kim HBA_HANDLE vendorHandle;
36569e86db79SHyon Kim SMHBAGetPortTypeFunc GetPortTypeFunc;
36579e86db79SHyon Kim
36589e86db79SHyon Kim DEBUG(2, "SMHBA_GetAdapterAttributes", 0, 0, 0);
36599e86db79SHyon Kim
36609e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
36619e86db79SHyon Kim
36629e86db79SHyon Kim GetPortTypeFunc =
36639e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetPortTypeHandler;
36649e86db79SHyon Kim if (GetPortTypeFunc != NULL) {
36659e86db79SHyon Kim status = ((GetPortTypeFunc)(vendorHandle, portindex, porttype));
36669e86db79SHyon Kim } else {
36679e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
36689e86db79SHyon Kim }
36699e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
36709e86db79SHyon Kim }
36719e86db79SHyon Kim
36729e86db79SHyon Kim HBA_STATUS
SMHBA_GetAdapterPortAttributes(HBA_HANDLE handle,HBA_UINT32 portindex,SMHBA_PORTATTRIBUTES * portattributes)36739e86db79SHyon Kim SMHBA_GetAdapterPortAttributes(
36749e86db79SHyon Kim HBA_HANDLE handle,
36759e86db79SHyon Kim HBA_UINT32 portindex,
36769e86db79SHyon Kim SMHBA_PORTATTRIBUTES *portattributes)
36779e86db79SHyon Kim {
36789e86db79SHyon Kim HBA_STATUS status;
36799e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
36809e86db79SHyon Kim HBA_HANDLE vendorHandle;
36819e86db79SHyon Kim SMHBAGetAdapterPortAttributesFunc
36829e86db79SHyon Kim GetAdapterPortAttributesFunc;
36839e86db79SHyon Kim
36849e86db79SHyon Kim DEBUG(2, "SMHBA_GetAdapterPortAttributes", 0, 0, 0);
36859e86db79SHyon Kim
36869e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
36879e86db79SHyon Kim
36889e86db79SHyon Kim GetAdapterPortAttributesFunc =
36899e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.\
36909e86db79SHyon Kim GetAdapterPortAttributesHandler;
36919e86db79SHyon Kim if (GetAdapterPortAttributesFunc != NULL) {
36929e86db79SHyon Kim status = ((GetAdapterPortAttributesFunc)
36939e86db79SHyon Kim (vendorHandle, portindex, portattributes));
36949e86db79SHyon Kim } else {
36959e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
36969e86db79SHyon Kim }
36979e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
36989e86db79SHyon Kim }
36999e86db79SHyon Kim
37009e86db79SHyon Kim HBA_STATUS
SMHBA_GetDiscoveredPortAttributes(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_UINT32 discoveredportindex,SMHBA_PORTATTRIBUTES * portattributes)37019e86db79SHyon Kim SMHBA_GetDiscoveredPortAttributes(
37029e86db79SHyon Kim HBA_HANDLE handle,
37039e86db79SHyon Kim HBA_UINT32 portindex,
37049e86db79SHyon Kim HBA_UINT32 discoveredportindex,
37059e86db79SHyon Kim SMHBA_PORTATTRIBUTES *portattributes)
37069e86db79SHyon Kim {
37079e86db79SHyon Kim HBA_STATUS status;
37089e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
37099e86db79SHyon Kim HBA_HANDLE vendorHandle;
37109e86db79SHyon Kim SMHBAGetDiscoveredPortAttributesFunc
37119e86db79SHyon Kim GetDiscoveredPortAttributesFunc;
37129e86db79SHyon Kim
37139e86db79SHyon Kim DEBUG(2, "SMHBA_GetDiscoveredPortAttributes", 0, 0, 0);
37149e86db79SHyon Kim
37159e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
37169e86db79SHyon Kim
37179e86db79SHyon Kim GetDiscoveredPortAttributesFunc =
37189e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.\
37199e86db79SHyon Kim GetDiscoveredPortAttributesHandler;
37209e86db79SHyon Kim if (GetDiscoveredPortAttributesFunc != NULL) {
37219e86db79SHyon Kim status = ((GetDiscoveredPortAttributesFunc)
37229e86db79SHyon Kim (vendorHandle, portindex, discoveredportindex,
37239e86db79SHyon Kim portattributes));
37249e86db79SHyon Kim } else {
37259e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
37269e86db79SHyon Kim }
37279e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
37289e86db79SHyon Kim }
37299e86db79SHyon Kim
37309e86db79SHyon Kim HBA_STATUS
SMHBA_GetPortAttributesByWWN(HBA_HANDLE handle,HBA_WWN portWWN,HBA_WWN domainPortWWN,SMHBA_PORTATTRIBUTES * portattributes)37319e86db79SHyon Kim SMHBA_GetPortAttributesByWWN(
37329e86db79SHyon Kim HBA_HANDLE handle,
37339e86db79SHyon Kim HBA_WWN portWWN,
37349e86db79SHyon Kim HBA_WWN domainPortWWN,
37359e86db79SHyon Kim SMHBA_PORTATTRIBUTES *portattributes)
37369e86db79SHyon Kim {
37379e86db79SHyon Kim HBA_STATUS status;
37389e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
37399e86db79SHyon Kim HBA_HANDLE vendorHandle;
37409e86db79SHyon Kim SMHBAGetPortAttributesByWWNFunc
37419e86db79SHyon Kim GetPortAttributesByWWNFunc;
37429e86db79SHyon Kim
37439e86db79SHyon Kim DEBUG(2, "SMHBA_GetPortAttributesByWWN: %s", WWN2STR1(&portWWN), 0, 0);
37449e86db79SHyon Kim
37459e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
37469e86db79SHyon Kim
37479e86db79SHyon Kim GetPortAttributesByWWNFunc =
37489e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetPortAttributesByWWNHandler;
37499e86db79SHyon Kim if (GetPortAttributesByWWNFunc != NULL) {
37509e86db79SHyon Kim status = ((GetPortAttributesByWWNFunc)
37519e86db79SHyon Kim (vendorHandle, portWWN, domainPortWWN, portattributes));
37529e86db79SHyon Kim } else {
37539e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
37549e86db79SHyon Kim }
37559e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
37569e86db79SHyon Kim }
37579e86db79SHyon Kim
37589e86db79SHyon Kim HBA_STATUS
SMHBA_GetFCPhyAttributes(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_UINT32 phyindex,SMHBA_FC_PHY * phytype)37599e86db79SHyon Kim SMHBA_GetFCPhyAttributes(
37609e86db79SHyon Kim HBA_HANDLE handle,
37619e86db79SHyon Kim HBA_UINT32 portindex,
37629e86db79SHyon Kim HBA_UINT32 phyindex,
37639e86db79SHyon Kim SMHBA_FC_PHY *phytype)
37649e86db79SHyon Kim {
37659e86db79SHyon Kim HBA_STATUS status;
37669e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
37679e86db79SHyon Kim HBA_HANDLE vendorHandle;
37689e86db79SHyon Kim SMHBAGetFCPhyAttributesFunc GetFCPhyAttributesFunc;
37699e86db79SHyon Kim
37709e86db79SHyon Kim DEBUG(2, "SMHBA_GetFCPhyAttributesByWWN", 0, 0, 0);
37719e86db79SHyon Kim
37729e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
37739e86db79SHyon Kim
37749e86db79SHyon Kim GetFCPhyAttributesFunc =
37759e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetFCPhyAttributesHandler;
37769e86db79SHyon Kim if (GetFCPhyAttributesFunc != NULL) {
37779e86db79SHyon Kim status = ((GetFCPhyAttributesFunc)
37789e86db79SHyon Kim (vendorHandle, portindex, phyindex, phytype));
37799e86db79SHyon Kim } else {
37809e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
37819e86db79SHyon Kim }
37829e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
37839e86db79SHyon Kim }
37849e86db79SHyon Kim
37859e86db79SHyon Kim HBA_STATUS
SMHBA_GetSASPhyAttributes(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_UINT32 phyindex,SMHBA_SAS_PHY * phytype)37869e86db79SHyon Kim SMHBA_GetSASPhyAttributes(
37879e86db79SHyon Kim HBA_HANDLE handle,
37889e86db79SHyon Kim HBA_UINT32 portindex,
37899e86db79SHyon Kim HBA_UINT32 phyindex,
37909e86db79SHyon Kim SMHBA_SAS_PHY *phytype)
37919e86db79SHyon Kim {
37929e86db79SHyon Kim HBA_STATUS status;
37939e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
37949e86db79SHyon Kim HBA_HANDLE vendorHandle;
37959e86db79SHyon Kim SMHBAGetSASPhyAttributesFunc GetSASPhyAttributesFunc;
37969e86db79SHyon Kim
37979e86db79SHyon Kim DEBUG(2, "SMHBA_GetFCPhyAttributesByWWN", 0, 0, 0);
37989e86db79SHyon Kim
37999e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
38009e86db79SHyon Kim
38019e86db79SHyon Kim GetSASPhyAttributesFunc =
38029e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetSASPhyAttributesHandler;
38039e86db79SHyon Kim if (GetSASPhyAttributesFunc != NULL) {
38049e86db79SHyon Kim status = ((GetSASPhyAttributesFunc)
38059e86db79SHyon Kim (vendorHandle, portindex, phyindex, phytype));
38069e86db79SHyon Kim } else {
38079e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
38089e86db79SHyon Kim }
38099e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
38109e86db79SHyon Kim }
38119e86db79SHyon Kim
38129e86db79SHyon Kim HBA_STATUS
SMHBA_GetProtocolStatistics(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_UINT32 protocoltype,SMHBA_PROTOCOLSTATISTICS * pProtocolStatistics)38139e86db79SHyon Kim SMHBA_GetProtocolStatistics(
38149e86db79SHyon Kim HBA_HANDLE handle,
38159e86db79SHyon Kim HBA_UINT32 portindex,
38169e86db79SHyon Kim HBA_UINT32 protocoltype,
38179e86db79SHyon Kim SMHBA_PROTOCOLSTATISTICS *pProtocolStatistics)
38189e86db79SHyon Kim {
38199e86db79SHyon Kim HBA_STATUS status;
38209e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
38219e86db79SHyon Kim HBA_HANDLE vendorHandle;
38229e86db79SHyon Kim SMHBAGetProtocolStatisticsFunc
38239e86db79SHyon Kim GetProtocolStatisticsFunc;
38249e86db79SHyon Kim
38259e86db79SHyon Kim DEBUG(2, "SMHBA_GetProtocolStatistics port index: %d protocol type: %d",
38269e86db79SHyon Kim portindex, protocoltype, 0);
38279e86db79SHyon Kim
38289e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
38299e86db79SHyon Kim
38309e86db79SHyon Kim GetProtocolStatisticsFunc =
38319e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetProtocolStatisticsHandler;
38329e86db79SHyon Kim if (GetProtocolStatisticsFunc != NULL) {
38339e86db79SHyon Kim status = (GetProtocolStatisticsFunc)
38349e86db79SHyon Kim (vendorHandle, portindex, protocoltype, pProtocolStatistics);
38359e86db79SHyon Kim } else {
38369e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
38379e86db79SHyon Kim }
38389e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
38399e86db79SHyon Kim }
38409e86db79SHyon Kim
38419e86db79SHyon Kim HBA_STATUS
SMHBA_GetPhyStatistics(HBA_HANDLE handle,HBA_UINT32 portindex,HBA_UINT32 phyindex,SMHBA_PHYSTATISTICS * pPhyStatistics)38429e86db79SHyon Kim SMHBA_GetPhyStatistics(
38439e86db79SHyon Kim HBA_HANDLE handle,
38449e86db79SHyon Kim HBA_UINT32 portindex,
38459e86db79SHyon Kim HBA_UINT32 phyindex,
38469e86db79SHyon Kim SMHBA_PHYSTATISTICS *pPhyStatistics)
38479e86db79SHyon Kim {
38489e86db79SHyon Kim HBA_STATUS status;
38499e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
38509e86db79SHyon Kim HBA_HANDLE vendorHandle;
38519e86db79SHyon Kim SMHBAGetPhyStatisticsFunc
38529e86db79SHyon Kim GetPhyStatisticsFunc;
38539e86db79SHyon Kim
38549e86db79SHyon Kim DEBUG(2, "SMHBA_GetPhyStatistics port index: %d phy idex: %d",
38559e86db79SHyon Kim portindex, phyindex, 0);
38569e86db79SHyon Kim
38579e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
38589e86db79SHyon Kim
38599e86db79SHyon Kim GetPhyStatisticsFunc =
38609e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetPhyStatisticsHandler;
38619e86db79SHyon Kim if (GetPhyStatisticsFunc != NULL) {
38629e86db79SHyon Kim status = (GetPhyStatisticsFunc)
38639e86db79SHyon Kim (vendorHandle, portindex, phyindex, pPhyStatistics);
38649e86db79SHyon Kim } else {
38659e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
38669e86db79SHyon Kim }
38679e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
38689e86db79SHyon Kim }
38699e86db79SHyon Kim
38709e86db79SHyon Kim HBA_STATUS
SMHBA_GetBindingCapability(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN domainPortWWN,SMHBA_BIND_CAPABILITY * pFlags)38719e86db79SHyon Kim SMHBA_GetBindingCapability(
38729e86db79SHyon Kim HBA_HANDLE handle,
38739e86db79SHyon Kim HBA_WWN hbaPortWWN,
38749e86db79SHyon Kim HBA_WWN domainPortWWN,
38759e86db79SHyon Kim SMHBA_BIND_CAPABILITY *pFlags)
38769e86db79SHyon Kim {
38779e86db79SHyon Kim HBA_STATUS status;
38789e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
38799e86db79SHyon Kim HBA_HANDLE vendorHandle;
38809e86db79SHyon Kim SMHBAGetBindingCapabilityFunc GetBindingCapabilityFunc;
38819e86db79SHyon Kim
38829e86db79SHyon Kim DEBUG(2, "HBA_GetBindingCapability", 0, 0, 0);
38839e86db79SHyon Kim
38849e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
38859e86db79SHyon Kim
38869e86db79SHyon Kim GetBindingCapabilityFunc =
38879e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetBindingCapabilityHandler;
38889e86db79SHyon Kim if (GetBindingCapabilityFunc != NULL) {
38899e86db79SHyon Kim status = (GetBindingCapabilityFunc)(vendorHandle, hbaPortWWN,
38909e86db79SHyon Kim domainPortWWN, pFlags);
38919e86db79SHyon Kim } else {
38929e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
38939e86db79SHyon Kim }
38949e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
38959e86db79SHyon Kim }
38969e86db79SHyon Kim
38979e86db79SHyon Kim HBA_STATUS
SMHBA_GetBindingSupport(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN domainPortWWN,SMHBA_BIND_CAPABILITY * pFlags)38989e86db79SHyon Kim SMHBA_GetBindingSupport(
38999e86db79SHyon Kim HBA_HANDLE handle,
39009e86db79SHyon Kim HBA_WWN hbaPortWWN,
39019e86db79SHyon Kim HBA_WWN domainPortWWN,
39029e86db79SHyon Kim SMHBA_BIND_CAPABILITY *pFlags)
39039e86db79SHyon Kim {
39049e86db79SHyon Kim HBA_STATUS status;
39059e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
39069e86db79SHyon Kim HBA_HANDLE vendorHandle;
39079e86db79SHyon Kim SMHBAGetBindingSupportFunc
39089e86db79SHyon Kim GetBindingSupporFunc;
39099e86db79SHyon Kim
39109e86db79SHyon Kim DEBUG(2, "SMHBA_GetBindingSupport port: %s",
39119e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
39129e86db79SHyon Kim
39139e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
39149e86db79SHyon Kim
39159e86db79SHyon Kim GetBindingSupporFunc =
39169e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetBindingSupportHandler;
39179e86db79SHyon Kim if (GetBindingSupporFunc != NULL) {
39189e86db79SHyon Kim status = (GetBindingSupporFunc)(vendorHandle,
39199e86db79SHyon Kim hbaPortWWN, domainPortWWN, pFlags);
39209e86db79SHyon Kim } else {
39219e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
39229e86db79SHyon Kim }
39239e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
39249e86db79SHyon Kim }
39259e86db79SHyon Kim
39269e86db79SHyon Kim HBA_STATUS
SMHBA_SetBindingSupport(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN domainPortWWN,SMHBA_BIND_CAPABILITY flags)39279e86db79SHyon Kim SMHBA_SetBindingSupport(
39289e86db79SHyon Kim HBA_HANDLE handle,
39299e86db79SHyon Kim HBA_WWN hbaPortWWN,
39309e86db79SHyon Kim HBA_WWN domainPortWWN,
39319e86db79SHyon Kim SMHBA_BIND_CAPABILITY flags)
39329e86db79SHyon Kim {
39339e86db79SHyon Kim HBA_STATUS status;
39349e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
39359e86db79SHyon Kim HBA_HANDLE vendorHandle;
39369e86db79SHyon Kim SMHBASetBindingSupportFunc
39379e86db79SHyon Kim SetBindingSupporFunc;
39389e86db79SHyon Kim
39399e86db79SHyon Kim DEBUG(2, "SMHBA_GetBindingSupport port: %s",
39409e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
39419e86db79SHyon Kim
39429e86db79SHyon Kim CHECKLIBRARYANDVERSION(HBAAPIV2);
39439e86db79SHyon Kim
39449e86db79SHyon Kim SetBindingSupporFunc =
39459e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.SetBindingSupportHandler;
39469e86db79SHyon Kim if (SetBindingSupporFunc != NULL) {
39479e86db79SHyon Kim status = (SetBindingSupporFunc)
39489e86db79SHyon Kim (vendorHandle, hbaPortWWN, domainPortWWN, flags);
39499e86db79SHyon Kim } else {
39509e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
39519e86db79SHyon Kim }
39529e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
39539e86db79SHyon Kim }
39549e86db79SHyon Kim
39559e86db79SHyon Kim HBA_STATUS
SMHBA_GetTargetMapping(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN domainPortWWN,SMHBA_TARGETMAPPING * pMapping)39569e86db79SHyon Kim SMHBA_GetTargetMapping(
39579e86db79SHyon Kim HBA_HANDLE handle,
39589e86db79SHyon Kim HBA_WWN hbaPortWWN,
39599e86db79SHyon Kim HBA_WWN domainPortWWN,
39609e86db79SHyon Kim SMHBA_TARGETMAPPING *pMapping)
39619e86db79SHyon Kim {
39629e86db79SHyon Kim HBA_STATUS status;
39639e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
39649e86db79SHyon Kim HBA_HANDLE vendorHandle;
39659e86db79SHyon Kim SMHBAGetTargetMappingFunc GetTargetMappingFunc;
39669e86db79SHyon Kim
39679e86db79SHyon Kim DEBUG(2, "SMHBA_GetTargetMapping port WWN: %s",
39689e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
39699e86db79SHyon Kim
39709e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
39719e86db79SHyon Kim
39729e86db79SHyon Kim GetTargetMappingFunc =
39739e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetTargetMappingHandler;
39749e86db79SHyon Kim if (GetTargetMappingFunc != NULL) {
39759e86db79SHyon Kim status = ((GetTargetMappingFunc)(vendorHandle,
39769e86db79SHyon Kim hbaPortWWN, domainPortWWN, pMapping));
39779e86db79SHyon Kim } else {
39789e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
39799e86db79SHyon Kim }
39809e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
39819e86db79SHyon Kim }
39829e86db79SHyon Kim
39839e86db79SHyon Kim HBA_STATUS
SMHBA_GetPersistentBinding(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN domainPortWWN,SMHBA_BINDING * binding)39849e86db79SHyon Kim SMHBA_GetPersistentBinding(
39859e86db79SHyon Kim HBA_HANDLE handle,
39869e86db79SHyon Kim HBA_WWN hbaPortWWN,
39879e86db79SHyon Kim HBA_WWN domainPortWWN,
39889e86db79SHyon Kim SMHBA_BINDING *binding)
39899e86db79SHyon Kim {
39909e86db79SHyon Kim HBA_STATUS status;
39919e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
39929e86db79SHyon Kim HBA_HANDLE vendorHandle;
39939e86db79SHyon Kim SMHBAGetPersistentBindingFunc
39949e86db79SHyon Kim GetPersistentBindingFunc;
39959e86db79SHyon Kim
39969e86db79SHyon Kim DEBUG(2, "SMHBA_GetPersistentBinding port WWN: %s",
39979e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
39989e86db79SHyon Kim
39999e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
40009e86db79SHyon Kim
40019e86db79SHyon Kim GetPersistentBindingFunc =
40029e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetPersistentBindingHandler;
40039e86db79SHyon Kim if (GetPersistentBindingFunc != NULL) {
40049e86db79SHyon Kim status = ((GetPersistentBindingFunc)(vendorHandle,
40059e86db79SHyon Kim hbaPortWWN, domainPortWWN, binding));
40069e86db79SHyon Kim } else {
40079e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
40089e86db79SHyon Kim }
40099e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
40109e86db79SHyon Kim }
40119e86db79SHyon Kim
40129e86db79SHyon Kim HBA_STATUS
SMHBA_SetPersistentBinding(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN domainPortWWN,const SMHBA_BINDING * binding)40139e86db79SHyon Kim SMHBA_SetPersistentBinding(
40149e86db79SHyon Kim HBA_HANDLE handle,
40159e86db79SHyon Kim HBA_WWN hbaPortWWN,
40169e86db79SHyon Kim HBA_WWN domainPortWWN,
40179e86db79SHyon Kim const SMHBA_BINDING *binding)
40189e86db79SHyon Kim {
40199e86db79SHyon Kim HBA_STATUS status;
40209e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
40219e86db79SHyon Kim HBA_HANDLE vendorHandle;
40229e86db79SHyon Kim SMHBASetPersistentBindingFunc
40239e86db79SHyon Kim SetPersistentBindingFunc;
40249e86db79SHyon Kim
40259e86db79SHyon Kim DEBUG(2, "SMHBA_SetPersistentBinding port WWN: %s",
40269e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
40279e86db79SHyon Kim
40289e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
40299e86db79SHyon Kim
40309e86db79SHyon Kim SetPersistentBindingFunc =
40319e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.SetPersistentBindingHandler;
40329e86db79SHyon Kim if (SetPersistentBindingFunc != NULL) {
40339e86db79SHyon Kim status = ((SetPersistentBindingFunc)(vendorHandle,
40349e86db79SHyon Kim hbaPortWWN, domainPortWWN, binding));
40359e86db79SHyon Kim } else {
40369e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
40379e86db79SHyon Kim }
40389e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
40399e86db79SHyon Kim }
40409e86db79SHyon Kim
40419e86db79SHyon Kim HBA_STATUS
SMHBA_RemovePersistentBinding(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN domainPortWWN,const SMHBA_BINDING * binding)40429e86db79SHyon Kim SMHBA_RemovePersistentBinding(
40439e86db79SHyon Kim HBA_HANDLE handle,
40449e86db79SHyon Kim HBA_WWN hbaPortWWN,
40459e86db79SHyon Kim HBA_WWN domainPortWWN,
40469e86db79SHyon Kim const SMHBA_BINDING *binding)
40479e86db79SHyon Kim {
40489e86db79SHyon Kim HBA_STATUS status;
40499e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
40509e86db79SHyon Kim HBA_HANDLE vendorHandle;
40519e86db79SHyon Kim SMHBARemovePersistentBindingFunc
40529e86db79SHyon Kim RemovePersistentBindingFunc;
40539e86db79SHyon Kim
40549e86db79SHyon Kim DEBUG(2, "SMHBA_RemovePersistentBinding port WWN: %s",
40559e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
40569e86db79SHyon Kim
40579e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
40589e86db79SHyon Kim
40599e86db79SHyon Kim RemovePersistentBindingFunc =
40609e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.RemovePersistentBindingHandler;
40619e86db79SHyon Kim if (RemovePersistentBindingFunc != NULL) {
40629e86db79SHyon Kim status = ((RemovePersistentBindingFunc)(vendorHandle,
40639e86db79SHyon Kim hbaPortWWN, domainPortWWN, binding));
40649e86db79SHyon Kim } else {
40659e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
40669e86db79SHyon Kim }
40679e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
40689e86db79SHyon Kim }
40699e86db79SHyon Kim
40709e86db79SHyon Kim HBA_STATUS
SMHBA_RemoveAllPersistentBindings(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN domainPortWWN)40719e86db79SHyon Kim SMHBA_RemoveAllPersistentBindings(
40729e86db79SHyon Kim HBA_HANDLE handle,
40739e86db79SHyon Kim HBA_WWN hbaPortWWN,
40749e86db79SHyon Kim HBA_WWN domainPortWWN)
40759e86db79SHyon Kim {
40769e86db79SHyon Kim HBA_STATUS status;
40779e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
40789e86db79SHyon Kim HBA_HANDLE vendorHandle;
40799e86db79SHyon Kim SMHBARemoveAllPersistentBindingsFunc
40809e86db79SHyon Kim RemoveAllPersistentBindingsFunc;
40819e86db79SHyon Kim
40829e86db79SHyon Kim DEBUG(2, "SMHBA_RemoveAllPersistentBinding port WWN: %s",
40839e86db79SHyon Kim WWN2STR1(&hbaPortWWN), 0, 0);
40849e86db79SHyon Kim
40859e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
40869e86db79SHyon Kim
40879e86db79SHyon Kim RemoveAllPersistentBindingsFunc =
40889e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.\
40899e86db79SHyon Kim RemoveAllPersistentBindingsHandler;
40909e86db79SHyon Kim if (RemoveAllPersistentBindingsFunc != NULL) {
40919e86db79SHyon Kim status = ((RemoveAllPersistentBindingsFunc)(vendorHandle,
40929e86db79SHyon Kim hbaPortWWN, domainPortWWN));
40939e86db79SHyon Kim } else {
40949e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
40959e86db79SHyon Kim }
40969e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
40979e86db79SHyon Kim }
40989e86db79SHyon Kim
40999e86db79SHyon Kim HBA_STATUS
SMHBA_GetLUNStatistics(HBA_HANDLE handle,const HBA_SCSIID * lunit,SMHBA_PROTOCOLSTATISTICS * statistics)41009e86db79SHyon Kim SMHBA_GetLUNStatistics(
41019e86db79SHyon Kim HBA_HANDLE handle,
41029e86db79SHyon Kim const HBA_SCSIID *lunit,
41039e86db79SHyon Kim SMHBA_PROTOCOLSTATISTICS *statistics)
41049e86db79SHyon Kim {
41059e86db79SHyon Kim HBA_STATUS status;
41069e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
41079e86db79SHyon Kim HBA_HANDLE vendorHandle;
41089e86db79SHyon Kim SMHBAGetLUNStatisticsFunc GetLUNStatisticsFunc;
41099e86db79SHyon Kim
41109e86db79SHyon Kim DEBUG(2, "SMHBA_GetLUNStatistics", 0, 0, 0);
41119e86db79SHyon Kim
41129e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
41139e86db79SHyon Kim
41149e86db79SHyon Kim GetLUNStatisticsFunc =
41159e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.GetLUNStatisticsHandler;
41169e86db79SHyon Kim if (GetLUNStatisticsFunc != NULL) {
41179e86db79SHyon Kim status = ((GetLUNStatisticsFunc)(vendorHandle, lunit, statistics));
41189e86db79SHyon Kim } else {
41199e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
41209e86db79SHyon Kim }
41219e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
41229e86db79SHyon Kim }
41239e86db79SHyon Kim
41249e86db79SHyon Kim HBA_STATUS
SMHBA_ScsiInquiry(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_WWN domainPortWWN,SMHBA_SCSILUN smhbaLUN,HBA_UINT8 CDB_Byte1,HBA_UINT8 CDB_Byte2,void * pRspBuffer,HBA_UINT32 * pRspBufferSize,HBA_UINT8 * pScsiStatus,void * pSenseBuffer,HBA_UINT32 * pSenseBufferSize)41259e86db79SHyon Kim SMHBA_ScsiInquiry(
41269e86db79SHyon Kim HBA_HANDLE handle,
41279e86db79SHyon Kim HBA_WWN hbaPortWWN,
41289e86db79SHyon Kim HBA_WWN discoveredPortWWN,
41299e86db79SHyon Kim HBA_WWN domainPortWWN,
41309e86db79SHyon Kim SMHBA_SCSILUN smhbaLUN,
41319e86db79SHyon Kim HBA_UINT8 CDB_Byte1,
41329e86db79SHyon Kim HBA_UINT8 CDB_Byte2,
41339e86db79SHyon Kim void *pRspBuffer,
41349e86db79SHyon Kim HBA_UINT32 *pRspBufferSize,
41359e86db79SHyon Kim HBA_UINT8 *pScsiStatus,
41369e86db79SHyon Kim void *pSenseBuffer,
41379e86db79SHyon Kim HBA_UINT32 *pSenseBufferSize)
41389e86db79SHyon Kim {
41399e86db79SHyon Kim HBA_STATUS status;
41409e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
41419e86db79SHyon Kim HBA_HANDLE vendorHandle;
41429e86db79SHyon Kim SMHBAScsiInquiryFunc ScsiInquiryFunc;
41439e86db79SHyon Kim
41449e86db79SHyon Kim DEBUG(2, "SMHBA_ScsiInquiry to hba port: %s discoveredPortWWN: %s",
41459e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR1(&discoveredPortWWN), 0);
41469e86db79SHyon Kim
41479e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
41489e86db79SHyon Kim
41499e86db79SHyon Kim ScsiInquiryFunc =
41509e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.ScsiInquiryHandler;
41519e86db79SHyon Kim if (ScsiInquiryFunc != NULL) {
41529e86db79SHyon Kim status = ((ScsiInquiryFunc)(
41539e86db79SHyon Kim vendorHandle, hbaPortWWN, discoveredPortWWN, domainPortWWN,
41549e86db79SHyon Kim smhbaLUN, CDB_Byte1, CDB_Byte2, pRspBuffer, pRspBufferSize,
41559e86db79SHyon Kim pScsiStatus, pSenseBuffer, pSenseBufferSize));
41569e86db79SHyon Kim } else {
41579e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
41589e86db79SHyon Kim }
41599e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
41609e86db79SHyon Kim }
41619e86db79SHyon Kim
41629e86db79SHyon Kim HBA_STATUS
SMHBA_ScsiReportLUNs(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_WWN domainPortWWN,void * pRspBuffer,HBA_UINT32 * pRspBufferSize,HBA_UINT8 * pScsiStatus,void * pSenseBuffer,HBA_UINT32 * pSenseBufferSize)41639e86db79SHyon Kim SMHBA_ScsiReportLUNs(
41649e86db79SHyon Kim HBA_HANDLE handle,
41659e86db79SHyon Kim HBA_WWN hbaPortWWN,
41669e86db79SHyon Kim HBA_WWN discoveredPortWWN,
41679e86db79SHyon Kim HBA_WWN domainPortWWN,
41689e86db79SHyon Kim void *pRspBuffer,
41699e86db79SHyon Kim HBA_UINT32 *pRspBufferSize,
41709e86db79SHyon Kim HBA_UINT8 *pScsiStatus,
41719e86db79SHyon Kim void *pSenseBuffer,
41729e86db79SHyon Kim HBA_UINT32 *pSenseBufferSize)
41739e86db79SHyon Kim {
41749e86db79SHyon Kim HBA_STATUS status;
41759e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
41769e86db79SHyon Kim HBA_HANDLE vendorHandle;
41779e86db79SHyon Kim SMHBAScsiReportLUNsFunc ScsiReportLUNsFunc;
41789e86db79SHyon Kim
41799e86db79SHyon Kim DEBUG(2, "SMHBA_ScsiReportLuns to hba port: %s discoveredPortWWN: %s",
41809e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR1(&discoveredPortWWN), 0);
41819e86db79SHyon Kim
41829e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
41839e86db79SHyon Kim
41849e86db79SHyon Kim ScsiReportLUNsFunc =
41859e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.ScsiReportLUNsHandler;
41869e86db79SHyon Kim if (ScsiReportLUNsFunc != NULL) {
41879e86db79SHyon Kim status = ((ScsiReportLUNsFunc)(
41889e86db79SHyon Kim vendorHandle, hbaPortWWN, discoveredPortWWN, domainPortWWN,
41899e86db79SHyon Kim pRspBuffer, pRspBufferSize, pScsiStatus, pSenseBuffer,
41909e86db79SHyon Kim pSenseBufferSize));
41919e86db79SHyon Kim } else {
41929e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
41939e86db79SHyon Kim }
41949e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
41959e86db79SHyon Kim }
41969e86db79SHyon Kim
41979e86db79SHyon Kim HBA_STATUS
SMHBA_ScsiReadCapacity(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_WWN domainPortWWN,SMHBA_SCSILUN smhbaLUN,void * pRspBuffer,HBA_UINT32 * pRspBufferSize,HBA_UINT8 * pScsiStatus,void * pSenseBuffer,HBA_UINT32 * pSenseBufferSize)41989e86db79SHyon Kim SMHBA_ScsiReadCapacity(
41999e86db79SHyon Kim HBA_HANDLE handle,
42009e86db79SHyon Kim HBA_WWN hbaPortWWN,
42019e86db79SHyon Kim HBA_WWN discoveredPortWWN,
42029e86db79SHyon Kim HBA_WWN domainPortWWN,
42039e86db79SHyon Kim SMHBA_SCSILUN smhbaLUN,
42049e86db79SHyon Kim void *pRspBuffer,
42059e86db79SHyon Kim HBA_UINT32 *pRspBufferSize,
42069e86db79SHyon Kim HBA_UINT8 *pScsiStatus,
42079e86db79SHyon Kim void *pSenseBuffer,
42089e86db79SHyon Kim HBA_UINT32 *pSenseBufferSize)
42099e86db79SHyon Kim {
42109e86db79SHyon Kim HBA_STATUS status;
42119e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
42129e86db79SHyon Kim HBA_HANDLE vendorHandle;
42139e86db79SHyon Kim SMHBAScsiReadCapacityFunc ScsiReadCapacityFunc;
42149e86db79SHyon Kim
42159e86db79SHyon Kim DEBUG(2, "SMHBA_ScsiReadCapacity to hba port: %s discoveredPortWWN: %s",
42169e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR1(&discoveredPortWWN), 0);
42179e86db79SHyon Kim
42189e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
42199e86db79SHyon Kim
42209e86db79SHyon Kim ScsiReadCapacityFunc =
42219e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.ScsiReadCapacityHandler;
42229e86db79SHyon Kim if (ScsiReadCapacityFunc != NULL) {
42239e86db79SHyon Kim status = ((ScsiReadCapacityFunc)(
42249e86db79SHyon Kim vendorHandle, hbaPortWWN, discoveredPortWWN, domainPortWWN,
42259e86db79SHyon Kim smhbaLUN, pRspBuffer, pRspBufferSize, pScsiStatus, pSenseBuffer,
42269e86db79SHyon Kim pSenseBufferSize));
42279e86db79SHyon Kim } else {
42289e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
42299e86db79SHyon Kim }
42309e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
42319e86db79SHyon Kim }
42329e86db79SHyon Kim
42339e86db79SHyon Kim HBA_STATUS
SMHBA_SendTEST(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN destWWN,HBA_UINT32 destFCID,void * pRspBuffer,HBA_UINT32 pRspBufferSize)42349e86db79SHyon Kim SMHBA_SendTEST(
42359e86db79SHyon Kim HBA_HANDLE handle,
42369e86db79SHyon Kim HBA_WWN hbaPortWWN,
42379e86db79SHyon Kim HBA_WWN destWWN,
42389e86db79SHyon Kim HBA_UINT32 destFCID,
42399e86db79SHyon Kim void *pRspBuffer,
42409e86db79SHyon Kim HBA_UINT32 pRspBufferSize)
42419e86db79SHyon Kim {
42429e86db79SHyon Kim HBA_STATUS status;
42439e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
42449e86db79SHyon Kim HBA_HANDLE vendorHandle;
42459e86db79SHyon Kim SMHBASendTESTFunc SendTESTFunc;
42469e86db79SHyon Kim
42479e86db79SHyon Kim DEBUG(2, "SMHBA_SendTEST, hbaPortWWN: %s destWWN",
42489e86db79SHyon Kim WWN2STR1(&hbaPortWWN),
42499e86db79SHyon Kim WWN2STR1(&destWWN), 0);
42509e86db79SHyon Kim
42519e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
42529e86db79SHyon Kim
42539e86db79SHyon Kim SendTESTFunc = lib_infop->ftable.smhbafunctionTable.SendTESTHandler;
42549e86db79SHyon Kim if (SendTESTFunc != NULL) {
42559e86db79SHyon Kim status = (SendTESTFunc)
42569e86db79SHyon Kim (vendorHandle, hbaPortWWN, destWWN, destFCID,
42579e86db79SHyon Kim pRspBuffer, pRspBufferSize);
42589e86db79SHyon Kim } else {
42599e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
42609e86db79SHyon Kim }
42619e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
42629e86db79SHyon Kim }
42639e86db79SHyon Kim
42649e86db79SHyon Kim HBA_STATUS
SMHBA_SendECHO(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN destWWN,HBA_UINT32 destFCID,void * pReqBuffer,HBA_UINT32 ReqBufferSize,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)42659e86db79SHyon Kim SMHBA_SendECHO(
42669e86db79SHyon Kim HBA_HANDLE handle,
42679e86db79SHyon Kim HBA_WWN hbaPortWWN,
42689e86db79SHyon Kim HBA_WWN destWWN,
42699e86db79SHyon Kim HBA_UINT32 destFCID,
42709e86db79SHyon Kim void *pReqBuffer,
42719e86db79SHyon Kim HBA_UINT32 ReqBufferSize,
42729e86db79SHyon Kim void *pRspBuffer,
42739e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
42749e86db79SHyon Kim {
42759e86db79SHyon Kim HBA_STATUS status;
42769e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
42779e86db79SHyon Kim HBA_HANDLE vendorHandle;
42789e86db79SHyon Kim SMHBASendECHOFunc SendECHOFunc;
42799e86db79SHyon Kim
42809e86db79SHyon Kim DEBUG(2, "SMHBA_SendECHO, hbaPortWWN: %s destWWN",
42819e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR1(&destWWN), 0);
42829e86db79SHyon Kim
42839e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
42849e86db79SHyon Kim
42859e86db79SHyon Kim SendECHOFunc = lib_infop->ftable.smhbafunctionTable.SendECHOHandler;
42869e86db79SHyon Kim if (SendECHOFunc != NULL) {
42879e86db79SHyon Kim status = (SendECHOFunc)
42889e86db79SHyon Kim (vendorHandle, hbaPortWWN, destWWN, destFCID,
42899e86db79SHyon Kim pReqBuffer, ReqBufferSize, pRspBuffer, pRspBufferSize);
42909e86db79SHyon Kim } else {
42919e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
42929e86db79SHyon Kim }
42939e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
42949e86db79SHyon Kim }
42959e86db79SHyon Kim
42969e86db79SHyon Kim HBA_STATUS
SMHBA_SendSMPPassThru(HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN destWWN,HBA_WWN domainPortWWN,void * pReqBuffer,HBA_UINT32 ReqBufferSize,void * pRspBuffer,HBA_UINT32 * pRspBufferSize)42979e86db79SHyon Kim SMHBA_SendSMPPassThru(
42989e86db79SHyon Kim HBA_HANDLE handle,
42999e86db79SHyon Kim HBA_WWN hbaPortWWN,
43009e86db79SHyon Kim HBA_WWN destWWN,
43019e86db79SHyon Kim HBA_WWN domainPortWWN,
43029e86db79SHyon Kim void *pReqBuffer,
43039e86db79SHyon Kim HBA_UINT32 ReqBufferSize,
43049e86db79SHyon Kim void *pRspBuffer,
43059e86db79SHyon Kim HBA_UINT32 *pRspBufferSize)
43069e86db79SHyon Kim {
43079e86db79SHyon Kim HBA_STATUS status;
43089e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
43099e86db79SHyon Kim HBA_HANDLE vendorHandle;
43109e86db79SHyon Kim SMHBASendSMPPassThruFunc SendSMPPassThruFunc;
43119e86db79SHyon Kim
43129e86db79SHyon Kim DEBUG(2, "SMHBA_SendSMPPassThru, hbaPortWWN: %s destWWN: %s",
43139e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR1(&destWWN), 0);
43149e86db79SHyon Kim
43159e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
43169e86db79SHyon Kim
43179e86db79SHyon Kim SendSMPPassThruFunc = lib_infop->ftable.\
43189e86db79SHyon Kim smhbafunctionTable.SendSMPPassThruHandler;
43199e86db79SHyon Kim
43209e86db79SHyon Kim if (SendSMPPassThruFunc != NULL) {
43219e86db79SHyon Kim status = (SendSMPPassThruFunc)
43229e86db79SHyon Kim (vendorHandle, hbaPortWWN, destWWN, domainPortWWN,
43239e86db79SHyon Kim pReqBuffer, ReqBufferSize, pRspBuffer, pRspBufferSize);
43249e86db79SHyon Kim } else {
43259e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
43269e86db79SHyon Kim }
43279e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
43289e86db79SHyon Kim }
43299e86db79SHyon Kim
43309e86db79SHyon Kim /*
43319e86db79SHyon Kim * Following the similar logic of HBAAPI addaspterevents_callback.
43329e86db79SHyon Kim *
43339e86db79SHyon Kim * Unlike other events Adapter Add Event is not limited to a specific
43340778188fSHengqing Hu * adapter(i.e. no adapter handle is passed for registration) so
43359e86db79SHyon Kim * the event should be passed to all registrants. The routine below
43369e86db79SHyon Kim * is passed to the VSLs as a callback and when Adapter Add event is detected
43379e86db79SHyon Kim * by VSL it will call smhba_adapteraddevents_callback() which in turn check
43389e86db79SHyon Kim * if the passed userdata ptr matches with the one stored in the callback list
43399e86db79SHyon Kim * and calls the stored callback.
43409e86db79SHyon Kim *
43419e86db79SHyon Kim * For the situation that multiple clients are registered for Adapter Add event
43429e86db79SHyon Kim * each registration is passed to VSLs so VSL may call
43439e86db79SHyon Kim * smhba_adapteraddevents_callback() multiple times or it may call only once
43449e86db79SHyon Kim * since the callback function is same. For this implemneation, the userdata
43459e86db79SHyon Kim * is stored in HBA_ALLADAPTERSCALLBACK_ELEM so it is expected that VSL call
43469e86db79SHyon Kim * smhba_adapteraddevents_callback() only once and
43479e86db79SHyon Kim * smhba_adapteraddevents_callback() will call the client callback with proper
43489e86db79SHyon Kim * userdata.
43499e86db79SHyon Kim */
43509e86db79SHyon Kim static void
smhba_adapteraddevents_callback(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType)43519e86db79SHyon Kim smhba_adapteraddevents_callback(
43529e86db79SHyon Kim /* LINTED E_FUNC_ARG_UNUSED */
43539e86db79SHyon Kim void *data,
43549e86db79SHyon Kim HBA_WWN PortWWN,
43559e86db79SHyon Kim /* LINTED E_FUNC_ARG_UNUSED */
43569e86db79SHyon Kim HBA_UINT32 eventType)
43579e86db79SHyon Kim {
43589e86db79SHyon Kim HBA_ALLADAPTERSCALLBACK_ELEM *cbp;
43599e86db79SHyon Kim
43609e86db79SHyon Kim DEBUG(3, "AddAdapterEvent, port:%s", WWN2STR1(&PortWWN), 0, 0);
43619e86db79SHyon Kim
43629e86db79SHyon Kim GRAB_MUTEX(&_smhba_AAE_mutex);
43639e86db79SHyon Kim for (cbp = _smhba_adapteraddevents_callback_list;
43649e86db79SHyon Kim cbp != NULL;
43659e86db79SHyon Kim cbp = cbp->next) {
43669e86db79SHyon Kim (*cbp->callback)(cbp->userdata, PortWWN, HBA_EVENT_ADAPTER_ADD);
43679e86db79SHyon Kim }
43689e86db79SHyon Kim RELEASE_MUTEX(&_smhba_AAE_mutex);
43699e86db79SHyon Kim
43709e86db79SHyon Kim }
43719e86db79SHyon Kim
43729e86db79SHyon Kim HBA_STATUS
SMHBA_RegisterForAdapterAddEvents(void (* pCallback)(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType),void * pUserData,HBA_CALLBACKHANDLE * pCallbackHandle)43739e86db79SHyon Kim SMHBA_RegisterForAdapterAddEvents(
43749e86db79SHyon Kim void (*pCallback) (
43759e86db79SHyon Kim void *data,
43769e86db79SHyon Kim HBA_WWN PortWWN,
43779e86db79SHyon Kim HBA_UINT32 eventType),
43789e86db79SHyon Kim void *pUserData,
43799e86db79SHyon Kim HBA_CALLBACKHANDLE *pCallbackHandle) {
43809e86db79SHyon Kim
43819e86db79SHyon Kim HBA_ALLADAPTERSCALLBACK_ELEM *cbp;
43829e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vcbp;
43839e86db79SHyon Kim HBA_VENDORCALLBACK_ELEM *vendorhandlelist;
43849e86db79SHyon Kim SMHBARegisterForAdapterAddEventsFunc registeredfunc;
43859e86db79SHyon Kim HBA_STATUS status = HBA_STATUS_OK;
43869e86db79SHyon Kim HBA_STATUS failure = HBA_STATUS_OK;
43879e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
43889e86db79SHyon Kim int registered_cnt = 0;
43899e86db79SHyon Kim int vendor_cnt = 0;
43909e86db79SHyon Kim int not_supported_cnt = 0;
43919e86db79SHyon Kim int status_OK_bar_cnt = 0;
43929e86db79SHyon Kim int status_OK_cnt = 0;
43939e86db79SHyon Kim
43949e86db79SHyon Kim DEBUG(2, "SMHBA_RegisterForAdapterAddEvents", 0, 0, 0);
43959e86db79SHyon Kim ARE_WE_INITED();
43969e86db79SHyon Kim
43979e86db79SHyon Kim cbp = (HBA_ALLADAPTERSCALLBACK_ELEM *)
43989e86db79SHyon Kim calloc(1, sizeof (HBA_ALLADAPTERSCALLBACK_ELEM));
43999e86db79SHyon Kim *pCallbackHandle = (HBA_CALLBACKHANDLE) cbp;
44009e86db79SHyon Kim if (cbp == NULL) {
44019e86db79SHyon Kim return (HBA_STATUS_ERROR);
44029e86db79SHyon Kim }
44039e86db79SHyon Kim
44049e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_LL_mutex);
44059e86db79SHyon Kim GRAB_MUTEX(&_smhba_AAE_mutex);
44069e86db79SHyon Kim cbp->callback = pCallback;
44079e86db79SHyon Kim cbp->userdata = pUserData;
44089e86db79SHyon Kim cbp->next = _smhba_adapteraddevents_callback_list;
44099e86db79SHyon Kim _smhba_adapteraddevents_callback_list = cbp;
44109e86db79SHyon Kim
44119e86db79SHyon Kim /*
44129e86db79SHyon Kim * Need to release the mutex now incase the vendor function invokes the
44139e86db79SHyon Kim * callback. We will grap the mutex later to attach the vendor handle
44149e86db79SHyon Kim * list to the callback structure
44159e86db79SHyon Kim */
44169e86db79SHyon Kim RELEASE_MUTEX(&_smhba_AAE_mutex);
44179e86db79SHyon Kim
44189e86db79SHyon Kim
44199e86db79SHyon Kim /*
44209e86db79SHyon Kim * now create a list of vendors (vendor libraryies, NOT ADAPTERS)
44219e86db79SHyon Kim * that have successfully registerred
44229e86db79SHyon Kim */
44239e86db79SHyon Kim vendorhandlelist = NULL;
44249e86db79SHyon Kim for (lib_infop = _hbaapi_librarylist;
44259e86db79SHyon Kim lib_infop != NULL;
44269e86db79SHyon Kim lib_infop = lib_infop->next) {
44279e86db79SHyon Kim
44289e86db79SHyon Kim /* only for HBAAPI V2 */
44299e86db79SHyon Kim if (lib_infop->version != SMHBA) {
44309e86db79SHyon Kim continue;
44319e86db79SHyon Kim } else {
44329e86db79SHyon Kim vendor_cnt++;
44339e86db79SHyon Kim }
44349e86db79SHyon Kim
44359e86db79SHyon Kim registeredfunc =
44369e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.\
44379e86db79SHyon Kim RegisterForAdapterAddEventsHandler;
44389e86db79SHyon Kim if (registeredfunc == NULL) {
44399e86db79SHyon Kim continue;
44409e86db79SHyon Kim }
44419e86db79SHyon Kim
44429e86db79SHyon Kim vcbp = (HBA_VENDORCALLBACK_ELEM *)
44439e86db79SHyon Kim calloc(1, sizeof (HBA_VENDORCALLBACK_ELEM));
44449e86db79SHyon Kim if (vcbp == NULL) {
44459e86db79SHyon Kim freevendorhandlelist(vendorhandlelist);
44469e86db79SHyon Kim status = HBA_STATUS_ERROR;
44479e86db79SHyon Kim break;
44489e86db79SHyon Kim }
44499e86db79SHyon Kim
44509e86db79SHyon Kim registered_cnt++;
44519e86db79SHyon Kim status = (registeredfunc)(smhba_adapteraddevents_callback,
44529e86db79SHyon Kim pUserData, &vcbp->vendorcbhandle);
44539e86db79SHyon Kim if (status == HBA_STATUS_ERROR_NOT_SUPPORTED) {
44549e86db79SHyon Kim not_supported_cnt++;
44559e86db79SHyon Kim free(vcbp);
44569e86db79SHyon Kim continue;
44579e86db79SHyon Kim } else if (status != HBA_STATUS_OK) {
44589e86db79SHyon Kim status_OK_bar_cnt++;
44599e86db79SHyon Kim DEBUG(1,
44609e86db79SHyon Kim "SMHBA_RegisterForAdapterAddEvents: Library->%s, Error->%d",
44619e86db79SHyon Kim lib_infop->LibraryPath, status, 0);
44629e86db79SHyon Kim failure = status;
44639e86db79SHyon Kim free(vcbp);
44649e86db79SHyon Kim continue;
44659e86db79SHyon Kim } else {
44669e86db79SHyon Kim status_OK_cnt++;
44679e86db79SHyon Kim }
44689e86db79SHyon Kim vcbp->lib_info = lib_infop;
44699e86db79SHyon Kim vcbp->next = vendorhandlelist;
44709e86db79SHyon Kim vendorhandlelist = vcbp;
44719e86db79SHyon Kim }
44729e86db79SHyon Kim
44739e86db79SHyon Kim if (vendor_cnt == 0) {
44749e86db79SHyon Kim /* no SMHBA VSL found. Should be okay?? */
44759e86db79SHyon Kim status = HBA_STATUS_ERROR;
44769e86db79SHyon Kim } else if (registered_cnt == 0) {
44779e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
44789e86db79SHyon Kim freevendorhandlelist(vendorhandlelist);
44799e86db79SHyon Kim (void) local_remove_callback((HBA_CALLBACKHANDLE) cbp);
44809e86db79SHyon Kim } else if (status_OK_cnt == 0 && not_supported_cnt != 0) {
44819e86db79SHyon Kim status = HBA_STATUS_ERROR_NOT_SUPPORTED;
44829e86db79SHyon Kim } else if (status_OK_cnt == 0) {
44839e86db79SHyon Kim /*
44849e86db79SHyon Kim * At least one vendor library registered this function, but no
44859e86db79SHyon Kim * vendor call succeeded
44869e86db79SHyon Kim */
44879e86db79SHyon Kim (void) local_remove_callback((HBA_CALLBACKHANDLE) cbp);
44889e86db79SHyon Kim status = failure;
44899e86db79SHyon Kim } else {
44909e86db79SHyon Kim /* we have had atleast some success, now finish up */
44919e86db79SHyon Kim GRAB_MUTEX(&_smhba_AAE_mutex);
44929e86db79SHyon Kim /*
44939e86db79SHyon Kim * this seems silly, but what if another thread called
44949e86db79SHyon Kim * the callback remove
44959e86db79SHyon Kim */
44969e86db79SHyon Kim for (cbp = _smhba_adapteraddevents_callback_list;
44979e86db79SHyon Kim cbp != NULL; cbp = cbp->next) {
44989e86db79SHyon Kim if ((HBA_CALLBACKHANDLE)cbp == *pCallbackHandle) {
44999e86db79SHyon Kim /* yup, its still there, hooray */
45009e86db79SHyon Kim cbp->vendorhandlelist = vendorhandlelist;
45019e86db79SHyon Kim vendorhandlelist = NULL;
45029e86db79SHyon Kim break;
45039e86db79SHyon Kim }
45049e86db79SHyon Kim }
45059e86db79SHyon Kim RELEASE_MUTEX(&_smhba_AAE_mutex);
45069e86db79SHyon Kim if (vendorhandlelist != NULL) {
45079e86db79SHyon Kim /*
45089e86db79SHyon Kim * bummer, somebody removed the callback before we finished
45099e86db79SHyon Kim * registration, probably will never happen
45109e86db79SHyon Kim */
45119e86db79SHyon Kim freevendorhandlelist(vendorhandlelist);
45129e86db79SHyon Kim DEBUG(1,
45139e86db79SHyon Kim "HBA_RegisterForAdapterAddEvents: HBA_RemoveCallback was "
45149e86db79SHyon Kim "called for a handle before registration was finished.",
45159e86db79SHyon Kim 0, 0, 0);
45169e86db79SHyon Kim status = HBA_STATUS_ERROR;
45179e86db79SHyon Kim } else {
45189e86db79SHyon Kim status = HBA_STATUS_OK;
45199e86db79SHyon Kim }
45209e86db79SHyon Kim }
45219e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
45229e86db79SHyon Kim }
45239e86db79SHyon Kim
45249e86db79SHyon Kim /* SMHBA Adapter Events (other than add) ******************************** */
45259e86db79SHyon Kim static void
smhba_adapterevents_callback(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType)45269e86db79SHyon Kim smhba_adapterevents_callback(void *data,
45279e86db79SHyon Kim HBA_WWN PortWWN,
45289e86db79SHyon Kim HBA_UINT32 eventType)
45299e86db79SHyon Kim {
45309e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
45319e86db79SHyon Kim
45329e86db79SHyon Kim DEBUG(3, "AdapterEvent, port:%s, eventType:%d", WWN2STR1(&PortWWN),
45339e86db79SHyon Kim eventType, 0);
45349e86db79SHyon Kim
45359e86db79SHyon Kim GRAB_MUTEX(&_hbaapi_AE_mutex);
45369e86db79SHyon Kim for (acbp = _smhba_adapterevents_callback_list;
45379e86db79SHyon Kim acbp != NULL;
45389e86db79SHyon Kim acbp = acbp->next) {
45399e86db79SHyon Kim if (data == (void *)acbp) {
45409e86db79SHyon Kim (*acbp->callback)(acbp->userdata, PortWWN, eventType);
45419e86db79SHyon Kim break;
45429e86db79SHyon Kim }
45439e86db79SHyon Kim }
45449e86db79SHyon Kim RELEASE_MUTEX(&_hbaapi_AE_mutex);
45459e86db79SHyon Kim }
45469e86db79SHyon Kim
45479e86db79SHyon Kim HBA_STATUS
SMHBA_RegisterForAdapterEvents(void (* pCallback)(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType),void * pUserData,HBA_HANDLE handle,HBA_CALLBACKHANDLE * pCallbackHandle)45489e86db79SHyon Kim SMHBA_RegisterForAdapterEvents(
45499e86db79SHyon Kim void (*pCallback) (
45509e86db79SHyon Kim void *data,
45519e86db79SHyon Kim HBA_WWN PortWWN,
45529e86db79SHyon Kim HBA_UINT32 eventType),
45539e86db79SHyon Kim void *pUserData,
45549e86db79SHyon Kim HBA_HANDLE handle,
45559e86db79SHyon Kim HBA_CALLBACKHANDLE *pCallbackHandle) {
45569e86db79SHyon Kim
45579e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
45589e86db79SHyon Kim SMHBARegisterForAdapterEventsFunc registeredfunc;
45599e86db79SHyon Kim HBA_STATUS status;
45609e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
45619e86db79SHyon Kim HBA_HANDLE vendorHandle;
45629e86db79SHyon Kim
45639e86db79SHyon Kim DEBUG(2, "SMHBA_RegisterForAdapterEvents", 0, 0, 0);
45649e86db79SHyon Kim
45659e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
45669e86db79SHyon Kim
45679e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
45689e86db79SHyon Kim
45699e86db79SHyon Kim registeredfunc = lib_infop->ftable.smhbafunctionTable.\
45709e86db79SHyon Kim RegisterForAdapterEventsHandler;
45719e86db79SHyon Kim if (registeredfunc == NULL) {
45729e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
45739e86db79SHyon Kim }
45749e86db79SHyon Kim
45759e86db79SHyon Kim /*
45769e86db79SHyon Kim * that allocated memory is used both as the handle for the
45779e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
45789e86db79SHyon Kim * callback the specific registration may be recalled
45799e86db79SHyon Kim */
45809e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
45819e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
45829e86db79SHyon Kim if (acbp == NULL) {
45839e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
45849e86db79SHyon Kim }
45859e86db79SHyon Kim *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
45869e86db79SHyon Kim acbp->callback = pCallback;
45879e86db79SHyon Kim acbp->userdata = pUserData;
45889e86db79SHyon Kim acbp->lib_info = lib_infop;
45899e86db79SHyon Kim
45909e86db79SHyon Kim status = (registeredfunc)(smhba_adapterevents_callback,
45919e86db79SHyon Kim (void *)acbp,
45929e86db79SHyon Kim vendorHandle,
45939e86db79SHyon Kim &acbp->vendorcbhandle);
45949e86db79SHyon Kim if (status != HBA_STATUS_OK) {
45959e86db79SHyon Kim free(acbp);
45969e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
45979e86db79SHyon Kim }
45989e86db79SHyon Kim
45999e86db79SHyon Kim GRAB_MUTEX(&_smhba_AE_mutex);
46009e86db79SHyon Kim acbp->next = _smhba_adapterevents_callback_list;
46019e86db79SHyon Kim _hbaapi_adapterevents_callback_list = acbp;
46029e86db79SHyon Kim
46039e86db79SHyon Kim RELEASE_MUTEX(&_smhba_AE_mutex);
46049e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
46059e86db79SHyon Kim }
46069e86db79SHyon Kim
46079e86db79SHyon Kim /* Adapter Port Events *********************************************** */
46089e86db79SHyon Kim static void
smhba_adapterportevents_callback(void * data,HBA_WWN PortWWN,HBA_UINT32 eventType,HBA_UINT32 fabricPortID)46099e86db79SHyon Kim smhba_adapterportevents_callback(void *data,
46109e86db79SHyon Kim HBA_WWN PortWWN,
46119e86db79SHyon Kim HBA_UINT32 eventType,
46129e86db79SHyon Kim HBA_UINT32 fabricPortID)
46139e86db79SHyon Kim {
46149e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
46159e86db79SHyon Kim
46169e86db79SHyon Kim DEBUG(3,
46179e86db79SHyon Kim "SMHBA_AdapterPortEvent, port:%s, eventType:%d fabricPortID:0X%06x",
46189e86db79SHyon Kim WWN2STR1(&PortWWN), eventType, fabricPortID);
46199e86db79SHyon Kim
46209e86db79SHyon Kim GRAB_MUTEX(&_smhba_APE_mutex);
46219e86db79SHyon Kim
46229e86db79SHyon Kim for (acbp = _smhba_adapterportevents_callback_list;
46239e86db79SHyon Kim acbp != NULL;
46249e86db79SHyon Kim acbp = acbp->next) {
46259e86db79SHyon Kim if (data == (void *)acbp) {
46269e86db79SHyon Kim (*acbp->callback)(acbp->userdata, PortWWN,
46279e86db79SHyon Kim eventType, fabricPortID);
46289e86db79SHyon Kim break;
46299e86db79SHyon Kim }
46309e86db79SHyon Kim }
46319e86db79SHyon Kim RELEASE_MUTEX(&_smhba_APE_mutex);
46329e86db79SHyon Kim }
46339e86db79SHyon Kim
46349e86db79SHyon Kim HBA_STATUS
SMHBA_RegisterForAdapterPortEvents(void (* pCallback)(void * pData,HBA_WWN PortWWN,HBA_UINT32 eventType,HBA_UINT32 fabricPortID),void * pUserData,HBA_HANDLE handle,HBA_WWN portWWN,HBA_UINT32 specificEventType,HBA_CALLBACKHANDLE * pCallbackHandle)46359e86db79SHyon Kim SMHBA_RegisterForAdapterPortEvents(
46369e86db79SHyon Kim void (*pCallback) (
46379e86db79SHyon Kim void *pData,
46389e86db79SHyon Kim HBA_WWN PortWWN,
46399e86db79SHyon Kim HBA_UINT32 eventType,
46409e86db79SHyon Kim HBA_UINT32 fabricPortID),
46419e86db79SHyon Kim void *pUserData,
46429e86db79SHyon Kim HBA_HANDLE handle,
46439e86db79SHyon Kim HBA_WWN portWWN,
46449e86db79SHyon Kim HBA_UINT32 specificEventType,
46459e86db79SHyon Kim HBA_CALLBACKHANDLE *pCallbackHandle) {
46469e86db79SHyon Kim
46479e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
46489e86db79SHyon Kim SMHBARegisterForAdapterPortEventsFunc registeredfunc;
46499e86db79SHyon Kim HBA_STATUS status;
46509e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
46519e86db79SHyon Kim HBA_HANDLE vendorHandle;
46529e86db79SHyon Kim
46539e86db79SHyon Kim DEBUG(2, "SMHBA_RegisterForAdapterPortEvents for port: %s",
46549e86db79SHyon Kim WWN2STR1(&portWWN), 0, 0);
46559e86db79SHyon Kim
46569e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
46579e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
46589e86db79SHyon Kim
46599e86db79SHyon Kim registeredfunc =
46609e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.\
46619e86db79SHyon Kim RegisterForAdapterPortEventsHandler;
46629e86db79SHyon Kim if (registeredfunc == NULL) {
46639e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
46649e86db79SHyon Kim }
46659e86db79SHyon Kim
46669e86db79SHyon Kim /*
46679e86db79SHyon Kim * that allocated memory is used both as the handle for the
46689e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
46699e86db79SHyon Kim * callback the specific registration may be recalled
46709e86db79SHyon Kim */
46719e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
46729e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
46739e86db79SHyon Kim if (acbp == NULL) {
46749e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
46759e86db79SHyon Kim }
46769e86db79SHyon Kim *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
46779e86db79SHyon Kim acbp->callback = pCallback;
46789e86db79SHyon Kim acbp->userdata = pUserData;
46799e86db79SHyon Kim acbp->lib_info = lib_infop;
46809e86db79SHyon Kim
46819e86db79SHyon Kim status = (registeredfunc)(smhba_adapterportevents_callback,
46829e86db79SHyon Kim (void *)acbp,
46839e86db79SHyon Kim vendorHandle,
46849e86db79SHyon Kim portWWN,
46859e86db79SHyon Kim specificEventType,
46869e86db79SHyon Kim &acbp->vendorcbhandle);
46879e86db79SHyon Kim if (status != HBA_STATUS_OK) {
46889e86db79SHyon Kim free(acbp);
46899e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
46909e86db79SHyon Kim }
46919e86db79SHyon Kim
46929e86db79SHyon Kim GRAB_MUTEX(&_smhba_APE_mutex);
46939e86db79SHyon Kim acbp->next = _smhba_adapterportevents_callback_list;
46949e86db79SHyon Kim _smhba_adapterportevents_callback_list = acbp;
46959e86db79SHyon Kim
46969e86db79SHyon Kim RELEASE_MUTEX(&_smhba_APE_mutex);
46979e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
46989e86db79SHyon Kim }
46999e86db79SHyon Kim
47009e86db79SHyon Kim /* SMHBA Adapter Port Stat Events ******************************** */
47019e86db79SHyon Kim static void
smhba_adapterportstatevents_callback(void * data,HBA_WWN portWWN,HBA_UINT32 protocolType,HBA_UINT32 eventType)47029e86db79SHyon Kim smhba_adapterportstatevents_callback(void *data,
47039e86db79SHyon Kim HBA_WWN portWWN,
47049e86db79SHyon Kim HBA_UINT32 protocolType,
47059e86db79SHyon Kim HBA_UINT32 eventType)
47069e86db79SHyon Kim {
47079e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
47089e86db79SHyon Kim
47099e86db79SHyon Kim DEBUG(3,
47109e86db79SHyon Kim "SMBA_AdapterPortStateEvent, port:%s, eventType:%d",
47119e86db79SHyon Kim WWN2STR1(&portWWN), eventType, 0);
47129e86db79SHyon Kim
47139e86db79SHyon Kim GRAB_MUTEX(&_smhba_APSE_mutex);
47149e86db79SHyon Kim for (acbp = _smhba_adapterportstatevents_callback_list;
47159e86db79SHyon Kim acbp != NULL;
47169e86db79SHyon Kim acbp = acbp->next) {
47179e86db79SHyon Kim if (data == (void *)acbp) {
47189e86db79SHyon Kim (*acbp->callback)(acbp->userdata, portWWN,
47199e86db79SHyon Kim protocolType, eventType);
47209e86db79SHyon Kim return;
47219e86db79SHyon Kim }
47229e86db79SHyon Kim }
47239e86db79SHyon Kim RELEASE_MUTEX(&_smhba_APSE_mutex);
47249e86db79SHyon Kim }
47259e86db79SHyon Kim
47269e86db79SHyon Kim HBA_STATUS
SMHBA_RegisterForAdapterPortStatEvents(void (* pCallback)(void * pData,HBA_WWN portWWN,HBA_UINT32 protocolType,HBA_UINT32 eventType),void * pUserData,HBA_HANDLE handle,HBA_WWN portWWN,HBA_UINT32 protocolType,SMHBA_PROTOCOLSTATISTICS stats,HBA_UINT32 statType,HBA_CALLBACKHANDLE * pCallbackHandle)47279e86db79SHyon Kim SMHBA_RegisterForAdapterPortStatEvents(
47289e86db79SHyon Kim void (*pCallback) (
47299e86db79SHyon Kim void *pData,
47309e86db79SHyon Kim HBA_WWN portWWN,
47319e86db79SHyon Kim HBA_UINT32 protocolType,
47329e86db79SHyon Kim HBA_UINT32 eventType),
47339e86db79SHyon Kim void *pUserData,
47349e86db79SHyon Kim HBA_HANDLE handle,
47359e86db79SHyon Kim HBA_WWN portWWN,
47369e86db79SHyon Kim HBA_UINT32 protocolType,
47379e86db79SHyon Kim SMHBA_PROTOCOLSTATISTICS stats,
47389e86db79SHyon Kim HBA_UINT32 statType,
47399e86db79SHyon Kim HBA_CALLBACKHANDLE *pCallbackHandle) {
47409e86db79SHyon Kim
47419e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
47429e86db79SHyon Kim SMHBARegisterForAdapterPortStatEventsFunc
47439e86db79SHyon Kim registeredfunc;
47449e86db79SHyon Kim HBA_STATUS status;
47459e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
47469e86db79SHyon Kim HBA_HANDLE vendorHandle;
47479e86db79SHyon Kim
47489e86db79SHyon Kim DEBUG(2, "SMHBA_RegisterForAdapterPortStatEvents for port: %s",
47499e86db79SHyon Kim WWN2STR1(&portWWN), 0, 0);
47509e86db79SHyon Kim
47519e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
47529e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
47539e86db79SHyon Kim
47549e86db79SHyon Kim registeredfunc =
47559e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.\
47569e86db79SHyon Kim RegisterForAdapterPortStatEventsHandler;
47579e86db79SHyon Kim if (registeredfunc == NULL) {
47589e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
47599e86db79SHyon Kim }
47609e86db79SHyon Kim
47619e86db79SHyon Kim /*
47629e86db79SHyon Kim * that allocated memory is used both as the handle for the
47639e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
47649e86db79SHyon Kim * callback the specific registration may be recalled
47659e86db79SHyon Kim */
47669e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
47679e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
47689e86db79SHyon Kim if (acbp == NULL) {
47699e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
47709e86db79SHyon Kim }
47719e86db79SHyon Kim *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
47729e86db79SHyon Kim acbp->callback = pCallback;
47739e86db79SHyon Kim acbp->userdata = pUserData;
47749e86db79SHyon Kim acbp->lib_info = lib_infop;
47759e86db79SHyon Kim
47769e86db79SHyon Kim status = (registeredfunc)(smhba_adapterportstatevents_callback,
47779e86db79SHyon Kim (void *)acbp,
47789e86db79SHyon Kim vendorHandle,
47799e86db79SHyon Kim portWWN,
47809e86db79SHyon Kim protocolType,
47819e86db79SHyon Kim stats,
47829e86db79SHyon Kim statType,
47839e86db79SHyon Kim &acbp->vendorcbhandle);
47849e86db79SHyon Kim if (status != HBA_STATUS_OK) {
47859e86db79SHyon Kim free(acbp);
47869e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
47879e86db79SHyon Kim }
47889e86db79SHyon Kim
47899e86db79SHyon Kim GRAB_MUTEX(&_smhba_APSE_mutex);
47909e86db79SHyon Kim acbp->next = _smhba_adapterportstatevents_callback_list;
47919e86db79SHyon Kim _smhba_adapterportstatevents_callback_list = acbp;
47929e86db79SHyon Kim
47939e86db79SHyon Kim RELEASE_MUTEX(&_smhba_APSE_mutex);
47949e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
47959e86db79SHyon Kim }
47969e86db79SHyon Kim
47979e86db79SHyon Kim /* SMHBA Adapter Port Phy Stat Events ************************************ */
47989e86db79SHyon Kim static void
smhba_adapterphystatevents_callback(void * data,HBA_WWN portWWN,HBA_UINT32 phyIndex,HBA_UINT32 eventType)47999e86db79SHyon Kim smhba_adapterphystatevents_callback(void *data,
48009e86db79SHyon Kim HBA_WWN portWWN,
48019e86db79SHyon Kim HBA_UINT32 phyIndex,
48029e86db79SHyon Kim HBA_UINT32 eventType)
48039e86db79SHyon Kim {
48049e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
48059e86db79SHyon Kim
48069e86db79SHyon Kim DEBUG(3,
48079e86db79SHyon Kim "SMBA_AdapterPortStateEvent, port:%s, eventType:%d",
48089e86db79SHyon Kim WWN2STR1(&portWWN), eventType, 0);
48099e86db79SHyon Kim
48109e86db79SHyon Kim GRAB_MUTEX(&_smhba_APHYSE_mutex);
48119e86db79SHyon Kim for (acbp = _smhba_adapterphystatevents_callback_list;
48129e86db79SHyon Kim acbp != NULL;
48139e86db79SHyon Kim acbp = acbp->next) {
48149e86db79SHyon Kim if (data == (void *)acbp) {
48159e86db79SHyon Kim (*acbp->callback)(acbp->userdata, portWWN, phyIndex, eventType);
48169e86db79SHyon Kim return;
48179e86db79SHyon Kim }
48189e86db79SHyon Kim }
48199e86db79SHyon Kim RELEASE_MUTEX(&_smhba_APHYSE_mutex);
48209e86db79SHyon Kim }
48219e86db79SHyon Kim
48229e86db79SHyon Kim HBA_STATUS
SMHBA_RegisterForAdapterPhyStatEvents(void (* pCallback)(void * pData,HBA_WWN portWWN,HBA_UINT32 phyIndex,HBA_UINT32 eventType),void * pUserData,HBA_HANDLE handle,HBA_WWN portWWN,HBA_UINT32 phyIndex,SMHBA_PHYSTATISTICS stats,HBA_UINT32 statType,HBA_CALLBACKHANDLE * pCallbackHandle)48239e86db79SHyon Kim SMHBA_RegisterForAdapterPhyStatEvents(
48249e86db79SHyon Kim void (*pCallback) (
48259e86db79SHyon Kim void *pData,
48269e86db79SHyon Kim HBA_WWN portWWN,
48279e86db79SHyon Kim HBA_UINT32 phyIndex,
48289e86db79SHyon Kim HBA_UINT32 eventType),
48299e86db79SHyon Kim void *pUserData,
48309e86db79SHyon Kim HBA_HANDLE handle,
48319e86db79SHyon Kim HBA_WWN portWWN,
48329e86db79SHyon Kim HBA_UINT32 phyIndex,
48339e86db79SHyon Kim SMHBA_PHYSTATISTICS stats,
48349e86db79SHyon Kim HBA_UINT32 statType,
48359e86db79SHyon Kim HBA_CALLBACKHANDLE *pCallbackHandle) {
48369e86db79SHyon Kim
48379e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
48389e86db79SHyon Kim SMHBARegisterForAdapterPhyStatEventsFunc
48399e86db79SHyon Kim registeredfunc;
48409e86db79SHyon Kim HBA_STATUS status;
48419e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
48429e86db79SHyon Kim HBA_HANDLE vendorHandle;
48439e86db79SHyon Kim
48449e86db79SHyon Kim DEBUG(2, "SMHBA_RegisterForAdapterPhyStatEvents for port: %s",
48459e86db79SHyon Kim WWN2STR1(&portWWN), 0, 0);
48469e86db79SHyon Kim
48479e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
48489e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
48499e86db79SHyon Kim
48509e86db79SHyon Kim registeredfunc =
48519e86db79SHyon Kim lib_infop->ftable.smhbafunctionTable.\
48529e86db79SHyon Kim RegisterForAdapterPhyStatEventsHandler;
48539e86db79SHyon Kim if (registeredfunc == NULL) {
48549e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
48559e86db79SHyon Kim }
48569e86db79SHyon Kim
48579e86db79SHyon Kim /*
48589e86db79SHyon Kim * that allocated memory is used both as the handle for the
48599e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
48609e86db79SHyon Kim * callback the specific registration may be recalled
48619e86db79SHyon Kim */
48629e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
48639e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
48649e86db79SHyon Kim if (acbp == NULL) {
48659e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
48669e86db79SHyon Kim }
48679e86db79SHyon Kim *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
48689e86db79SHyon Kim acbp->callback = pCallback;
48699e86db79SHyon Kim acbp->userdata = pUserData;
48709e86db79SHyon Kim acbp->lib_info = lib_infop;
48719e86db79SHyon Kim
48729e86db79SHyon Kim status = (registeredfunc)(smhba_adapterphystatevents_callback,
48739e86db79SHyon Kim (void *)acbp,
48749e86db79SHyon Kim vendorHandle,
48759e86db79SHyon Kim portWWN,
48769e86db79SHyon Kim phyIndex,
48779e86db79SHyon Kim stats,
48789e86db79SHyon Kim statType,
48799e86db79SHyon Kim &acbp->vendorcbhandle);
48809e86db79SHyon Kim if (status != HBA_STATUS_OK) {
48819e86db79SHyon Kim free(acbp);
48829e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
48839e86db79SHyon Kim }
48849e86db79SHyon Kim
48859e86db79SHyon Kim GRAB_MUTEX(&_smhba_APHYSE_mutex);
48869e86db79SHyon Kim acbp->next = _smhba_adapterphystatevents_callback_list;
48879e86db79SHyon Kim _smhba_adapterphystatevents_callback_list = acbp;
48889e86db79SHyon Kim
48899e86db79SHyon Kim RELEASE_MUTEX(&_smhba_APHYSE_mutex);
48909e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
48919e86db79SHyon Kim }
48929e86db79SHyon Kim
48939e86db79SHyon Kim /* SMHBA Target Events ********************************************* */
48949e86db79SHyon Kim static void
smhba_targetevents_callback(void * data,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_WWN domainPortWWN,HBA_UINT32 eventType)48959e86db79SHyon Kim smhba_targetevents_callback(void *data,
48969e86db79SHyon Kim HBA_WWN hbaPortWWN,
48979e86db79SHyon Kim HBA_WWN discoveredPortWWN,
48989e86db79SHyon Kim HBA_WWN domainPortWWN,
48999e86db79SHyon Kim HBA_UINT32 eventType)
49009e86db79SHyon Kim {
49019e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
49029e86db79SHyon Kim
49039e86db79SHyon Kim DEBUG(3, "TargetEvent, hbaPort:%s, discoveredPort:%s eventType:%d",
49049e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), eventType);
49059e86db79SHyon Kim
49069e86db79SHyon Kim GRAB_MUTEX(&_smhba_TE_mutex);
49079e86db79SHyon Kim for (acbp = _smhba_targetevents_callback_list;
49089e86db79SHyon Kim acbp != NULL;
49099e86db79SHyon Kim acbp = acbp->next) {
49109e86db79SHyon Kim if (data == (void *)acbp) {
49119e86db79SHyon Kim (*acbp->callback)(acbp->userdata, hbaPortWWN,
49129e86db79SHyon Kim discoveredPortWWN, domainPortWWN, eventType);
49139e86db79SHyon Kim break;
49149e86db79SHyon Kim }
49159e86db79SHyon Kim }
49169e86db79SHyon Kim RELEASE_MUTEX(&_smhba_TE_mutex);
49179e86db79SHyon Kim }
49189e86db79SHyon Kim
49199e86db79SHyon Kim HBA_STATUS
SMHBA_RegisterForTargetEvents(void (* pCallback)(void * pData,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_WWN domainPortWWN,HBA_UINT32 eventType),void * pUserData,HBA_HANDLE handle,HBA_WWN hbaPortWWN,HBA_WWN discoveredPortWWN,HBA_WWN domainPortWWN,HBA_CALLBACKHANDLE * pCallbackHandle,HBA_UINT32 allTargets)49209e86db79SHyon Kim SMHBA_RegisterForTargetEvents(
49219e86db79SHyon Kim void (*pCallback) (
49229e86db79SHyon Kim void *pData,
49239e86db79SHyon Kim HBA_WWN hbaPortWWN,
49249e86db79SHyon Kim HBA_WWN discoveredPortWWN,
49259e86db79SHyon Kim HBA_WWN domainPortWWN,
49269e86db79SHyon Kim HBA_UINT32 eventType),
49279e86db79SHyon Kim void *pUserData,
49289e86db79SHyon Kim HBA_HANDLE handle,
49299e86db79SHyon Kim HBA_WWN hbaPortWWN,
49309e86db79SHyon Kim HBA_WWN discoveredPortWWN,
49319e86db79SHyon Kim HBA_WWN domainPortWWN,
49329e86db79SHyon Kim HBA_CALLBACKHANDLE *pCallbackHandle,
49339e86db79SHyon Kim HBA_UINT32 allTargets) {
49349e86db79SHyon Kim
49359e86db79SHyon Kim HBA_ADAPTERCALLBACK_ELEM *acbp;
49369e86db79SHyon Kim SMHBARegisterForTargetEventsFunc
49379e86db79SHyon Kim registeredfunc;
49389e86db79SHyon Kim HBA_STATUS status;
49399e86db79SHyon Kim HBA_LIBRARY_INFO *lib_infop;
49409e86db79SHyon Kim HBA_HANDLE vendorHandle;
49419e86db79SHyon Kim
49429e86db79SHyon Kim DEBUG(2, "SMHBA_RegisterForTargetEvents, hbaPort:"
49439e86db79SHyon Kim "%s, discoveredPort: %s",
49449e86db79SHyon Kim WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), 0);
49459e86db79SHyon Kim
49469e86db79SHyon Kim CHECKLIBRARYANDVERSION(SMHBA);
49479e86db79SHyon Kim /* we now have the _hbaapi_LL_mutex */
49489e86db79SHyon Kim
49499e86db79SHyon Kim registeredfunc = lib_infop->ftable.smhbafunctionTable.\
49509e86db79SHyon Kim RegisterForTargetEventsHandler;
49519e86db79SHyon Kim
49529e86db79SHyon Kim if (registeredfunc == NULL) {
49539e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
49549e86db79SHyon Kim }
49559e86db79SHyon Kim
49569e86db79SHyon Kim /*
49579e86db79SHyon Kim * that allocated memory is used both as the handle for the
49589e86db79SHyon Kim * caller, and as userdata to the vendor call so that on
49599e86db79SHyon Kim * callback the specific registration may be recalled
49609e86db79SHyon Kim */
49619e86db79SHyon Kim acbp = (HBA_ADAPTERCALLBACK_ELEM *)
49629e86db79SHyon Kim calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
49639e86db79SHyon Kim if (acbp == NULL) {
49649e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
49659e86db79SHyon Kim }
49669e86db79SHyon Kim *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
49679e86db79SHyon Kim acbp->callback = pCallback;
49689e86db79SHyon Kim acbp->userdata = pUserData;
49699e86db79SHyon Kim acbp->lib_info = lib_infop;
49709e86db79SHyon Kim
49719e86db79SHyon Kim status = (registeredfunc)(smhba_targetevents_callback,
49729e86db79SHyon Kim (void *)acbp,
49739e86db79SHyon Kim vendorHandle,
49749e86db79SHyon Kim hbaPortWWN,
49759e86db79SHyon Kim discoveredPortWWN,
49769e86db79SHyon Kim domainPortWWN,
49779e86db79SHyon Kim &acbp->vendorcbhandle,
49789e86db79SHyon Kim allTargets);
49799e86db79SHyon Kim if (status != HBA_STATUS_OK) {
49809e86db79SHyon Kim free(acbp);
49819e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
49829e86db79SHyon Kim }
49839e86db79SHyon Kim
49849e86db79SHyon Kim GRAB_MUTEX(&_smhba_TE_mutex);
49859e86db79SHyon Kim acbp->next = _smhba_targetevents_callback_list;
49869e86db79SHyon Kim _smhba_targetevents_callback_list = acbp;
49879e86db79SHyon Kim
49889e86db79SHyon Kim RELEASE_MUTEX(&_smhba_TE_mutex);
49899e86db79SHyon Kim RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
49909e86db79SHyon Kim }
4991