1 /*
2 * ************************************************************************
3 * Description
4 * HBAAPILIB.c - Implements a sample common (wrapper) HBA API library
5 *
6 * License:
7 * The contents of this file are subject to the SNIA Public License
8 * Version 1.0 (the "License"); you may not use this file except in
9 * compliance with the License. You may obtain a copy of the License at
10 *
11 * /http://www.snia.org/English/Resources/Code/OpenSource.html
12 *
13 * Software distributed under the License is distributed on an "AS IS"
14 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
15 * the License for the specific language governing rights and limitations
16 * under the License.
17 *
18 * The Original Code is SNIA HBA API Wrapper Library
19 *
20 * The Initial Developer of the Original Code is:
21 * Benjamin F. Kuo, Troika Networks, Inc. (benk@troikanetworks.com)
22 *
23 * Contributor(s):
24 * Tuan Lam, QLogic Corp. (t_lam@qlc.com)
25 * Dan Willie, Emulex Corp. (Dan.Willie@emulex.com)
26 * Dixon Hutchinson, Legato Systems, Inc. (dhutchin@legato.com)
27 * David Dillard, VERITAS Software Corp. (david.dillard@veritas.com)
28 *
29 * ************************************************************************
30 *
31 * Adding on SM-HBA support
32 *
33 * The implementation includes Three different categories functions to support
34 * both HBAAPI and SM-HBA through the same library.
35 *
36 * SM-HBA unique interface:
37 * 1. CHECKLIBRARYANDVERSION(SMHBA) : match SMHBA VSL
38 * Or checking specifically if version is SMHBA beforehand.
39 * 2. resolved to ftable.smhbafunctiontable.{interface}
40 * HBAAPIV2 unique functions
41 * 1. CHECKLIBRARYANDVERSION(HBAAPIV2) : validate and match HBAAPI V2 VSL.
42 * Or checking specifically if version is HBAAPIV2 beforehand.
43 * 2. resolved to ftable.functiontable.{interface}
44 * Common interface between SM-HBA and HBAAPIV2.
45 * 1. CHECKLIBRARY() : to validate the VSL.
46 * 2. FUNCCOMMON macro to map the appropriate entry point table
47 * (union ftable).
48 * 3. If the interface is not supported by HBAAPI(Version 1)
49 * the funtiion ptr will be set to NULL.
50 * Common interface between HBAAPI and HBAAPIV2.
51 * 1. Check if version is not SMHBA).
52 * 2. ftable.functiontalbe.(interface)
53 *
54 * ************************************************************************
55 */
56 /*
57 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
58 * Use is subject to license terms.
59 */
60
61 #ifdef WIN32
62 #include <windows.h>
63 #include <string.h>
64 /*
65 * Next define forces entry points in the dll to be exported
66 * See hbaapi.h to see what it does.
67 */
68 #define HBAAPI_EXPORTS
69 #else
70 #include <dlfcn.h>
71 #include <strings.h>
72 #endif
73 #include <stdio.h>
74 #include <time.h>
75 #include "smhbaapi.h"
76 #include "vendorsmhbaapi.h"
77 #include <stdlib.h>
78 #ifdef USESYSLOG
79 #include <syslog.h>
80 #endif
81 #ifdef SOLARIS
82 #include <link.h>
83 #include <limits.h>
84 static int *handle;
85 static Link_map *map, *mp;
86 #endif
87
88 /*
89 * LIBRARY_NUM is a shortcut to figure out which library we need to call.
90 * The top 16 bits of handle are the library index
91 */
92 #define LIBRARY_NUM(handle) ((handle)>>16)
93
94 /*
95 * VENDOR_HANDLE turns a global library handle into a vendor specific handle,
96 * with all upper 16 bits set to 0
97 */
98 #define VENDOR_HANDLE(handle) ((handle)&0xFFFF)
99
100 #define HBA_HANDLE_FROM_LOCAL(library, vendor) \
101 (((library)<<16) | ((vendor)&0x0000FFFF))
102
103 int _hbaapi_debuglevel = 0;
104 #define DEBUG(L, STR, A1, A2, A3)
105
106 #if defined(USESYSLOG) && defined(USELOGFILE)
107 FILE *_hbaapi_debug_fd = NULL;
108 int _hbaapi_sysloginit = 0;
109 #undef DEBUG
110 #ifdef WIN32
111 #define DEBUG(L, STR, A1, A2, A3)\
112 if ((L) <= _hbaapi_debuglevel) {\
113 if (_hbaapi_sysloginit == 0) {\
114 openlog("HBAAPI", LOG_PID|LOG_ODELAY, LOG_USER);\
115 _hbaapi_sysloginit = 1;\
116 }\
117 syslog(LOG_INFO, (STR), (A1), (A2), (A3));\
118 if (_hbaapi_debug_fd == NULL) {\
119 char _logFile[MAX_PATH]; \
120 GetTempPath(MAX_PATH, _logFile); \
121 strcat(_logFile, "HBAAPI.log"); \
122 _hbaapi_debug_fd = fopen(_logFile, "a");\
123 }\
124 if (_hbaapi_debug_fd != NULL) {\
125 fprintf(_hbaapi_debug_fd, #STR "\n", (A1), (A2), (A3));\
126 }\
127 }
128 #else /* WIN32 */
129 #define DEBUG(L, STR, A1, A2, A3)\
130 if ((L) <= _hbaapi_debuglevel) {\
131 if (_hbaapi_sysloginit == 0) {\
132 openlog("HBAAPI", LOG_PID|LOG_ODELAY, LOG_USER);\
133 _hbaapi_sysloginit = 1;\
134 }\
135 syslog(LOG_INFO, (STR), (A1), (A2), (A3));\
136 if (_hbaapi_debug_fd == NULL) {\
137 _hbaapi_debug_fd = fopen("/tmp/HBAAPI.log", "a");\
138 }\
139 if (_hbaapi_debug_fd != NULL) {\
140 fprintf(_hbaapi_debug_fd, #STR "\n", (A1), (A2), (A3));\
141 }\
142 }
143 #endif /* WIN32 */
144
145 #else /* Not both USESYSLOG and USELOGFILE */
146 #if defined(USESYSLOG)
147 int _hbaapi_sysloginit = 0;
148 #undef DEBUG
149 #define DEBUG(L, STR, A1, A2, A3) \
150 if ((L) <= _hbaapi_debuglevel) {\
151 if (_hbaapi_sysloginit == 0) {\
152 openlog("HBAAPI", LOG_PID|LOG_ODELAY, LOG_USER);\
153 _hbaapi_sysloginit = 1;\
154 }\
155 syslog(LOG_DEBUG, (STR), (A1), (A2), (A3));\
156 }
157 #endif /* USESYSLOG */
158 #if defined(USELOGFILE)
159 FILE *_hbaapi_debug_fd = NULL;
160 #undef DEBUG
161 #ifdef WIN32
162 #define DEBUG(L, STR, A1, A2, A3) \
163 if ((L) <= _hbaapi_debuglevel) {\
164 if (_hbaapi_debug_fd == NULL) {\
165 char _logFile[MAX_PATH]; \
166 GetTempPath(MAX_PATH, _logFile); \
167 strcat(_logFile, "HBAAPI.log"); \
168 _hbaapi_debug_fd = fopen(_logFile, "a");\
169 }\
170 }
171 #else /* WIN32 */
172 #define DEBUG(L, STR, A1, A2, A3) \
173 if ((L) <= _hbaapi_debuglevel) {\
174 if (_hbaapi_debug_fd == NULL) {\
175 _hbaapi_debug_fd = fopen("/tmp/HBAAPI.log", "a");\
176 }\
177 if (_hbaapi_debug_fd != NULL) { \
178 fprintf(_hbaapi_debug_fd, #STR "\n", (A1), (A2), (A3));\
179 }\
180 }
181 #endif /* WIN32 */
182 #endif /* USELOGFILE */
183 #endif /* Not both USELOGFILE and USESYSLOG */
184
185 #ifdef POSIX_THREADS
186 #include <pthread.h>
187 /*
188 * When multiple mutex's are grabed, they must be always be grabbed in
189 * the same order, or deadlock can result. There are three levels
190 * of mutex's involved in this API. If LL_mutex is grabbed, always grap
191 * it first. If AL_mutex is grabbed, it may not be grabbed before
192 * LL_mutex. If grabbed in a multi grab sequence, the mutex's protecting
193 * the callback lists must always be grabbed last and release before calling
194 * a vendor specific library function that might invoke a callback function
195 * on the same thread.
196 */
197 #define GRAB_MUTEX(M) grab_mutex(M)
198 #define RELEASE_MUTEX(M) release_mutex(M)
199 #define RELEASE_MUTEX_RETURN(M, RET) release_mutex(M); return (RET)
200 #elif defined(WIN32)
201 #define GRAB_MUTEX(m) EnterCriticalSection(m)
202 #define RELEASE_MUTEX(m) LeaveCriticalSection(m)
203 #define RELEASE_MUTEX_RETURN(m, RET) LeaveCriticalSection(m); return (RET)
204 #else
205 #define GRAB_MUTEX(M)
206 #define RELEASE_MUTEX(M)
207 #define RELEASE_MUTEX_RETURN(M, RET) return (RET)
208 #endif
209
210 /*
211 * Vendor library information
212 */
213 typedef enum {
214 HBA_LIBRARY_UNKNOWN,
215 HBA_LIBRARY_LOADED,
216 HBA_LIBRARY_NOT_LOADED
217 } HBA_LIBRARY_STATUS;
218
219 typedef enum {
220 UNKNOWN = 1,
221 SMHBA,
222 HBAAPIV2,
223 HBAAPI
224 } LIBRARY_VERSION;
225
226 typedef struct hba_library_info {
227 struct hba_library_info
228 *next;
229 #ifdef WIN32
230 HINSTANCE hLibrary; /* Handle to a loaded DLL */
231 #else
232 char *LibraryName;
233 void* hLibrary; /* Handle to a loaded DLL */
234 #endif
235 char *LibraryPath;
236 LIBRARY_VERSION version; /* resolve union */
237 HBA_UINT32 numOfAdapters;
238 union {
239 SMHBA_ENTRYPOINTS smhbafunctionTable; /* smhba function pointers */
240 HBA_ENTRYPOINTSV2 functionTable; /* hba api function pointers */
241 } ftable;
242 HBA_LIBRARY_STATUS status; /* info on this library */
243 HBA_UINT32 index;
244 } HBA_LIBRARY_INFO, *PHBA_LIBRARY_INFO;
245
246 #define ARE_WE_INITED() \
247 if (_hbaapi_librarylist == NULL) { \
248 return (HBA_STATUS_ERROR_NOT_LOADED); \
249 }
250 HBA_LIBRARY_INFO *_hbaapi_librarylist = NULL;
251 HBA_UINT32 _hbaapi_total_library_count = 0;
252 #ifdef POSIX_THREADS
253 pthread_mutex_t _hbaapi_LL_mutex = PTHREAD_MUTEX_INITIALIZER;
254 #elif defined(WIN32)
255 CRITICAL_SECTION _hbaapi_LL_mutex;
256 #endif
257
258 /*
259 * Macro to use the right function table between smhba and hbaapi.
260 */
261 #define FUNCTABLE(lib_infop) \
262 ((lib_infop->version == SMHBA) ? \
263 lib_infop->ftable.smhbafunctionTable : \
264 lib_infop->ftable.functionTable);
265
266 /*
267 * Macro to use the right function ptr between smhba and hbaapi function table.
268 * Should be used for an interface common to SM-HBA and HBAAPIV2.
269 */
270 #define FUNCCOMMON(lib_infop, func) \
271 ((lib_infop->version == SMHBA) ? \
272 lib_infop->ftable.smhbafunctionTable.func : \
273 lib_infop->ftable.functionTable.func)
274
275 /*
276 * Macro to use the hbaapi function ptr.
277 * Should be used for an interface applicable only HBAAPIV2.
278 */
279 #define FUNCHBAAPIV2(lib_infop, func) \
280 lib_infop->ftable.functionTable.func
281
282 /*
283 * Macro to use the hbaapi function ptr.
284 * Should be used for an interface applicable only HBAAPIV2.
285 */
286 #define FUNCSMHBA(lib_infop, func) \
287 lib_infop->ftable.smhbafunctionTable.func
288
289 /*
290 * Individual adapter (hba) information
291 */
292 typedef struct hba_adapter_info {
293 struct hba_adapter_info
294 *next;
295 HBA_STATUS GNstatus; /* status from GetAdapterNameFunc */
296 char *name;
297 HBA_WWN nodeWWN;
298 HBA_LIBRARY_INFO *library;
299 HBA_UINT32 index;
300 } HBA_ADAPTER_INFO;
301
302 HBA_ADAPTER_INFO *_hbaapi_adapterlist = NULL;
303 HBA_UINT32 _hbaapi_total_adapter_count = 0;
304 #ifdef POSIX_THREADS
305 pthread_mutex_t _hbaapi_AL_mutex = PTHREAD_MUTEX_INITIALIZER;
306 #elif defined(WIN32)
307 CRITICAL_SECTION _hbaapi_AL_mutex;
308 #endif
309
310 /*
311 * Call back registration
312 */
313 typedef struct hba_vendorcallback_elem {
314 struct hba_vendorcallback_elem
315 *next;
316 HBA_CALLBACKHANDLE vendorcbhandle;
317 HBA_LIBRARY_INFO *lib_info;
318 } HBA_VENDORCALLBACK_ELEM;
319
320 /*
321 * Each instance of HBA_ADAPTERCALLBACK_ELEM represents a call to one of
322 * "register" functions that apply to a particular adapter.
323 * HBA_ALLADAPTERSCALLBACK_ELEM is used just for HBA_RegisterForAdapterAddEvents
324 */
325 typedef struct hba_adaptercallback_elem {
326 struct hba_adaptercallback_elem
327 *next;
328 HBA_LIBRARY_INFO *lib_info;
329 void *userdata;
330 HBA_CALLBACKHANDLE vendorcbhandle;
331 void (*callback)();
332 } HBA_ADAPTERCALLBACK_ELEM;
333
334 typedef struct hba_alladapterscallback_elem {
335 struct hba_alladapterscallback_elem
336 *next;
337 void *userdata;
338 HBA_VENDORCALLBACK_ELEM *vendorhandlelist;
339 void (*callback)();
340 } HBA_ALLADAPTERSCALLBACK_ELEM;
341
342 HBA_ALLADAPTERSCALLBACK_ELEM *_hbaapi_adapteraddevents_callback_list = NULL;
343 HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterevents_callback_list = NULL;
344 HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterportevents_callback_list = NULL;
345 HBA_ADAPTERCALLBACK_ELEM *_hbaapi_adapterportstatevents_callback_list = NULL;
346 HBA_ADAPTERCALLBACK_ELEM *_hbaapi_targetevents_callback_list = NULL;
347 HBA_ADAPTERCALLBACK_ELEM *_hbaapi_linkevents_callback_list = NULL;
348
349 HBA_ALLADAPTERSCALLBACK_ELEM *_smhba_adapteraddevents_callback_list = NULL;
350 HBA_ADAPTERCALLBACK_ELEM *_smhba_adapterevents_callback_list = NULL;
351 HBA_ADAPTERCALLBACK_ELEM *_smhba_adapterportevents_callback_list = NULL;
352 HBA_ADAPTERCALLBACK_ELEM *_smhba_adapterportstatevents_callback_list = NULL;
353 HBA_ADAPTERCALLBACK_ELEM *_smhba_adapterphystatevents_callback_list = NULL;
354 HBA_ADAPTERCALLBACK_ELEM *_smhba_targetevents_callback_list = NULL;
355
356 #ifdef POSIX_THREADS
357 /* mutex's to protect each list */
358 pthread_mutex_t _hbaapi_AAE_mutex = PTHREAD_MUTEX_INITIALIZER;
359 pthread_mutex_t _hbaapi_AE_mutex = PTHREAD_MUTEX_INITIALIZER;
360 pthread_mutex_t _hbaapi_APE_mutex = PTHREAD_MUTEX_INITIALIZER;
361 pthread_mutex_t _hbaapi_APSE_mutex = PTHREAD_MUTEX_INITIALIZER;
362 pthread_mutex_t _hbaapi_TE_mutex = PTHREAD_MUTEX_INITIALIZER;
363 pthread_mutex_t _hbaapi_LE_mutex = PTHREAD_MUTEX_INITIALIZER;
364 pthread_mutex_t _smhba_AAE_mutex = PTHREAD_MUTEX_INITIALIZER;
365 pthread_mutex_t _smhba_AE_mutex = PTHREAD_MUTEX_INITIALIZER;
366 pthread_mutex_t _smhba_APE_mutex = PTHREAD_MUTEX_INITIALIZER;
367 pthread_mutex_t _smhba_APSE_mutex = PTHREAD_MUTEX_INITIALIZER;
368 pthread_mutex_t _smhba_APHYSE_mutex = PTHREAD_MUTEX_INITIALIZER;
369 pthread_mutex_t _smhba_TE_mutex = PTHREAD_MUTEX_INITIALIZER;
370 pthread_mutex_t _smhba_LE_mutex = PTHREAD_MUTEX_INITIALIZER;
371 #elif defined(WIN32)
372 CRITICAL_SECTION _hbaapi_AAE_mutex;
373 CRITICAL_SECTION _hbaapi_AE_mutex;
374 CRITICAL_SECTION _hbaapi_APE_mutex;
375 CRITICAL_SECTION _hbaapi_APSE_mutex;
376 CRITICAL_SECTION _hbaapi_TE_mutex;
377 CRITICAL_SECTION _smhba_AAE_mutex;
378 CRITICAL_SECTION _smhba_AE_mutex;
379 CRITICAL_SECTION _smhba_APE_mutex;
380 CRITICAL_SECTION _smhba_APSE_mutex;
381 CRITICAL_SECTION _smhba_APHYSE_mutex;
382 CRITICAL_SECTION _smhba_TE_mutex;
383 CRITICAL_SECTION _hbaapi_LE_mutex;
384 #endif
385
386 HBA_ADAPTERCALLBACK_ELEM **cb_lists_array[] = {
387 &_hbaapi_adapterevents_callback_list,
388 &_hbaapi_adapterportevents_callback_list,
389 &_hbaapi_adapterportstatevents_callback_list,
390 &_hbaapi_targetevents_callback_list,
391 &_hbaapi_linkevents_callback_list,
392 &_smhba_adapterevents_callback_list,
393 &_smhba_adapterportevents_callback_list,
394 &_smhba_adapterportstatevents_callback_list,
395 &_smhba_adapterphystatevents_callback_list,
396 &_smhba_targetevents_callback_list,
397 NULL};
398
399 /*
400 * Common library internal. Mutex handling
401 */
402 #ifdef POSIX_THREADS
403 static void
404 grab_mutex(pthread_mutex_t *mp) {
405 /* LINTED E_FUNC_SET_NOT_USED */
406 int ret;
407 if ((ret = pthread_mutex_lock(mp)) != 0) {
408 perror("pthread_mutex_lock - HBAAPI:");
409 DEBUG(1, "pthread_mutex_lock returned %d", ret, 0, 0);
410 }
411 }
412
413 static void
414 release_mutex(pthread_mutex_t *mp) {
415 /* LINTED E_FUNC_SET_NOT_USED */
416 int ret;
417 if ((ret = pthread_mutex_unlock(mp)) != 0) {
418 perror("pthread_mutex_unlock - HBAAPI:");
419 DEBUG(1, "pthread_mutex_unlock returned %d", ret, 0, 0);
420 }
421 }
422 #endif
423
424 /*
425 * Common library internal. Check library and return vendorhandle
426 */
427 static HBA_STATUS
428 HBA_CheckLibrary(HBA_HANDLE handle,
429 HBA_LIBRARY_INFO **lib_infopp,
430 HBA_HANDLE *vendorhandle) {
431
432 HBA_UINT32 libraryIndex;
433 HBA_LIBRARY_INFO *lib_infop;
434
435 if (_hbaapi_librarylist == NULL) {
436 return (HBA_STATUS_ERROR);
437 }
438 libraryIndex = LIBRARY_NUM(handle);
439
440 GRAB_MUTEX(&_hbaapi_LL_mutex);
441 for (lib_infop = _hbaapi_librarylist;
442 lib_infop != NULL;
443 lib_infop = lib_infop->next) {
444 if (lib_infop->index == libraryIndex) {
445 if (lib_infop->status != HBA_LIBRARY_LOADED) {
446 return (HBA_STATUS_ERROR);
447 }
448 *lib_infopp = lib_infop;
449 *vendorhandle = VENDOR_HANDLE(handle);
450 /* caller will release the mutex */
451 return (HBA_STATUS_OK);
452 }
453 }
454 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INVALID_HANDLE);
455 }
456 #define CHECKLIBRARY() \
457 status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);\
458 if (status != HBA_STATUS_OK) { \
459 return (status); \
460 }
461
462 #define CHECKLIBRARYANDVERSION(ver) \
463 status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle); \
464 if (status != HBA_STATUS_OK) { \
465 return (status); \
466 } else { \
467 if (ver != lib_infop->version) { \
468 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, \
469 HBA_STATUS_ERROR_INCOMPATIBLE); \
470 } \
471 }
472
473 /*
474 * freevendorhandlelist is called with _hbaapi_LL_mutex already held
475 */
476 static void
477 freevendorhandlelist(HBA_VENDORCALLBACK_ELEM *vhlist) {
478 HBA_VENDORCALLBACK_ELEM *vhlp;
479 HBA_VENDORCALLBACK_ELEM *vnext;
480 HBARemoveCallbackFunc registeredfunc;
481
482 for (vhlp = vhlist; vhlp != NULL; vhlp = vnext) {
483 vnext = vhlp->next;
484 registeredfunc =
485 FUNCCOMMON(vhlp->lib_info, RemoveCallbackHandler);
486 if (registeredfunc == NULL) {
487 continue;
488 }
489 (registeredfunc)(vhlp->vendorcbhandle);
490 free(vhlp);
491 }
492 }
493
494 static
495 HBA_STATUS
496 local_remove_callback(HBA_CALLBACKHANDLE cbhandle) {
497 HBA_ADAPTERCALLBACK_ELEM ***listp;
498 HBA_ADAPTERCALLBACK_ELEM **lastp;
499 HBA_ALLADAPTERSCALLBACK_ELEM **lap;
500 HBA_ALLADAPTERSCALLBACK_ELEM *allcbp;
501 HBA_ADAPTERCALLBACK_ELEM *cbp;
502 HBARemoveCallbackFunc registeredfunc;
503 HBA_VENDORCALLBACK_ELEM *vhlp;
504 HBA_VENDORCALLBACK_ELEM *vnext;
505 int found;
506 HBA_STATUS status = HBA_STATUS_ERROR_INVALID_HANDLE;
507
508
509 /* search through the simple lists first */
510 GRAB_MUTEX(&_hbaapi_AAE_mutex);
511 GRAB_MUTEX(&_hbaapi_AE_mutex);
512 GRAB_MUTEX(&_hbaapi_APE_mutex);
513 GRAB_MUTEX(&_hbaapi_APSE_mutex);
514 GRAB_MUTEX(&_hbaapi_TE_mutex);
515 GRAB_MUTEX(&_hbaapi_LE_mutex);
516 GRAB_MUTEX(&_smhba_AAE_mutex);
517 GRAB_MUTEX(&_smhba_AE_mutex);
518 GRAB_MUTEX(&_smhba_APE_mutex);
519 GRAB_MUTEX(&_smhba_APSE_mutex);
520 GRAB_MUTEX(&_smhba_TE_mutex);
521 for (listp = cb_lists_array, found = 0;
522 (found == 0 && *listp != NULL); listp++) {
523 lastp = *listp;
524 for (cbp = **listp; cbp != NULL; cbp = cbp->next) {
525 if (cbhandle != (HBA_CALLBACKHANDLE)cbp) {
526 lastp = &(cbp->next);
527 continue;
528 }
529 found = 1;
530 registeredfunc =
531 FUNCCOMMON(cbp->lib_info, RemoveCallbackHandler);
532 if (registeredfunc == NULL) {
533 break;
534 }
535 (registeredfunc)(cbp->vendorcbhandle);
536 *lastp = cbp->next;
537 free(cbp);
538 break;
539 }
540 }
541 RELEASE_MUTEX(&_hbaapi_LE_mutex);
542 RELEASE_MUTEX(&_hbaapi_TE_mutex);
543 RELEASE_MUTEX(&_hbaapi_APSE_mutex);
544 RELEASE_MUTEX(&_hbaapi_APE_mutex);
545 RELEASE_MUTEX(&_hbaapi_AE_mutex);
546 RELEASE_MUTEX(&_hbaapi_AAE_mutex);
547 RELEASE_MUTEX(&_smhba_AAE_mutex);
548 RELEASE_MUTEX(&_smhba_AE_mutex);
549 RELEASE_MUTEX(&_smhba_APE_mutex);
550 RELEASE_MUTEX(&_smhba_APSE_mutex);
551 RELEASE_MUTEX(&_smhba_TE_mutex);
552
553 if (found != 0) {
554 if (registeredfunc == NULL) {
555 return (HBA_STATUS_ERROR_NOT_SUPPORTED);
556 }
557 return (HBA_STATUS_OK);
558 }
559
560 GRAB_MUTEX(&_hbaapi_AAE_mutex);
561 /*
562 * if it wasnt in the simple lists,
563 * look in the list for adapteraddevents
564 */
565 lap = &_hbaapi_adapteraddevents_callback_list;
566 for (allcbp = _hbaapi_adapteraddevents_callback_list;
567 allcbp != NULL;
568 allcbp = allcbp->next) {
569 if (cbhandle != (HBA_CALLBACKHANDLE)allcbp) {
570 lap = &allcbp->next;
571 continue;
572 }
573 for (vhlp = allcbp->vendorhandlelist; vhlp != NULL; vhlp = vnext) {
574 vnext = vhlp->next;
575 /* should be HBAAPIV2 VSL to get to here */
576 registeredfunc =
577 vhlp->lib_info->ftable.functionTable.RemoveCallbackHandler;
578 if (registeredfunc == NULL) {
579 continue;
580 }
581 (registeredfunc)(vhlp->vendorcbhandle);
582 free(vhlp);
583 }
584 *lap = allcbp->next;
585 free(allcbp);
586 status = HBA_STATUS_OK;
587 break;
588 }
589 RELEASE_MUTEX(&_hbaapi_AAE_mutex);
590
591 /* now search smhba adapteradd events. */
592 GRAB_MUTEX(&_smhba_AAE_mutex);
593 lap = &_smhba_adapteraddevents_callback_list;
594 for (allcbp = _smhba_adapteraddevents_callback_list;
595 allcbp != NULL;
596 allcbp = allcbp->next) {
597 if (cbhandle != (HBA_CALLBACKHANDLE)allcbp) {
598 lap = &allcbp->next;
599 continue;
600 }
601 for (vhlp = allcbp->vendorhandlelist; vhlp != NULL; vhlp = vnext) {
602 vnext = vhlp->next;
603 /* should be SMHBA VSL to get to here */
604 registeredfunc =
605 vhlp->lib_info->
606 ftable.smhbafunctionTable.RemoveCallbackHandler;
607 if (registeredfunc == NULL) {
608 continue;
609 }
610 (registeredfunc)(vhlp->vendorcbhandle);
611 free(vhlp);
612 }
613 *lap = allcbp->next;
614 free(allcbp);
615 status = HBA_STATUS_OK;
616 break;
617 }
618 RELEASE_MUTEX(&_smhba_AAE_mutex);
619
620 return (status);
621 }
622
623 /* LINTED E_STATIC_UE_STATIC_UNUSED */
624 static char wwn_str1[17];
625 /* LINTED E_STATIC_UE_STATIC_UNUSED */
626 static char wwn_str2[17];
627 /* LINTED E_STATIC_UE_STATIC_UNUSED */
628 static char wwn_str3[17];
629 #define WWN2STR1(wwn) WWN2str(wwn_str1, (wwn))
630 #define WWN2STR2(wwn) WWN2str(wwn_str2, (wwn))
631 #define WWN2STR3(wwn) WWN2str(wwn_str3, (wwn))
632 static char *
633 /* LINTED E_STATIC_UE_STATIC_UNUSED */
634 WWN2str(char *buf, HBA_WWN *wwn) {
635 int j;
636 unsigned char *pc = (unsigned char *)&(wwn->wwn[0]);
637 buf[0] = '\0';
638 for (j = 0; j < 16; j += 2) {
639 (void) sprintf(&buf[j], "%02X", (int)*pc++);
640 }
641 return (buf);
642 }
643
644 #ifdef WIN32
645 BOOL APIENTRY
646 DllMain(HANDLE hModule,
647 DWORD ul_reason_for_call,
648 LPVOID lpReserved)
649 {
650 switch (ul_reason_for_call) {
651 case DLL_PROCESS_ATTACH:
652 break;
653 case DLL_PROCESS_DETACH:
654 break;
655 case DLL_THREAD_ATTACH:
656 case DLL_THREAD_DETACH:
657 break;
658 }
659 return (TRUE);
660 }
661 #endif
662
663 /*
664 * Read in the config file and load all the specified vendor specific
665 * libraries and perform the function registration exercise
666 */
667 HBA_STATUS
668 HBA_LoadLibrary()
669 {
670 HBARegisterLibraryFunc RegisterFunc;
671 HBARegisterLibraryV2Func RegisterV2Func;
672 SMHBARegisterLibraryFunc RegisterSMHBAFunc;
673 HBALoadLibraryFunc LoadLibraryFunc;
674 HBAGetVersionFunc GetVersionFunc;
675 #ifdef POSIX_THREADS
676 int ret;
677 #endif
678 HBA_STATUS status;
679 HBA_UINT32 libversion;
680
681 /* Open configuration file from known location */
682 #ifdef WIN32
683 LONG lStatus;
684 HKEY hkSniaHba, hkVendorLib;
685 FILETIME ftLastWriteTime;
686 TCHAR cSubKeyName[256];
687 DWORD i, dwSize, dwType;
688 BYTE byFileName[MAX_PATH];
689 HBA_LIBRARY_INFO *lib_infop;
690
691 if (_hbaapi_librarylist != NULL) {
692 /* this is an app programming error */
693 return (HBA_STATUS_ERROR);
694 }
695
696 lStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\SNIA\\HBA",
697 0, KEY_READ, &hkSniaHba);
698 if (lStatus != ERROR_SUCCESS) {
699 /* ???Opportunity to send error msg, configuration error */
700 return (HBA_STATUS_ERROR);
701 }
702 /*
703 * Enumerate all the subkeys. These have the form:
704 * HKLM\Software\SNIA\HBA\<Vendor id> - note that we don't care
705 * what the vendor id is
706 */
707 for (i = 0; ; i++) {
708 dwSize = 255; /* how big the buffer is */
709 lStatus = RegEnumKeyEx(hkSniaHba, i,
710 (char *)&cSubKeyName, &dwSize, NULL,
711 NULL, NULL, &ftLastWriteTime);
712 if (lStatus == ERROR_NO_MORE_ITEMS) {
713 break; /* we're done */
714 } else if (lStatus == ERROR_MORE_DATA) { /* buffer not big enough */
715 /* do whatever */
716 ;
717 }
718 /* Now open the subkey that pertains to this vendor's library */
719 lStatus = RegOpenKeyEx(hkSniaHba, cSubKeyName, 0, KEY_READ,
720 &hkVendorLib);
721 if (lStatus != ERROR_SUCCESS) {
722 RegCloseKey(hkSniaHba);
723 /* ???Opportunity to send error msg, installation error */
724 return (HBA_STATUS_ERROR);
725 /*
726 * you may want to return something
727 * else or keep trying
728 */
729 }
730 /*
731 * The name of the library is contained in a REG_SZ Value
732 * keyed to "LibraryFile"
733 */
734 dwSize = MAX_PATH;
735 lStatus = RegQueryValueEx(hkVendorLib, "LibraryFile", NULL, &dwType,
736 byFileName, &dwSize);
737 if (lStatus != ERROR_SUCCESS) {
738 RegCloseKey(hkVendorLib);
739 /* ???Opportunity to send error msg, installation error */
740 continue;
741 }
742 lib_infop = (HBA_LIBRARY_INFO *)calloc(1, sizeof (HBA_LIBRARY_INFO));
743 if (lib_infop == NULL) {
744 /* what is the right thing to do in MS land??? */
745 RegCloseKey(hkVendorLib);
746 /* ???Opportunity to send error msg, installation error */
747 return (HBA_STATUS_ERROR);
748 }
749 lib_infop->status = HBA_LIBRARY_NOT_LOADED;
750 lib_infop->next = _hbaapi_librarylist;
751 lib_infop->index = _hbaapi_total_library_count;
752 _hbaapi_total_library_count++;
753 _hbaapi_librarylist = lib_infop;
754
755 /* Now I can try to load the library */
756 lib_infop->hLibrary = LoadLibrary(byFileName);
757 if (lib_infop->hLibrary == NULL) {
758 /* printf("unable to load library %s\n", librarypath); */
759 /* ???Opportunity to send error msg, installation error */
760 goto dud_library;
761 }
762 lib_infop->LibraryPath = strdup(byFileName);
763 DEBUG(1, "HBAAPI loading: %s\n", byFileName, 0, 0);
764
765 RegisterSMHBAFunc = (SMHBARegisterLibraryFunc)
766 GetProcAddress(lib_infop->hLibrary, "SMHBA_RegisterLibrary");
767 if (RegisterSMHBAFunc != NULL) {
768 status = ((RegisterSMHBAFunc)(SMHBA_ENTRYPOINTS *)
769 (&lib_infop->ftable.smhbafunctionTable));
770 if (status != HBA_STATUS_OK) {
771 /* library not loaded */
772 /* ???Opportunity to send error msg, library error? */
773 goto dud_library;
774 } else {
775 lib_infop->version = SMHBA;
776 }
777 } else {
778 /* Call the registration function to get the list of pointers */
779 RegisterV2Func = (HBARegisterLibraryV2Func)GetProcAddress(
780 lib_infop->hLibrary, "HBA_RegisterLibraryV2");
781 if (RegisterV2Func != NULL) {
782 /*
783 * Load the function pointers directly into
784 * the table of functions
785 */
786 status = ((RegisterV2Func)
787 (HBA_ENTRYPOINTSV2 *)(&lib_infop->ftable.functionTable));
788 if (status != HBA_STATUS_OK) {
789 /* library not loaded */
790 /* ???Opportunity to send error msg, library error? */
791 goto dud_library;
792 } else {
793 lib_infop->version = HBAAPIV2;
794 }
795 } else {
796 /* Maybe the vendor library is only Rev1 */
797 RegisterFunc = (HBARegisterLibraryFunc)
798 GetProcAddress(lib_infop->hLibrary, "HBA_RegisterLibrary");
799 if (RegisterFunc == NULL) {
800 /* ???Opportunity to send error msg, library error? */
801 goto dud_library;
802 }
803 /*
804 * Load the function points directly into
805 * the Rev 2 table of functions
806 */
807 status = ((RegisterFunc)(
808 (HBA_ENTRYPOINTS *)(&lib_infop->ftable.functionTable)));
809 if (status != HBA_STATUS_OK) {
810 /* library not loaded */
811 /* ???Opportunity to send error msg, library error? */
812 goto dud_library;
813 } else {
814 lib_infop->version = HBAAPI;
815 }
816 }
817 }
818
819 /* successfully loaded library */
820 /*
821 * SM-HBA and HBAAPI has a seperate handler for GetVersion but
822 * they have the same function signature so use the same variable here.
823 */
824 GetVersionFunc = FUNCCOMMON(lib_infop, GetVersionHandler);
825 if (GetVersionFunc != NULL) {
826 if (lib_infop->version == SMHBA) {
827 /* Check the version of this library before loading */
828 libversion = ((GetVersionFunc)());
829 #ifdef NOTDEF /* save for a later time... when it matters */
830 if (libversion < SMHBA_LIBVERSION) {
831 goto dud_library;
832 }
833 #endif
834 } else {
835 /* Check the version of this library before loading */
836 /* Actually... This wrapper is compatible with version 1 */
837 libversion = ((GetVersionFunc)());
838 #ifdef NOTDEF /* save for a later time... when it matters */
839 if (libversion < HBA_LIBVERSION) {
840 goto dud_library;
841 }
842 #endif
843 }
844 } else {
845 /* ???Opportunity to send error msg, library error? */
846 goto dud_library;
847 }
848
849 LoadLibraryFunc = FUNCCOMMON(lib_infop, LoadLibraryHandler);
850 if (LoadLibraryFunc == NULL) {
851 /* Hmmm, dont we need to flag this in a realy big way??? */
852 /* How about messages to the system event logger ??? */
853 /* ???Opportunity to send error msg, library error? */
854 goto dud_library;
855 }
856 /* Initialize this library */
857 status = ((LoadLibraryFunc)());
858 if (status != HBA_STATUS_OK) {
859 /* ???Opportunity to send error msg, library error? */
860 continue;
861 }
862 /* successfully loaded library */
863 lib_infop->status = HBA_LIBRARY_LOADED;
864
865 dud_library: /* its also just the end of the loop */
866 RegCloseKey(hkVendorLib);
867 }
868 RegCloseKey(hkSniaHba);
869
870 #else /* Unix as opposed to Win32 */
871 FILE *hbaconf;
872 char fullline[512]; /* line read from HBA.conf */
873 char *libraryname; /* Read in from file HBA.conf */
874 char *librarypath; /* Read in from file HBA.conf */
875 char hbaConfFilePath[256];
876 char *charPtr;
877 HBA_LIBRARY_INFO *lib_infop;
878
879 GRAB_MUTEX(&_hbaapi_LL_mutex);
880 if (_hbaapi_librarylist != NULL) {
881 (void) fprintf(stderr,
882 "HBA_LoadLibrary: previously unfreed "
883 "libraries exist, call HBA_FreeLibrary().\n");
884 RELEASE_MUTEX(&_hbaapi_LL_mutex);
885 return (HBA_STATUS_ERROR);
886 }
887
888 (void) strcpy(hbaConfFilePath, "/etc/smhba.conf");
889
890 if ((hbaconf = fopen(hbaConfFilePath, "r")) == NULL) {
891 (void) printf("Cannot open %s\n", hbaConfFilePath);
892 RELEASE_MUTEX(&_hbaapi_LL_mutex);
893 return (HBA_STATUS_ERROR);
894 }
895
896 /* Read in each line and load library */
897 while ((hbaconf != NULL) &&
898 (fgets(fullline, sizeof (fullline), hbaconf))) {
899 /* Skip the comments... */
900 if ((fullline[0] == '#') || (fullline[0] == '\n')) {
901 continue;
902 }
903
904 /* grab first 'thing' in line (if its there) */
905 if ((libraryname = strtok(fullline, " \t\n")) != NULL) {
906 if (strlen(libraryname) >= 64) {
907 (void) fprintf(stderr,
908 "Library name(%s) in %s is > 64 characters\n",
909 libraryname, hbaConfFilePath);
910 }
911 }
912 /* grab second 'thing' in line (if its there) */
913 if ((librarypath = strtok(NULL, " \t\n")) != NULL) {
914 if (strlen(librarypath) >= 256) {
915 (void) fprintf(stderr,
916 "Library path(%s) in %s is > 256 characters\n",
917 librarypath, hbaConfFilePath);
918 }
919 }
920
921 /* there should be no more 'things' in the line */
922 if ((charPtr = strtok(NULL, " \n\t")) != NULL) {
923 (void) fprintf(stderr, "Extraneous characters (\"%s\") in %s\n",
924 charPtr, hbaConfFilePath);
925 }
926
927 /* Continue to the next line if library name or path is invalid */
928 if (libraryname == NULL ||
929 strlen(libraryname) == 0 ||
930 librarypath == NULL ||
931 (strlen(librarypath) == 0)) {
932 continue;
933 }
934
935 /*
936 * Special case....
937 * Look for loglevel
938 */
939 if (strcmp(libraryname, "debuglevel") == 0) {
940 _hbaapi_debuglevel = strtol(librarypath, NULL, 10);
941 /* error handling does the right thing automagically */
942 continue;
943 }
944
945 lib_infop = (HBA_LIBRARY_INFO *)calloc(1, sizeof (HBA_LIBRARY_INFO));
946 if (lib_infop == NULL) {
947 (void) fprintf(stderr, "HBA_LoadLibrary: out of memeory\n");
948 RELEASE_MUTEX(&_hbaapi_LL_mutex);
949 return (HBA_STATUS_ERROR);
950 }
951 lib_infop->status = HBA_LIBRARY_NOT_LOADED;
952 lib_infop->LibraryName = strdup(libraryname);
953 lib_infop->LibraryPath = strdup(librarypath);
954 lib_infop->numOfAdapters = 0;
955 lib_infop->version = UNKNOWN;
956 lib_infop->index = _hbaapi_total_library_count;
957 _hbaapi_total_library_count++;
958 lib_infop->next = _hbaapi_librarylist;
959 _hbaapi_librarylist = lib_infop;
960
961 /* Load the DLL now */
962 if ((lib_infop->hLibrary = dlopen(librarypath, RTLD_LAZY)) == NULL) {
963 /* printf("unable to load library %s\n", librarypath); */
964 continue;
965 }
966 /* Call the registration function to get the list of pointers */
967 RegisterSMHBAFunc = (SMHBARegisterLibraryFunc)
968 dlsym(lib_infop->hLibrary, "SMHBA_RegisterLibrary");
969 if (RegisterSMHBAFunc != NULL) {
970 /*
971 * Load the function points directly into
972 * the table of functions
973 */
974 status = ((RegisterSMHBAFunc)
975 (&lib_infop->ftable.smhbafunctionTable));
976 if (status != HBA_STATUS_OK) {
977 /* library not loaded */
978 continue;
979 } else {
980 lib_infop->version = SMHBA;
981 }
982 } else {
983 RegisterV2Func = (HBARegisterLibraryV2Func)
984 dlsym(lib_infop->hLibrary, "HBA_RegisterLibraryV2");
985 if (RegisterV2Func != NULL) {
986 /*
987 * Load the function points directly into
988 * the table of functions
989 */
990 status = ((RegisterV2Func)((HBA_ENTRYPOINTSV2 *)
991 (&lib_infop->ftable.functionTable)));
992 if (status != HBA_STATUS_OK) {
993 /* library not loaded */
994 continue;
995 } else {
996 lib_infop->version = HBAAPIV2;
997 }
998 } else {
999 /* Maybe the vendor library is only Rev1 */
1000 RegisterFunc = (HBARegisterLibraryFunc)
1001 dlsym(lib_infop->hLibrary, "HBA_RegisterLibrary");
1002 if (RegisterFunc == NULL) {
1003 /* This function is required */
1004 (void) fprintf(stderr,
1005 "HBA_LoadLibrary: vendor specific RegisterLibrary "
1006 "function not found. lib: %s\n", librarypath);
1007 DEBUG(1, "HBA_LoadLibrary: vendor specific "
1008 "RegisterLibrary function not found. lib: %s\n",
1009 librarypath, 0, 0);
1010 continue;
1011 }
1012 /*
1013 * Load the function points directly into
1014 * the table of functions
1015 */
1016 status = ((RegisterFunc)
1017 ((HBA_ENTRYPOINTS *)(&lib_infop->ftable.functionTable)));
1018 if (status != HBA_STATUS_OK) {
1019 /* library not loaded */
1020 (void) fprintf(stderr,
1021 "HBA_LoadLibrary: vendor specific RegisterLibrary "
1022 "function encountered an error. lib: %s\n",
1023 librarypath);
1024 DEBUG(1,
1025 "HBA_LoadLibrary: vendor specific RegisterLibrary "
1026 "function encountered an error. lib: %s\n",
1027 librarypath, 0, 0);
1028 continue;
1029 } else {
1030 lib_infop->version = HBAAPI;
1031 }
1032 }
1033 }
1034
1035 /* successfully loaded library */
1036 /*
1037 * SM-HBA and HBAAPI has a seperate handler for GetVersion but
1038 * they have the same function signature so use the same variable here.
1039 */
1040 if ((GetVersionFunc = FUNCCOMMON(lib_infop, GetVersionHandler))
1041 == NULL) {
1042 continue;
1043 }
1044 if (lib_infop->version == SMHBA) {
1045 libversion = ((GetVersionFunc)());
1046 if (libversion < SMHBA_LIBVERSION) {
1047 (void) printf("Library version mismatch."
1048 "Got %d expected %d.\n",
1049 libversion, SMHBA_LIBVERSION);
1050 continue;
1051 }
1052 } else {
1053 libversion = ((GetVersionFunc)());
1054 /* Check the version of this library before loading */
1055 /* Actually... This wrapper is compatible with version 1 */
1056 if (libversion < HBA_LIBVERSION) {
1057 (void) printf("Library version mismatch."
1058 "Got %d expected %d.\n",
1059 libversion, HBA_LIBVERSION);
1060 continue;
1061 }
1062 }
1063
1064 DEBUG(1, "%s libversion = %d", librarypath, libversion, 0);
1065 LoadLibraryFunc = FUNCCOMMON(lib_infop, LoadLibraryHandler);
1066 if (LoadLibraryFunc == NULL) {
1067 /* this function is required */
1068 (void) fprintf(stderr,
1069 "HBA_LoadLibrary: vendor specific LoadLibrary "
1070 "function not found. lib: %s\n", librarypath);
1071 DEBUG(1, "HBA_LoadLibrary: vendor specific LoadLibrary "
1072 "function not found. lib: %s\n", librarypath, 0, 0);
1073 continue;
1074 }
1075 /* Initialize this library */
1076 if ((status = ((LoadLibraryFunc)())) != HBA_STATUS_OK) {
1077 /* maybe this should be a printf so that we CANNOT miss it */
1078 (void) fprintf(stderr,
1079 "HBA_LoadLibrary: Encounterd and error loading: %s",
1080 librarypath);
1081 DEBUG(1, "Encounterd and error loading: %s", librarypath, 0, 0);
1082 DEBUG(1, " HBA_STATUS: %d", status, 0, 0);
1083 continue;
1084 }
1085 /* successfully loaded library */
1086 lib_infop->status = HBA_LIBRARY_LOADED;
1087 }
1088 #endif /* WIN32 or UNIX */
1089 #ifdef POSIX_THREADS
1090 /*
1091 * The _hbaapi_LL_mutex is already grabbed to proctect the caller of
1092 * HBA_FreeLibrary() during loading.
1093 * The mutexes are already initialized
1094 * with PTHREAD_MUTEX_INITIALIZER. Do we need to init again?
1095 * Keeping the code from HBAAPI source...
1096 */
1097 ret = pthread_mutex_init(&_hbaapi_AL_mutex, NULL);
1098 if (ret == 0) {
1099 ret = pthread_mutex_init(&_hbaapi_AAE_mutex, NULL);
1100 }
1101 if (ret == 0) {
1102 ret = pthread_mutex_init(&_hbaapi_AE_mutex, NULL);
1103 }
1104 if (ret == 0) {
1105 ret = pthread_mutex_init(&_hbaapi_APE_mutex, NULL);
1106 }
1107 if (ret == 0) {
1108 ret = pthread_mutex_init(&_hbaapi_APSE_mutex, NULL);
1109 }
1110 if (ret == 0) {
1111 ret = pthread_mutex_init(&_hbaapi_TE_mutex, NULL);
1112 }
1113 if (ret == 0) {
1114 ret = pthread_mutex_init(&_smhba_AAE_mutex, NULL);
1115 }
1116 if (ret == 0) {
1117 ret = pthread_mutex_init(&_smhba_AE_mutex, NULL);
1118 }
1119 if (ret == 0) {
1120 ret = pthread_mutex_init(&_smhba_APE_mutex, NULL);
1121 }
1122 if (ret == 0) {
1123 ret = pthread_mutex_init(&_smhba_APSE_mutex, NULL);
1124 }
1125 if (ret == 0) {
1126 ret = pthread_mutex_init(&_smhba_TE_mutex, NULL);
1127 }
1128 if (ret == 0) {
1129 ret = pthread_mutex_init(&_hbaapi_LE_mutex, NULL);
1130 }
1131 if (ret != 0) {
1132 perror("pthread_mutex_init - HBA_LoadLibrary");
1133 RELEASE_MUTEX(&_hbaapi_LL_mutex);
1134 return (HBA_STATUS_ERROR);
1135 }
1136 RELEASE_MUTEX(&_hbaapi_LL_mutex);
1137 #elif defined(WIN32)
1138 InitializeCriticalSection(&_hbaapi_LL_mutex);
1139 InitializeCriticalSection(&_hbaapi_AL_mutex);
1140 InitializeCriticalSection(&_hbaapi_AAE_mutex);
1141 InitializeCriticalSection(&_hbaapi_AE_mutex);
1142 InitializeCriticalSection(&_hbaapi_APE_mutex);
1143 InitializeCriticalSection(&_hbaapi_APSE_mutex);
1144 InitializeCriticalSection(&_hbaapi_TE_mutex);
1145 InitializeCriticalSection(&_hbaapi_LE_mutex);
1146 InitializeCriticalSection(&_smhba_AAE_mutex);
1147 InitializeCriticalSection(&_smhba_AE_mutex);
1148 InitializeCriticalSection(&_smhba_APE_mutex);
1149 InitializeCriticalSection(&_smhba_APSE_mutex);
1150 InitializeCriticalSection(&_smhba_TE_mutex);
1151 #endif
1152
1153 return (HBA_STATUS_OK);
1154 }
1155
1156 HBA_STATUS
1157 HBA_FreeLibrary() {
1158 HBAFreeLibraryFunc FreeLibraryFunc;
1159 /* LINTED E_FUNC_SET_NOT_USED */
1160 HBA_STATUS status;
1161 HBA_LIBRARY_INFO *lib_infop;
1162 HBA_LIBRARY_INFO *lib_next;
1163 HBA_ADAPTERCALLBACK_ELEM
1164 ***listp;
1165 HBA_ADAPTER_INFO *adapt_infop;
1166 HBA_ADAPTER_INFO *adapt_next;
1167
1168 GRAB_MUTEX(&_hbaapi_LL_mutex);
1169 if (_hbaapi_librarylist == NULL) {
1170 RELEASE_MUTEX(&_hbaapi_LL_mutex);
1171 return (HBA_STATUS_ERROR_NOT_LOADED);
1172 }
1173
1174 GRAB_MUTEX(&_hbaapi_AL_mutex);
1175
1176 DEBUG(1, "HBA_FreeLibrary()", 0, 0, 0);
1177 for (lib_infop = _hbaapi_librarylist; lib_infop != NULL;
1178 lib_infop = lib_next) {
1179 lib_next = lib_infop->next;
1180 if (lib_infop->status == HBA_LIBRARY_LOADED) {
1181 FreeLibraryFunc = FUNCCOMMON(lib_infop, FreeLibraryHandler);
1182 if (FreeLibraryFunc != NULL) {
1183 /* Free this library */
1184 status = ((FreeLibraryFunc)());
1185 DEBUG(1, "HBA_FreeLibrary() Failed %d", status, 0, 0);
1186 }
1187 #ifdef WIN32
1188 FreeLibrary(lib_infop->hLibrary); /* Unload DLL from memory */
1189 #else
1190 (void) dlclose(lib_infop->hLibrary); /* Unload DLL from memory */
1191 #endif
1192 }
1193 #ifndef WIN32
1194 free(lib_infop->LibraryName);
1195 #endif
1196 free(lib_infop->LibraryPath);
1197 free(lib_infop);
1198
1199 }
1200 _hbaapi_librarylist = NULL;
1201 /*
1202 * OK, now all functions are disabled except for LoadLibrary,
1203 * Hope no other thread calls it before we have returned
1204 */
1205 _hbaapi_total_library_count = 0;
1206
1207 for (adapt_infop = _hbaapi_adapterlist;
1208 adapt_infop != NULL;
1209 adapt_infop = adapt_next) {
1210 adapt_next = adapt_infop->next;
1211 free(adapt_infop->name);
1212 free(adapt_infop);
1213 }
1214 _hbaapi_adapterlist = NULL;
1215 _hbaapi_total_adapter_count = 0;
1216
1217 /*
1218 * Free up the callbacks, this is not the most efficient, but it works
1219 */
1220 while ((volatile HBA_ADAPTERCALLBACK_ELEM *)
1221 _hbaapi_adapteraddevents_callback_list
1222 != NULL) {
1223 (void) local_remove_callback((HBA_CALLBACKHANDLE)
1224 _hbaapi_adapteraddevents_callback_list);
1225 }
1226 while ((volatile HBA_ADAPTERCALLBACK_ELEM *)
1227 _smhba_adapteraddevents_callback_list
1228 != NULL) {
1229 (void) local_remove_callback((HBA_CALLBACKHANDLE)
1230 _smhba_adapteraddevents_callback_list);
1231 }
1232 for (listp = cb_lists_array; *listp != NULL; listp++) {
1233 while ((volatile HBA_ADAPTERCALLBACK_ELEM ***)**listp != NULL) {
1234 (void) local_remove_callback((HBA_CALLBACKHANDLE)**listp);
1235 }
1236 }
1237
1238 RELEASE_MUTEX(&_hbaapi_AL_mutex);
1239 RELEASE_MUTEX(&_hbaapi_LL_mutex);
1240
1241 #ifdef USESYSLOG
1242 closelog();
1243 #endif
1244 #ifdef USELOGFILE
1245 if (_hbaapi_debug_fd != NULL) {
1246 fclose(_hbaapi_debug_fd);
1247 }
1248 _hbaapi_debug_fd = NULL;
1249 #endif
1250 #ifdef POSIX_THREADS
1251 /* this will unlock them as well, but who cares */
1252 (void) pthread_mutex_destroy(&_hbaapi_LE_mutex);
1253 (void) pthread_mutex_destroy(&_hbaapi_TE_mutex);
1254 (void) pthread_mutex_destroy(&_hbaapi_APSE_mutex);
1255 (void) pthread_mutex_destroy(&_hbaapi_APE_mutex);
1256 (void) pthread_mutex_destroy(&_hbaapi_AE_mutex);
1257 (void) pthread_mutex_destroy(&_hbaapi_AAE_mutex);
1258 (void) pthread_mutex_destroy(&_smhba_TE_mutex);
1259 (void) pthread_mutex_destroy(&_smhba_APSE_mutex);
1260 (void) pthread_mutex_destroy(&_smhba_APE_mutex);
1261 (void) pthread_mutex_destroy(&_smhba_AE_mutex);
1262 (void) pthread_mutex_destroy(&_smhba_AAE_mutex);
1263 (void) pthread_mutex_destroy(&_hbaapi_AL_mutex);
1264 (void) pthread_mutex_destroy(&_hbaapi_LL_mutex);
1265 #elif defined(WIN32)
1266 DeleteCriticalSection(&_hbaapi_LL_mutex);
1267 DeleteCriticalSection(&_hbaapi_AL_mutex);
1268 DeleteCriticalSection(&_hbaapi_AAE_mutex);
1269 DeleteCriticalSection(&_hbaapi_AE_mutex);
1270 DeleteCriticalSection(&_hbaapi_APE_mutex);
1271 DeleteCriticalSection(&_hbaapi_APSE_mutex);
1272 DeleteCriticalSection(&_hbaapi_TE_mutex);
1273 DeleteCriticalSection(&_hbaapi_LE_mutex);
1274 DeleteCriticalSection(&_smhba_TE_mutex);
1275 DeleteCriticalSection(&_smhba_APSE_mutex);
1276 DeleteCriticalSection(&_smhba_APE_mutex);
1277 DeleteCriticalSection(&_smhba_AE_mutex);
1278 DeleteCriticalSection(&_smhba_AAE_mutex);
1279 #endif
1280
1281 return (HBA_STATUS_OK);
1282 }
1283
1284 /*
1285 * The API used to use fixed size tables as its primary data structure.
1286 * Indexing from 1 to N identified each adapters. Now the adapters are
1287 * on a linked list. There is a unique "index" foreach each adapter.
1288 * Adapters always keep their index, even if they are removed from the
1289 * hardware. The only time the indexing is reset is on HBA_FreeLibrary
1290 */
1291 HBA_UINT32
1292 HBA_GetNumberOfAdapters()
1293 {
1294 int j = 0;
1295 HBA_LIBRARY_INFO *lib_infop;
1296 HBAGetNumberOfAdaptersFunc GetNumberOfAdaptersFunc;
1297 HBAGetAdapterNameFunc GetAdapterNameFunc;
1298 HBA_BOOLEAN found_name;
1299 HBA_ADAPTER_INFO *adapt_infop;
1300 HBA_STATUS status;
1301
1302 char adaptername[256];
1303 int num_adapters; /* local */
1304
1305 if (_hbaapi_librarylist == NULL) {
1306 return (0);
1307 }
1308 GRAB_MUTEX(&_hbaapi_LL_mutex); /* pay attention to order */
1309 GRAB_MUTEX(&_hbaapi_AL_mutex);
1310
1311 for (lib_infop = _hbaapi_librarylist;
1312 lib_infop != NULL;
1313 lib_infop = lib_infop->next) {
1314
1315 if (lib_infop->status != HBA_LIBRARY_LOADED) {
1316 continue;
1317 }
1318
1319 GetNumberOfAdaptersFunc =
1320 FUNCCOMMON(lib_infop, GetNumberOfAdaptersHandler);
1321 if (GetNumberOfAdaptersFunc == NULL) {
1322 continue;
1323 }
1324 num_adapters = ((GetNumberOfAdaptersFunc)());
1325 #ifndef WIN32
1326 DEBUG(1, "HBAAPI: num_adapters for %s = %d\n",
1327 lib_infop->LibraryName, num_adapters, 0);
1328 #else
1329 DEBUG(1, "HBAAPI: num_adapters for %s = %d\n",
1330 lib_infop->LibraryPath, num_adapters, 0);
1331 #endif
1332
1333 /* Also get the names of all the adapters here and cache */
1334 GetAdapterNameFunc = FUNCCOMMON(lib_infop, GetAdapterNameHandler);
1335 if (GetAdapterNameFunc == NULL) {
1336 continue;
1337 }
1338
1339 for (j = 0; j < num_adapters; j++) {
1340 found_name = 0;
1341 status = (GetAdapterNameFunc)(j, (char *)&adaptername);
1342 if (status == HBA_STATUS_OK) {
1343 for (adapt_infop = _hbaapi_adapterlist;
1344 adapt_infop != NULL;
1345 adapt_infop = adapt_infop->next) {
1346 /*
1347 * check for duplicates, really,
1348 * this may just be a second
1349 * call to this function
1350 * ??? how do we know when a name becomes stale?
1351 */
1352 if (strcmp(adaptername, adapt_infop->name) == 0) {
1353 /* already got this one */
1354 found_name++;
1355 break;
1356 }
1357 }
1358 if (found_name != 0) {
1359 continue;
1360 }
1361 }
1362
1363 adapt_infop = (HBA_ADAPTER_INFO *)
1364 calloc(1, sizeof (HBA_ADAPTER_INFO));
1365 if (adapt_infop == NULL) {
1366 #ifndef WIN32
1367 (void) fprintf(stderr,
1368 "HBA_GetNumberOfAdapters: calloc failed"
1369 " on sizeof:%lu\n",
1370 (unsigned long)(sizeof (HBA_ADAPTER_INFO)));
1371 #endif
1372 RELEASE_MUTEX(&_hbaapi_AL_mutex);
1373 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex,
1374 _hbaapi_total_adapter_count);
1375 }
1376 if ((adapt_infop->GNstatus = status) == HBA_STATUS_OK) {
1377 adapt_infop->name = strdup(adaptername);
1378 } else {
1379 char dummyname[512];
1380 (void) sprintf(dummyname, "NULLADAPTER-%255s-%03d",
1381 lib_infop->LibraryPath, _hbaapi_total_adapter_count);
1382 dummyname[511] = '\0';
1383 adapt_infop->name = strdup(dummyname);
1384 }
1385 lib_infop->numOfAdapters++;
1386 adapt_infop->library = lib_infop;
1387 adapt_infop->next = _hbaapi_adapterlist;
1388 adapt_infop->index = _hbaapi_total_adapter_count;
1389 _hbaapi_adapterlist = adapt_infop;
1390 _hbaapi_total_adapter_count++;
1391 }
1392 }
1393 RELEASE_MUTEX(&_hbaapi_AL_mutex);
1394 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, _hbaapi_total_adapter_count);
1395 }
1396
1397 HBA_STATUS
1398 HBA_GetAdapterName(
1399 HBA_UINT32 adapterindex,
1400 char *adaptername)
1401 {
1402 HBA_ADAPTER_INFO *adapt_infop;
1403 HBA_STATUS ret = HBA_STATUS_ERROR_ILLEGAL_INDEX;
1404
1405 if (adaptername == NULL) {
1406 DEBUG(1, "HBA_GetAdapterName: NULL pointer adatpername",
1407 0, 0, 0);
1408 return (HBA_STATUS_ERROR_ARG);
1409 }
1410
1411 /*
1412 * The adapter index is from old code, but we have
1413 * to support it. Go down the list looking for
1414 * the adapter
1415 */
1416 ARE_WE_INITED();
1417 GRAB_MUTEX(&_hbaapi_AL_mutex);
1418 *adaptername = '\0';
1419 for (adapt_infop = _hbaapi_adapterlist;
1420 adapt_infop != NULL;
1421 adapt_infop = adapt_infop->next) {
1422
1423 if (adapt_infop->index == adapterindex) {
1424 if (adapt_infop->name != NULL &&
1425 adapt_infop->GNstatus == HBA_STATUS_OK) {
1426 (void) strcpy(adaptername, adapt_infop->name);
1427 } else {
1428 *adaptername = '\0';
1429 }
1430 ret = adapt_infop->GNstatus;
1431 break;
1432 }
1433 }
1434 DEBUG(2, "GetAdapterName for index:%d ->%s",
1435 adapterindex, adaptername, 0);
1436 RELEASE_MUTEX_RETURN(&_hbaapi_AL_mutex, ret);
1437 }
1438
1439 HBA_HANDLE
1440 HBA_OpenAdapter(char *adaptername)
1441 {
1442 HBA_HANDLE handle;
1443 HBAOpenAdapterFunc OpenAdapterFunc;
1444 HBA_ADAPTER_INFO *adapt_infop;
1445 HBA_LIBRARY_INFO *lib_infop;
1446
1447 DEBUG(2, "OpenAdapter: %s", adaptername, 0, 0);
1448
1449 handle = HBA_HANDLE_INVALID;
1450 if (_hbaapi_librarylist == NULL) {
1451 return (handle);
1452 }
1453 if (adaptername == NULL) {
1454 DEBUG(1, "HBA_OpenAdapter: NULL pointer adatpername",
1455 0, 0, 0);
1456 return (handle);
1457 }
1458 GRAB_MUTEX(&_hbaapi_AL_mutex);
1459 for (adapt_infop = _hbaapi_adapterlist;
1460 adapt_infop != NULL;
1461 adapt_infop = adapt_infop->next) {
1462 if (strcmp(adaptername, adapt_infop->name) != 0) {
1463 continue;
1464 }
1465 lib_infop = adapt_infop->library;
1466 OpenAdapterFunc = FUNCCOMMON(lib_infop, OpenAdapterHandler);
1467
1468 if (OpenAdapterFunc != NULL) {
1469 /* retrieve the vendor handle */
1470 handle = (OpenAdapterFunc)(adaptername);
1471 if (handle != 0) {
1472 /* or this with the library index to get the common handle */
1473 handle = HBA_HANDLE_FROM_LOCAL(lib_infop->index, handle);
1474 }
1475 }
1476 break;
1477 }
1478 RELEASE_MUTEX_RETURN(&_hbaapi_AL_mutex, handle);
1479 }
1480
1481 /*
1482 * Finding an adapter with matching WWN.
1483 */
1484 HBA_STATUS
1485 HBA_OpenAdapterByWWN(HBA_HANDLE *phandle, HBA_WWN nodeWWN) {
1486 HBA_HANDLE handle;
1487 HBA_LIBRARY_INFO *lib_infop;
1488 HBAGetNumberOfAdaptersFunc
1489 GetNumberOfAdaptersFunc;
1490 HBAOpenAdapterByWWNFunc
1491 OpenAdapterFunc;
1492 HBA_STATUS status;
1493
1494 DEBUG(2, "OpenAdapterByWWN: %s", WWN2STR1(&nodeWWN), 0, 0);
1495 ARE_WE_INITED();
1496
1497 *phandle = HBA_HANDLE_INVALID;
1498
1499 GRAB_MUTEX(&_hbaapi_LL_mutex);
1500 for (lib_infop = _hbaapi_librarylist;
1501 lib_infop != NULL;
1502 lib_infop = lib_infop->next) {
1503
1504 status = HBA_STATUS_ERROR_ILLEGAL_WWN;
1505
1506 if (lib_infop->status != HBA_LIBRARY_LOADED) {
1507 continue;
1508 }
1509
1510 /* only for HBAAPIV2 */
1511 if (lib_infop->version != HBAAPIV2) {
1512 continue;
1513 }
1514
1515 GetNumberOfAdaptersFunc =
1516 FUNCCOMMON(lib_infop, GetNumberOfAdaptersHandler);
1517 if (GetNumberOfAdaptersFunc == NULL) {
1518 continue;
1519 }
1520
1521 /* look for new hardware */
1522 (void) ((GetNumberOfAdaptersFunc)());
1523
1524 OpenAdapterFunc =
1525 lib_infop->ftable.functionTable.OpenAdapterByWWNHandler;
1526 if (OpenAdapterFunc == NULL) {
1527 continue;
1528 }
1529 /*
1530 * We do not know if the WWN is known by this vendor,
1531 * just try it
1532 */
1533 if ((status = (OpenAdapterFunc)(&handle, nodeWWN)) != HBA_STATUS_OK) {
1534 continue;
1535 }
1536 /* OK, make a vendor non-specific handle */
1537 *phandle = HBA_HANDLE_FROM_LOCAL(lib_infop->index, handle);
1538 status = HBA_STATUS_OK;
1539 break;
1540 }
1541 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
1542 }
1543
1544 void
1545 HBA_RefreshAdapterConfiguration() {
1546 DEBUG(2, "HBA_RefreshAdapterConfiguration", 0, 0, 0);
1547 (void) HBA_GetNumberOfAdapters();
1548 }
1549
1550 HBA_UINT32
1551 HBA_GetVersion() {
1552 DEBUG(2, "HBA_GetVersion", 0, 0, 0);
1553 return (HBA_LIBVERSION);
1554 }
1555
1556 /*
1557 * This function is VERY OS dependent. Wing it as best you can.
1558 */
1559 HBA_UINT32
1560 HBA_GetWrapperLibraryAttributes(
1561 HBA_LIBRARYATTRIBUTES *attributes)
1562 {
1563
1564 DEBUG(2, "HBA_GetWrapperLibraryAttributes", 0, 0, 0);
1565
1566 if (attributes == NULL) {
1567 DEBUG(1, "HBA_GetWrapperLibraryAttributes:"
1568 "NULL pointer attributes",
1569 0, 0, 0);
1570 return (HBA_STATUS_ERROR_ARG);
1571 }
1572
1573 (void) memset(attributes, 0, sizeof (HBA_LIBRARYATTRIBUTES));
1574
1575 #if defined(SOLARIS)
1576 if ((handle = dlopen("libHBAAPI.so", RTLD_NOW)) != NULL) {
1577 if (dlinfo(handle, RTLD_DI_LINKMAP, &map) >= 0) {
1578 for (mp = map; mp != NULL; mp = mp->l_next) {
1579 if (strlen(map->l_name) < 256) {
1580 (void) strcpy(attributes->LibPath, map->l_name);
1581 }
1582 }
1583 }
1584 }
1585 #elif defined(WIN32)
1586 HMODULE module;
1587
1588 /* No need to do anything with the module handle */
1589 /* It wasn't alloocated so it doesn't need to be freed */
1590 module = GetModuleHandle("HBAAPI");
1591 if (module != NULL) {
1592 if (GetModuleFileName(module, attributes->LibPath,
1593 sizeof (attributes->LibPath)) == 0) {
1594 attributes->LibPath[0] = '\0';
1595 }
1596 }
1597 #endif
1598 #if defined(VENDOR)
1599 (void) strcpy(attributes->VName, VENDOR);
1600 #else
1601 attributes->VName[0] = '\0';
1602 #endif
1603 #if defined(VERSION)
1604 (void) strcpy(attributes->VVersion, VERSION);
1605 #else
1606 attributes->VVersion[0] = '\0';
1607 #endif
1608 #if defined(BUILD_DATE)
1609 #if defined(WIN32)
1610 int matchCount;
1611 matchCount = sscanf(BUILD_DATE, "%u/%u/%u %u:%u:%u",
1612 &attributes->build_date.tm_year,
1613 &attributes->build_date.tm_mon,
1614 &attributes->build_date.tm_mday,
1615 &attributes->build_date.tm_hour,
1616 &attributes->build_date.tm_min,
1617 &attributes->build_date.tm_sec);
1618
1619 if (matchCount != 6) {
1620 memset(&attributes->build_date, 0, sizeof (struct tm));
1621 } else {
1622 attributes->build_date.tm_year -= 1900;
1623 attributes->build_date.tm_isdst = -1;
1624 }
1625 #else
1626 if (strptime(BUILD_DATE,
1627 "%Y/%m/%d %T %Z", &(attributes->build_date)) == NULL) {
1628 (void) memset(&attributes->build_date, 0, sizeof (struct tm));
1629 }
1630 #endif
1631 #else
1632 (void) memset(&attributes->build_date, 0, sizeof (struct tm));
1633 #endif
1634 return (2);
1635 }
1636
1637 /*
1638 * Callback registation and handling
1639 */
1640 HBA_STATUS
1641 HBA_RemoveCallback(HBA_CALLBACKHANDLE cbhandle) {
1642 HBA_STATUS status;
1643
1644 DEBUG(2, "HBA_RemoveCallback", 0, 0, 0);
1645 ARE_WE_INITED();
1646
1647 GRAB_MUTEX(&_hbaapi_LL_mutex);
1648 status = local_remove_callback(cbhandle);
1649 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
1650 }
1651
1652 /* Adapter Add Events ************************************************* */
1653 static void
1654 /* LINTED E_FUNC_ARG_UNUSED */
1655 adapteraddevents_callback(void *data, HBA_WWN PortWWN, HBA_UINT32 eventType) {
1656 HBA_ALLADAPTERSCALLBACK_ELEM *cbp;
1657
1658 DEBUG(3, "AddAdapterEvent, port: %s", WWN2STR1(&PortWWN), 0, 0);
1659
1660 GRAB_MUTEX(&_hbaapi_AAE_mutex);
1661 for (cbp = _hbaapi_adapteraddevents_callback_list;
1662 cbp != NULL;
1663 cbp = cbp->next) {
1664 (*cbp->callback)(data, PortWWN, HBA_EVENT_ADAPTER_ADD);
1665 }
1666 RELEASE_MUTEX(&_hbaapi_AAE_mutex);
1667
1668 }
1669
1670 HBA_STATUS
1671 HBA_RegisterForAdapterAddEvents(
1672 void (*callback)(
1673 void *data,
1674 HBA_WWN PortWWN,
1675 HBA_UINT32 eventType),
1676 void *userData,
1677 HBA_CALLBACKHANDLE *callbackHandle) {
1678
1679 HBA_ALLADAPTERSCALLBACK_ELEM *cbp;
1680 HBA_VENDORCALLBACK_ELEM *vcbp;
1681 HBA_VENDORCALLBACK_ELEM *vendorhandlelist;
1682 HBARegisterForAdapterAddEventsFunc registeredfunc;
1683 HBA_STATUS status = HBA_STATUS_OK;
1684 HBA_STATUS failure = HBA_STATUS_OK;
1685 HBA_LIBRARY_INFO *lib_infop;
1686 int registered_cnt = 0;
1687 int vendor_cnt = 0;
1688 int not_supported_cnt = 0;
1689 int status_OK_bar_cnt = 0;
1690 int status_OK_cnt = 0;
1691
1692 DEBUG(2, "HBA_RegisterForAdapterAddEvents", 0, 0, 0);
1693 ARE_WE_INITED();
1694
1695 cbp = (HBA_ALLADAPTERSCALLBACK_ELEM *)
1696 calloc(1, sizeof (HBA_ALLADAPTERSCALLBACK_ELEM));
1697 *callbackHandle = (HBA_CALLBACKHANDLE) cbp;
1698 if (cbp == NULL) {
1699 #ifndef WIN32
1700 (void) fprintf(stderr,
1701 "HBA_RegisterForAdapterAddEvents: calloc failed "
1702 "for %lu bytes\n",
1703 (unsigned long)(sizeof (HBA_ALLADAPTERSCALLBACK_ELEM)));
1704 #endif
1705 return (HBA_STATUS_ERROR);
1706 }
1707
1708 GRAB_MUTEX(&_hbaapi_LL_mutex);
1709 GRAB_MUTEX(&_hbaapi_AAE_mutex);
1710 cbp->callback = callback;
1711 cbp->next = _hbaapi_adapteraddevents_callback_list;
1712 _hbaapi_adapteraddevents_callback_list = cbp;
1713 /*
1714 * Need to release the mutex now incase the vendor function invokes the
1715 * callback. We will grap the mutex later to attach the vendor handle
1716 * list to the callback structure
1717 */
1718 RELEASE_MUTEX(&_hbaapi_AAE_mutex);
1719
1720 /*
1721 * now create a list of vendors (vendor libraryies, NOT ADAPTERS)
1722 * that have successfully registerred
1723 */
1724 vendorhandlelist = NULL;
1725 for (lib_infop = _hbaapi_librarylist;
1726 lib_infop != NULL;
1727 lib_infop = lib_infop->next) {
1728
1729 /* only for HBAAPI V2 */
1730 if ((lib_infop->version != HBAAPIV2)) {
1731 continue;
1732 } else {
1733 vendor_cnt++;
1734 }
1735
1736 registeredfunc =
1737 lib_infop->ftable.functionTable.RegisterForAdapterAddEventsHandler;
1738 if (registeredfunc == NULL) {
1739 continue;
1740 }
1741
1742 vcbp = (HBA_VENDORCALLBACK_ELEM *)
1743 calloc(1, sizeof (HBA_VENDORCALLBACK_ELEM));
1744 if (vcbp == NULL) {
1745 #ifndef WIN32
1746 (void) fprintf(stderr,
1747 "HBA_RegisterForAdapterAddEvents: "
1748 "calloc failed for %lu bytes\n",
1749 (unsigned long)(sizeof (HBA_VENDORCALLBACK_ELEM)));
1750 #endif
1751 freevendorhandlelist(vendorhandlelist);
1752 status = HBA_STATUS_ERROR;
1753 break;
1754 }
1755
1756 registered_cnt++;
1757 status = (registeredfunc)(adapteraddevents_callback,
1758 userData, &vcbp->vendorcbhandle);
1759 if (status == HBA_STATUS_ERROR_NOT_SUPPORTED) {
1760 not_supported_cnt++;
1761 free(vcbp);
1762 continue;
1763 } else if (status != HBA_STATUS_OK) {
1764 status_OK_bar_cnt++;
1765 DEBUG(1,
1766 "HBA_RegisterForAdapterAddEvents: Library->%s, Error->%d",
1767 lib_infop->LibraryPath, status, 0);
1768 #ifndef WIN32
1769 (void) fprintf(stderr,
1770 "HBA_RegisterForAdapterAddEvents: Library->%s, Error->%d",
1771 lib_infop->LibraryPath, status);
1772 #endif
1773 failure = status;
1774 free(vcbp);
1775 continue;
1776 } else {
1777 status_OK_cnt++;
1778 }
1779 vcbp->lib_info = lib_infop;
1780 vcbp->next = vendorhandlelist;
1781 vendorhandlelist = vcbp;
1782 }
1783 if (vendor_cnt == 0) {
1784 /* no HBAAPIV2 is deteced. should be okay? */
1785 status = HBA_STATUS_ERROR;
1786 } else if (registered_cnt == 0) {
1787 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
1788 freevendorhandlelist(vendorhandlelist);
1789 (void) local_remove_callback((HBA_CALLBACKHANDLE) cbp);
1790 } else if (status_OK_cnt == 0 && not_supported_cnt != 0) {
1791 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
1792 } else if (status_OK_cnt == 0) {
1793 /*
1794 * At least one vendor library registered this function, but no
1795 * vendor call succeeded
1796 */
1797 (void) local_remove_callback((HBA_CALLBACKHANDLE) cbp);
1798 status = failure;
1799 } else {
1800 /* we have had atleast some success, now finish up */
1801 GRAB_MUTEX(&_hbaapi_AAE_mutex);
1802 /*
1803 * this seems silly, but what if another thread called
1804 * the callback remove
1805 */
1806 for (cbp = _hbaapi_adapteraddevents_callback_list;
1807 cbp != NULL; cbp = cbp->next) {
1808 if ((HBA_CALLBACKHANDLE)cbp == *callbackHandle) {
1809 /* yup, its still there, hooray */
1810 cbp->vendorhandlelist = vendorhandlelist;
1811 vendorhandlelist = NULL;
1812 break;
1813 }
1814 }
1815 RELEASE_MUTEX(&_hbaapi_AAE_mutex);
1816 if (vendorhandlelist != NULL) {
1817 /*
1818 * bummer, somebody removed the callback before we finished
1819 * registration, probably will never happen
1820 */
1821 freevendorhandlelist(vendorhandlelist);
1822 DEBUG(1,
1823 "HBA_RegisterForAdapterAddEvents: HBA_RemoveCallback was "
1824 "called for a handle before registration was finished.",
1825 0, 0, 0);
1826 status = HBA_STATUS_ERROR;
1827 } else {
1828 status = HBA_STATUS_OK;
1829 }
1830 }
1831 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
1832 }
1833
1834 /* Adapter Events (other than add) ************************************** */
1835 static void
1836 adapterevents_callback(void *data,
1837 HBA_WWN PortWWN,
1838 HBA_UINT32 eventType) {
1839 HBA_ADAPTERCALLBACK_ELEM *acbp;
1840
1841 DEBUG(3, "AdapterEvent, port:%s, eventType:%d", WWN2STR1(&PortWWN),
1842 eventType, 0);
1843
1844 GRAB_MUTEX(&_hbaapi_AE_mutex);
1845 for (acbp = _hbaapi_adapterevents_callback_list;
1846 acbp != NULL;
1847 acbp = acbp->next) {
1848 if (data == (void *)acbp) {
1849 (*acbp->callback)(acbp->userdata, PortWWN, eventType);
1850 break;
1851 }
1852 }
1853 RELEASE_MUTEX(&_hbaapi_AE_mutex);
1854 }
1855 HBA_STATUS
1856 HBA_RegisterForAdapterEvents(
1857 void (*callback) (
1858 void *data,
1859 HBA_WWN PortWWN,
1860 HBA_UINT32 eventType),
1861 void *userData,
1862 HBA_HANDLE handle,
1863 HBA_CALLBACKHANDLE *callbackHandle) {
1864
1865 HBA_ADAPTERCALLBACK_ELEM *acbp;
1866 HBARegisterForAdapterEventsFunc registeredfunc;
1867 HBA_STATUS status;
1868 HBA_LIBRARY_INFO *lib_infop;
1869 HBA_HANDLE vendorHandle;
1870
1871 DEBUG(2, "HBA_RegisterForAdapterEvents", 0, 0, 0);
1872
1873 CHECKLIBRARYANDVERSION(HBAAPIV2);
1874
1875 /* we now have the _hbaapi_LL_mutex */
1876
1877 registeredfunc =
1878 lib_infop->ftable.functionTable.RegisterForAdapterEventsHandler;
1879 if (registeredfunc == NULL) {
1880 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
1881 }
1882
1883 /*
1884 * that allocated memory is used both as the handle for the
1885 * caller, and as userdata to the vendor call so that on
1886 * callback the specific registration may be recalled
1887 */
1888 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
1889 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
1890 if (acbp == NULL) {
1891 #ifndef WIN32
1892 (void) fprintf(stderr,
1893 "HBA_RegisterForAdapterEvents: calloc failed for %lu bytes\n",
1894 (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
1895 #endif
1896 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
1897 }
1898 *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
1899 acbp->callback = callback;
1900 acbp->userdata = userData;
1901 acbp->lib_info = lib_infop;
1902
1903 status = (registeredfunc)(adapterevents_callback,
1904 (void *)acbp,
1905 vendorHandle,
1906 &acbp->vendorcbhandle);
1907 if (status != HBA_STATUS_OK) {
1908 free(acbp);
1909 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
1910 }
1911
1912 GRAB_MUTEX(&_hbaapi_AE_mutex);
1913 acbp->next = _hbaapi_adapterevents_callback_list;
1914 _hbaapi_adapterevents_callback_list = acbp;
1915 RELEASE_MUTEX(&_hbaapi_AE_mutex);
1916
1917 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
1918 }
1919
1920 /* Adapter Port Events ************************************************** */
1921 static void
1922 adapterportevents_callback(void *data,
1923 HBA_WWN PortWWN,
1924 HBA_UINT32 eventType,
1925 HBA_UINT32 fabricPortID) {
1926 HBA_ADAPTERCALLBACK_ELEM *acbp;
1927
1928 DEBUG(3, "AdapterPortEvent, port:%s, eventType:%d fabricPortID:0X%06x",
1929 WWN2STR1(&PortWWN), eventType, fabricPortID);
1930
1931 GRAB_MUTEX(&_hbaapi_APE_mutex);
1932
1933 for (acbp = _hbaapi_adapterportevents_callback_list;
1934 acbp != NULL;
1935 acbp = acbp->next) {
1936 if (data == (void *)acbp) {
1937 (*acbp->callback)(acbp->userdata, PortWWN, eventType, fabricPortID);
1938 break;
1939 }
1940 }
1941 RELEASE_MUTEX(&_hbaapi_APE_mutex);
1942 }
1943
1944 HBA_STATUS
1945 HBA_RegisterForAdapterPortEvents(
1946 void (*callback) (
1947 void *data,
1948 HBA_WWN PortWWN,
1949 HBA_UINT32 eventType,
1950 HBA_UINT32 fabricPortID),
1951 void *userData,
1952 HBA_HANDLE handle,
1953 HBA_WWN PortWWN,
1954 HBA_CALLBACKHANDLE *callbackHandle) {
1955
1956 HBA_ADAPTERCALLBACK_ELEM *acbp;
1957 HBARegisterForAdapterPortEventsFunc registeredfunc;
1958 HBA_STATUS status;
1959 HBA_LIBRARY_INFO *lib_infop;
1960 HBA_HANDLE vendorHandle;
1961
1962 DEBUG(2, "HBA_RegisterForAdapterPortEvents for port: %s",
1963 WWN2STR1(&PortWWN), 0, 0);
1964
1965 CHECKLIBRARYANDVERSION(HBAAPIV2);
1966 /* we now have the _hbaapi_LL_mutex */
1967
1968 registeredfunc =
1969 lib_infop->ftable.functionTable.RegisterForAdapterPortEventsHandler;
1970 if (registeredfunc == NULL) {
1971 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
1972 }
1973
1974 /*
1975 * that allocated memory is used both as the handle for the
1976 * caller, and as userdata to the vendor call so that on
1977 * callback the specific registration may be recalled
1978 */
1979 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
1980 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
1981 if (acbp == NULL) {
1982 #ifndef WIN32
1983 (void) fprintf(stderr,
1984 "HBA_RegisterForAdapterPortEvents: "
1985 "calloc failed for %lu bytes\n",
1986 (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
1987 #endif
1988 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
1989
1990 }
1991 *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
1992 acbp->callback = callback;
1993 acbp->userdata = userData;
1994 acbp->lib_info = lib_infop;
1995
1996 status = (registeredfunc)(adapterportevents_callback,
1997 (void *)acbp,
1998 vendorHandle,
1999 PortWWN,
2000 &acbp->vendorcbhandle);
2001 if (status != HBA_STATUS_OK) {
2002 free(acbp);
2003 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2004 }
2005
2006 GRAB_MUTEX(&_hbaapi_APE_mutex);
2007 acbp->next = _hbaapi_adapterportevents_callback_list;
2008 _hbaapi_adapterportevents_callback_list = acbp;
2009 RELEASE_MUTEX(&_hbaapi_APE_mutex);
2010
2011 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
2012 }
2013
2014 /* Adapter State Events ************************************************ */
2015 static void
2016 adapterportstatevents_callback(void *data,
2017 HBA_WWN PortWWN,
2018 HBA_UINT32 eventType) {
2019 HBA_ADAPTERCALLBACK_ELEM *acbp;
2020
2021 DEBUG(3, "AdapterPortStatEvent, port:%s, eventType:%d",
2022 WWN2STR1(&PortWWN),
2023 eventType, 0);
2024
2025 GRAB_MUTEX(&_hbaapi_APSE_mutex);
2026 for (acbp = _hbaapi_adapterportstatevents_callback_list;
2027 acbp != NULL;
2028 acbp = acbp->next) {
2029 if (data == (void *)acbp) {
2030 (*acbp->callback)(acbp->userdata, PortWWN, eventType);
2031 return;
2032 }
2033 }
2034 RELEASE_MUTEX(&_hbaapi_APSE_mutex);
2035 }
2036 HBA_STATUS
2037 HBA_RegisterForAdapterPortStatEvents(
2038 void (*callback) (
2039 void *data,
2040 HBA_WWN PortWWN,
2041 HBA_UINT32 eventType),
2042 void *userData,
2043 HBA_HANDLE handle,
2044 HBA_WWN PortWWN,
2045 HBA_PORTSTATISTICS stats,
2046 HBA_UINT32 statType,
2047 HBA_CALLBACKHANDLE *callbackHandle) {
2048
2049 HBA_ADAPTERCALLBACK_ELEM *acbp;
2050 HBARegisterForAdapterPortStatEventsFunc
2051 registeredfunc;
2052 HBA_STATUS status;
2053 HBA_LIBRARY_INFO *lib_infop;
2054 HBA_HANDLE vendorHandle;
2055
2056 DEBUG(2, "HBA_RegisterForAdapterPortStatEvents for port: %s",
2057 WWN2STR1(&PortWWN), 0, 0);
2058
2059 CHECKLIBRARYANDVERSION(HBAAPIV2);
2060 /* we now have the _hbaapi_LL_mutex */
2061
2062 registeredfunc =
2063 lib_infop->ftable.functionTable.RegisterForAdapterPortStatEventsHandler;
2064 if (registeredfunc == NULL) {
2065 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
2066 }
2067
2068 /*
2069 * that allocated memory is used both as the handle for the
2070 * caller, and as userdata to the vendor call so that on
2071 * callback the specific registration may be recalled
2072 */
2073 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
2074 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
2075 if (acbp == NULL) {
2076 #ifndef WIN32
2077 (void) fprintf(stderr,
2078 "HBA_RegisterForAdapterPortStatEvents: "
2079 "calloc failed for %lu bytes\n",
2080 (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
2081 #endif
2082 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
2083 }
2084 *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
2085 acbp->callback = callback;
2086 acbp->userdata = userData;
2087 acbp->lib_info = lib_infop;
2088
2089 status = (registeredfunc)(adapterportstatevents_callback,
2090 (void *)acbp,
2091 vendorHandle,
2092 PortWWN,
2093 stats,
2094 statType,
2095 &acbp->vendorcbhandle);
2096 if (status != HBA_STATUS_OK) {
2097 free(acbp);
2098 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2099 }
2100
2101 GRAB_MUTEX(&_hbaapi_APSE_mutex);
2102 acbp->next = _hbaapi_adapterportstatevents_callback_list;
2103 _hbaapi_adapterportstatevents_callback_list = acbp;
2104 RELEASE_MUTEX(&_hbaapi_APSE_mutex);
2105
2106 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
2107 }
2108
2109 /* Target Events ******************************************************* */
2110 static void
2111 targetevents_callback(void *data,
2112 HBA_WWN hbaPortWWN,
2113 HBA_WWN discoveredPortWWN,
2114 HBA_UINT32 eventType) {
2115
2116 HBA_ADAPTERCALLBACK_ELEM *acbp;
2117
2118 DEBUG(3, "TargetEvent, hbaPort:%s, discoveredPort:%s eventType:%d",
2119 WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), eventType);
2120
2121 GRAB_MUTEX(&_hbaapi_TE_mutex);
2122 for (acbp = _hbaapi_targetevents_callback_list;
2123 acbp != NULL;
2124 acbp = acbp->next) {
2125 if (data == (void *)acbp) {
2126 (*acbp->callback)(acbp->userdata, hbaPortWWN,
2127 discoveredPortWWN, eventType);
2128 break;
2129 }
2130 }
2131 RELEASE_MUTEX(&_hbaapi_TE_mutex);
2132 }
2133
2134 HBA_STATUS
2135 HBA_RegisterForTargetEvents(
2136 void (*callback) (
2137 void *data,
2138 HBA_WWN hbaPortWWN,
2139 HBA_WWN discoveredPortWWN,
2140 HBA_UINT32 eventType),
2141 void *userData,
2142 HBA_HANDLE handle,
2143 HBA_WWN hbaPortWWN,
2144 HBA_WWN discoveredPortWWN,
2145 HBA_CALLBACKHANDLE *callbackHandle,
2146 HBA_UINT32 allTargets) {
2147
2148 HBA_ADAPTERCALLBACK_ELEM
2149 *acbp;
2150 HBARegisterForTargetEventsFunc
2151 registeredfunc;
2152 HBA_STATUS status;
2153 HBA_LIBRARY_INFO *lib_infop;
2154 HBA_HANDLE vendorHandle;
2155
2156 DEBUG(2, "HBA_RegisterForTargetEvents, hbaPort: %s, discoveredPort: %s",
2157 WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), 0);
2158
2159 CHECKLIBRARYANDVERSION(HBAAPIV2);
2160 /* we now have the _hbaapi_LL_mutex */
2161
2162 registeredfunc =
2163 lib_infop->ftable.functionTable.RegisterForTargetEventsHandler;
2164 if (registeredfunc == NULL) {
2165 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
2166 }
2167
2168 /*
2169 * that allocated memory is used both as the handle for the
2170 * caller, and as userdata to the vendor call so that on
2171 * callback the specific registration may be recalled
2172 */
2173 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
2174 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
2175 if (acbp == NULL) {
2176 #ifndef WIN32
2177 (void) fprintf(stderr,
2178 "HBA_RegisterForTargetEvents: calloc failed for %lu bytes\n",
2179 (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
2180 #endif
2181 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
2182 }
2183 *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
2184 acbp->callback = callback;
2185 acbp->userdata = userData;
2186 acbp->lib_info = lib_infop;
2187
2188 status = (registeredfunc)(targetevents_callback,
2189 (void *)acbp,
2190 vendorHandle,
2191 hbaPortWWN,
2192 discoveredPortWWN,
2193 &acbp->vendorcbhandle,
2194 allTargets);
2195 if (status != HBA_STATUS_OK) {
2196 free(acbp);
2197 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2198 }
2199
2200 GRAB_MUTEX(&_hbaapi_TE_mutex);
2201 acbp->next = _hbaapi_targetevents_callback_list;
2202 _hbaapi_targetevents_callback_list = acbp;
2203 RELEASE_MUTEX(&_hbaapi_TE_mutex);
2204
2205 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
2206 }
2207
2208 /* Link Events ********************************************************* */
2209 static void
2210 linkevents_callback(void *data,
2211 HBA_WWN adapterWWN,
2212 HBA_UINT32 eventType,
2213 void *pRLIRBuffer,
2214 HBA_UINT32 RLIRBufferSize) {
2215 HBA_ADAPTERCALLBACK_ELEM *acbp;
2216
2217 DEBUG(3, "LinkEvent, hbaWWN:%s, eventType:%d",
2218 WWN2STR1(&adapterWWN), eventType, 0);
2219
2220 GRAB_MUTEX(&_hbaapi_LE_mutex);
2221 for (acbp = _hbaapi_linkevents_callback_list;
2222 acbp != NULL;
2223 acbp = acbp->next) {
2224 if (data == (void *)acbp) {
2225 (*acbp->callback)(acbp->userdata, adapterWWN,
2226 eventType, pRLIRBuffer, RLIRBufferSize);
2227 break;
2228 }
2229 }
2230 RELEASE_MUTEX(&_hbaapi_LE_mutex);
2231 }
2232 HBA_STATUS
2233 HBA_RegisterForLinkEvents(
2234 void (*callback) (
2235 void *data,
2236 HBA_WWN adapterWWN,
2237 HBA_UINT32 eventType,
2238 void *pRLIRBuffer,
2239 HBA_UINT32 RLIRBufferSize),
2240 void *userData,
2241 void *pRLIRBuffer,
2242 HBA_UINT32 RLIRBufferSize,
2243 HBA_HANDLE handle,
2244 HBA_CALLBACKHANDLE *callbackHandle) {
2245
2246 HBA_ADAPTERCALLBACK_ELEM *acbp;
2247 HBARegisterForLinkEventsFunc
2248 registeredfunc;
2249 HBA_STATUS status;
2250 HBA_LIBRARY_INFO *lib_infop;
2251 HBA_HANDLE vendorHandle;
2252
2253 DEBUG(2, "HBA_RegisterForLinkEvents", 0, 0, 0);
2254
2255 CHECKLIBRARY();
2256 /* we now have the _hbaapi_LL_mutex */
2257
2258 registeredfunc = FUNCCOMMON(lib_infop, RegisterForLinkEventsHandler);
2259
2260 if (registeredfunc == NULL) {
2261 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
2262 }
2263
2264 /*
2265 * that allocated memory is used both as the handle for the
2266 * caller, and as userdata to the vendor call so that on
2267 * callback the specific registration may be recalled
2268 */
2269 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
2270 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
2271 if (acbp == NULL) {
2272 #ifndef WIN32
2273 (void) fprintf(stderr,
2274 "HBA_RegisterForLinkEvents: calloc failed for %lu bytes\n",
2275 (unsigned long)(sizeof (HBA_ADAPTERCALLBACK_ELEM)));
2276 #endif
2277 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
2278 }
2279 *callbackHandle = (HBA_CALLBACKHANDLE) acbp;
2280 acbp->callback = callback;
2281 acbp->userdata = userData;
2282 acbp->lib_info = lib_infop;
2283
2284 status = (registeredfunc)(linkevents_callback,
2285 (void *)acbp,
2286 pRLIRBuffer,
2287 RLIRBufferSize,
2288 vendorHandle,
2289 &acbp->vendorcbhandle);
2290 if (status != HBA_STATUS_OK) {
2291 free(acbp);
2292 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2293 }
2294
2295 GRAB_MUTEX(&_hbaapi_LE_mutex);
2296 acbp->next = _hbaapi_linkevents_callback_list;
2297 _hbaapi_linkevents_callback_list = acbp;
2298 RELEASE_MUTEX(&_hbaapi_LE_mutex);
2299
2300 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
2301 }
2302
2303 /*
2304 * All of the functions below are almost passthru functions to the
2305 * vendor specific function
2306 */
2307
2308 void
2309 HBA_CloseAdapter(HBA_HANDLE handle) {
2310 HBA_STATUS status;
2311 HBA_LIBRARY_INFO *lib_infop;
2312 HBA_HANDLE vendorHandle;
2313 HBACloseAdapterFunc CloseAdapterFunc;
2314
2315 DEBUG(2, "HBA_CloseAdapter", 0, 0, 0);
2316
2317 status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
2318 if (status == HBA_STATUS_OK) {
2319 CloseAdapterFunc = FUNCCOMMON(lib_infop, CloseAdapterHandler);
2320 if (CloseAdapterFunc != NULL) {
2321 ((CloseAdapterFunc)(vendorHandle));
2322 }
2323 RELEASE_MUTEX(&_hbaapi_LL_mutex);
2324 }
2325 }
2326
2327 HBA_STATUS
2328 HBA_GetAdapterAttributes(
2329 HBA_HANDLE handle,
2330 HBA_ADAPTERATTRIBUTES
2331 *hbaattributes)
2332 {
2333 HBA_STATUS status;
2334 HBA_LIBRARY_INFO *lib_infop;
2335 HBA_HANDLE vendorHandle;
2336 HBAGetAdapterAttributesFunc GetAdapterAttributesFunc;
2337
2338 DEBUG(2, "HBA_GetAdapterAttributes", 0, 0, 0);
2339
2340 CHECKLIBRARY();
2341
2342 if (lib_infop->version == SMHBA) {
2343 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2344 }
2345
2346 GetAdapterAttributesFunc =
2347 lib_infop->ftable.functionTable.GetAdapterAttributesHandler;
2348 if (GetAdapterAttributesFunc != NULL) {
2349 status = ((GetAdapterAttributesFunc)(vendorHandle, hbaattributes));
2350 } else {
2351 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2352 }
2353 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2354 }
2355
2356 HBA_STATUS
2357 HBA_GetAdapterPortAttributes(
2358 HBA_HANDLE handle,
2359 HBA_UINT32 portindex,
2360 HBA_PORTATTRIBUTES *portattributes)
2361 {
2362 HBA_STATUS status;
2363 HBA_LIBRARY_INFO *lib_infop;
2364 HBA_HANDLE vendorHandle;
2365 HBAGetAdapterPortAttributesFunc
2366 GetAdapterPortAttributesFunc;
2367
2368 DEBUG(2, "HBA_GetAdapterPortAttributes", 0, 0, 0);
2369
2370 CHECKLIBRARY();
2371 if (lib_infop->version == SMHBA) {
2372 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2373 }
2374
2375 GetAdapterPortAttributesFunc =
2376 lib_infop->ftable.functionTable.GetAdapterPortAttributesHandler;
2377 if (GetAdapterPortAttributesFunc != NULL) {
2378 status = ((GetAdapterPortAttributesFunc)
2379 (vendorHandle, portindex, portattributes));
2380 } else {
2381 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2382 }
2383 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2384 }
2385
2386 HBA_STATUS
2387 HBA_GetPortStatistics(
2388 HBA_HANDLE handle,
2389 HBA_UINT32 portindex,
2390 HBA_PORTSTATISTICS *portstatistics)
2391 {
2392 HBA_STATUS status;
2393 HBA_LIBRARY_INFO *lib_infop;
2394 HBA_HANDLE vendorHandle;
2395 HBAGetPortStatisticsFunc
2396 GetPortStatisticsFunc;
2397
2398 DEBUG(2, "HBA_GetPortStatistics", 0, 0, 0);
2399
2400 CHECKLIBRARY();
2401 if (lib_infop->version == SMHBA) {
2402 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2403 }
2404
2405 GetPortStatisticsFunc =
2406 lib_infop->ftable.functionTable.GetPortStatisticsHandler;
2407 if (GetPortStatisticsFunc != NULL) {
2408 status = ((GetPortStatisticsFunc)
2409 (vendorHandle, portindex, portstatistics));
2410 } else {
2411 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2412 }
2413 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2414 }
2415
2416 HBA_STATUS
2417 HBA_GetDiscoveredPortAttributes(
2418 HBA_HANDLE handle,
2419 HBA_UINT32 portindex,
2420 HBA_UINT32 discoveredportindex,
2421 HBA_PORTATTRIBUTES *portattributes)
2422 {
2423 HBA_STATUS status;
2424 HBA_LIBRARY_INFO *lib_infop;
2425 HBA_HANDLE vendorHandle;
2426 HBAGetDiscoveredPortAttributesFunc
2427 GetDiscoveredPortAttributesFunc;
2428
2429 DEBUG(2, "HBA_GetDiscoveredPortAttributes", 0, 0, 0);
2430
2431 CHECKLIBRARY();
2432 if (lib_infop->version == SMHBA) {
2433 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2434 }
2435
2436 GetDiscoveredPortAttributesFunc =
2437 lib_infop->ftable.functionTable.GetDiscoveredPortAttributesHandler;
2438 if (GetDiscoveredPortAttributesFunc != NULL) {
2439 status = ((GetDiscoveredPortAttributesFunc)
2440 (vendorHandle, portindex, discoveredportindex,
2441 portattributes));
2442 } else {
2443 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2444 }
2445 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2446 }
2447
2448 HBA_STATUS
2449 HBA_GetPortAttributesByWWN(
2450 HBA_HANDLE handle,
2451 HBA_WWN PortWWN,
2452 HBA_PORTATTRIBUTES *portattributes)
2453 {
2454 HBA_STATUS status;
2455 HBA_LIBRARY_INFO *lib_infop;
2456 HBA_HANDLE vendorHandle;
2457 HBAGetPortAttributesByWWNFunc
2458 GetPortAttributesByWWNFunc;
2459
2460 DEBUG(2, "HBA_GetPortAttributesByWWN: %s", WWN2STR1(&PortWWN), 0, 0);
2461
2462 CHECKLIBRARY();
2463 if (lib_infop->version == SMHBA) {
2464 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2465 }
2466
2467 GetPortAttributesByWWNFunc =
2468 lib_infop->ftable.functionTable.GetPortAttributesByWWNHandler;
2469 if (GetPortAttributesByWWNFunc != NULL) {
2470 status = ((GetPortAttributesByWWNFunc)
2471 (vendorHandle, PortWWN, portattributes));
2472 } else {
2473 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2474 }
2475 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2476 }
2477
2478 HBA_STATUS
2479 HBA_SendCTPassThru(
2480 HBA_HANDLE handle,
2481 void *pReqBuffer,
2482 HBA_UINT32 ReqBufferSize,
2483 void *pRspBuffer,
2484 HBA_UINT32 RspBufferSize)
2485 {
2486 HBA_STATUS status;
2487 HBA_LIBRARY_INFO *lib_infop;
2488 HBA_HANDLE vendorHandle;
2489 HBASendCTPassThruFunc
2490 SendCTPassThruFunc;
2491
2492 DEBUG(2, "HBA_SendCTPassThru", 0, 0, 0);
2493
2494 CHECKLIBRARY();
2495 if (lib_infop->version == SMHBA) {
2496 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2497 }
2498
2499 SendCTPassThruFunc =
2500 lib_infop->ftable.functionTable.SendCTPassThruHandler;
2501 if (SendCTPassThruFunc != NULL) {
2502 status = (SendCTPassThruFunc)
2503 (vendorHandle,
2504 pReqBuffer, ReqBufferSize,
2505 pRspBuffer, RspBufferSize);
2506 } else {
2507 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2508 }
2509 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2510 }
2511
2512 HBA_STATUS
2513 HBA_SendCTPassThruV2(
2514 HBA_HANDLE handle,
2515 HBA_WWN hbaPortWWN,
2516 void *pReqBuffer,
2517 HBA_UINT32 ReqBufferSize,
2518 void *pRspBuffer,
2519 HBA_UINT32 *pRspBufferSize)
2520 {
2521 HBA_STATUS status;
2522 HBA_LIBRARY_INFO *lib_infop;
2523 HBA_HANDLE vendorHandle;
2524 HBASendCTPassThruV2Func
2525 registeredfunc;
2526
2527 DEBUG(2, "HBA_SendCTPassThruV2m hbaPortWWN: %s",
2528 WWN2STR1(&hbaPortWWN), 0, 0);
2529
2530 CHECKLIBRARYANDVERSION(HBAAPIV2);
2531 registeredfunc = FUNCCOMMON(lib_infop, SendCTPassThruV2Handler);
2532 if (registeredfunc != NULL) {
2533 status = (registeredfunc)
2534 (vendorHandle, hbaPortWWN,
2535 pReqBuffer, ReqBufferSize,
2536 pRspBuffer, pRspBufferSize);
2537 } else {
2538 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2539 }
2540 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2541 }
2542
2543 HBA_STATUS
2544 HBA_GetEventBuffer(
2545 HBA_HANDLE handle,
2546 PHBA_EVENTINFO EventBuffer,
2547 HBA_UINT32 *EventBufferCount)
2548 {
2549 HBA_STATUS status;
2550 HBA_LIBRARY_INFO *lib_infop;
2551 HBA_HANDLE vendorHandle;
2552 HBAGetEventBufferFunc
2553 GetEventBufferFunc;
2554
2555 DEBUG(2, "HBA_GetEventBuffer", 0, 0, 0);
2556
2557 CHECKLIBRARY();
2558 if (lib_infop->version == SMHBA) {
2559 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2560 }
2561
2562 GetEventBufferFunc =
2563 lib_infop->ftable.functionTable.GetEventBufferHandler;
2564 if (GetEventBufferFunc != NULL) {
2565 status = (GetEventBufferFunc)
2566 (vendorHandle, EventBuffer, EventBufferCount);
2567 } else {
2568 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2569 }
2570 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2571 }
2572
2573 HBA_STATUS
2574 HBA_SetRNIDMgmtInfo(HBA_HANDLE handle, HBA_MGMTINFO Info) {
2575 HBA_STATUS status;
2576 HBA_LIBRARY_INFO *lib_infop;
2577 HBA_HANDLE vendorHandle;
2578 HBASetRNIDMgmtInfoFunc
2579 SetRNIDMgmtInfoFunc;
2580
2581 DEBUG(2, "HBA_SetRNIDMgmtInfo", 0, 0, 0);
2582
2583 CHECKLIBRARY();
2584 SetRNIDMgmtInfoFunc = FUNCCOMMON(lib_infop, SetRNIDMgmtInfoHandler);
2585 if (SetRNIDMgmtInfoFunc != NULL) {
2586 status = (SetRNIDMgmtInfoFunc)(vendorHandle, Info);
2587 } else {
2588 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2589 }
2590 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2591 }
2592
2593 HBA_STATUS
2594 HBA_GetRNIDMgmtInfo(HBA_HANDLE handle, HBA_MGMTINFO *pInfo) {
2595 HBA_STATUS status;
2596 HBA_LIBRARY_INFO *lib_infop;
2597 HBA_HANDLE vendorHandle;
2598 HBAGetRNIDMgmtInfoFunc
2599 GetRNIDMgmtInfoFunc;
2600
2601 DEBUG(2, "HBA_GetRNIDMgmtInfo", 0, 0, 0);
2602
2603 CHECKLIBRARY();
2604 GetRNIDMgmtInfoFunc = FUNCCOMMON(lib_infop, GetRNIDMgmtInfoHandler);
2605 if (GetRNIDMgmtInfoFunc != NULL) {
2606 status = (GetRNIDMgmtInfoFunc)(vendorHandle, pInfo);
2607 } else {
2608 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2609 }
2610 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2611 }
2612
2613 HBA_STATUS
2614 HBA_SendRNID(
2615 HBA_HANDLE handle,
2616 HBA_WWN wwn,
2617 HBA_WWNTYPE wwntype,
2618 void *pRspBuffer,
2619 HBA_UINT32 *pRspBufferSize)
2620 {
2621 HBA_STATUS status;
2622 HBA_LIBRARY_INFO *lib_infop;
2623 HBA_HANDLE vendorHandle;
2624 HBASendRNIDFunc SendRNIDFunc;
2625
2626 DEBUG(2, "HBA_SendRNID for wwn: %s", WWN2STR1(&wwn), 0, 0);
2627
2628 CHECKLIBRARY();
2629 if (lib_infop->version == SMHBA) {
2630 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2631 }
2632
2633 SendRNIDFunc = lib_infop->ftable.functionTable.SendRNIDHandler;
2634 if (SendRNIDFunc != NULL) {
2635 status = ((SendRNIDFunc)(vendorHandle, wwn, wwntype,
2636 pRspBuffer, pRspBufferSize));
2637 } else {
2638 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2639 }
2640 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2641 }
2642
2643 HBA_STATUS
2644 HBA_SendRNIDV2(
2645 HBA_HANDLE handle,
2646 HBA_WWN hbaPortWWN,
2647 HBA_WWN destWWN,
2648 HBA_UINT32 destFCID,
2649 HBA_UINT32 NodeIdDataFormat,
2650 void *pRspBuffer,
2651 HBA_UINT32 *pRspBufferSize)
2652 {
2653 HBA_STATUS status;
2654 HBA_LIBRARY_INFO *lib_infop;
2655 HBA_HANDLE vendorHandle;
2656 HBASendRNIDV2Func registeredfunc;
2657
2658 DEBUG(2, "HBA_SendRNIDV2, hbaPortWWN: %s", WWN2STR1(&hbaPortWWN), 0, 0);
2659
2660 CHECKLIBRARY();
2661 registeredfunc = FUNCCOMMON(lib_infop, SendRNIDV2Handler);
2662 if (registeredfunc != NULL) {
2663 status = (registeredfunc)
2664 (vendorHandle, hbaPortWWN, destWWN, destFCID, NodeIdDataFormat,
2665 pRspBuffer, pRspBufferSize);
2666 } else {
2667 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2668 }
2669 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2670 }
2671
2672 void
2673 HBA_RefreshInformation(HBA_HANDLE handle) {
2674 HBA_STATUS status;
2675 HBA_LIBRARY_INFO *lib_infop;
2676 HBA_HANDLE vendorHandle;
2677 HBARefreshInformationFunc
2678 RefreshInformationFunc;
2679
2680 DEBUG(2, "HBA_RefreshInformation", 0, 0, 0);
2681
2682 status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
2683 if (status == HBA_STATUS_OK) {
2684 RefreshInformationFunc =
2685 FUNCCOMMON(lib_infop, RefreshInformationHandler);
2686 if (RefreshInformationFunc != NULL) {
2687 ((RefreshInformationFunc)(vendorHandle));
2688 }
2689 RELEASE_MUTEX(&_hbaapi_LL_mutex);
2690 }
2691 }
2692
2693 void
2694 HBA_ResetStatistics(HBA_HANDLE handle, HBA_UINT32 portindex) {
2695 HBA_STATUS status;
2696 HBA_LIBRARY_INFO *lib_infop;
2697 HBA_HANDLE vendorHandle;
2698 HBAResetStatisticsFunc
2699 ResetStatisticsFunc;
2700
2701 DEBUG(2, "HBA_ResetStatistics", 0, 0, 0);
2702
2703 status = HBA_CheckLibrary(handle, &lib_infop, &vendorHandle);
2704 if (status == HBA_STATUS_OK) {
2705 if (lib_infop->version == SMHBA) {
2706 RELEASE_MUTEX(&_hbaapi_LL_mutex);
2707 }
2708
2709 ResetStatisticsFunc =
2710 lib_infop->ftable.functionTable.ResetStatisticsHandler;
2711 if (ResetStatisticsFunc != NULL) {
2712 ((ResetStatisticsFunc)(vendorHandle, portindex));
2713 }
2714 RELEASE_MUTEX(&_hbaapi_LL_mutex);
2715 }
2716 }
2717
2718 HBA_STATUS
2719 HBA_GetFcpTargetMapping(HBA_HANDLE handle, PHBA_FCPTARGETMAPPING mapping) {
2720 HBA_STATUS status;
2721 HBA_LIBRARY_INFO *lib_infop;
2722 HBA_HANDLE vendorHandle;
2723 HBAGetFcpTargetMappingFunc GetFcpTargetMappingFunc;
2724
2725 DEBUG(2, "HBA_GetFcpTargetMapping", 0, 0, 0);
2726
2727 CHECKLIBRARY();
2728 if (lib_infop->version == SMHBA) {
2729 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2730 }
2731
2732 GetFcpTargetMappingFunc =
2733 lib_infop->ftable.functionTable.GetFcpTargetMappingHandler;
2734 if (GetFcpTargetMappingFunc != NULL) {
2735 status = ((GetFcpTargetMappingFunc)(vendorHandle, mapping));
2736 } else {
2737 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2738 }
2739 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2740 }
2741
2742 HBA_STATUS
2743 HBA_GetFcpTargetMappingV2(
2744 HBA_HANDLE handle,
2745 HBA_WWN hbaPortWWN,
2746 HBA_FCPTARGETMAPPINGV2 *pmapping)
2747 {
2748 HBA_STATUS status;
2749 HBA_LIBRARY_INFO *lib_infop;
2750 HBA_HANDLE vendorHandle;
2751 HBAGetFcpTargetMappingV2Func
2752 registeredfunc;
2753
2754 DEBUG(2, "HBA_GetFcpTargetMapping", 0, 0, 0);
2755
2756 CHECKLIBRARYANDVERSION(HBAAPIV2);
2757
2758 registeredfunc =
2759 lib_infop->ftable.functionTable.GetFcpTargetMappingV2Handler;
2760 if (registeredfunc != NULL) {
2761 status = ((registeredfunc)(vendorHandle, hbaPortWWN, pmapping));
2762 } else {
2763 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2764 }
2765 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2766 }
2767
2768 HBA_STATUS
2769 HBA_GetFcpPersistentBinding(HBA_HANDLE handle, PHBA_FCPBINDING binding) {
2770 HBA_STATUS status;
2771 HBA_LIBRARY_INFO *lib_infop;
2772 HBA_HANDLE vendorHandle;
2773 HBAGetFcpPersistentBindingFunc
2774 GetFcpPersistentBindingFunc;
2775
2776 DEBUG(2, "HBA_GetFcpPersistentBinding", 0, 0, 0);
2777
2778 CHECKLIBRARY();
2779 if (lib_infop->version == SMHBA) {
2780 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2781 }
2782
2783 GetFcpPersistentBindingFunc =
2784 lib_infop->ftable.functionTable.GetFcpPersistentBindingHandler;
2785 if (GetFcpPersistentBindingFunc != NULL) {
2786 status = ((GetFcpPersistentBindingFunc)(vendorHandle, binding));
2787 } else {
2788 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2789 }
2790 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2791 }
2792
2793 HBA_STATUS
2794 HBA_ScsiInquiryV2(
2795 HBA_HANDLE handle,
2796 HBA_WWN hbaPortWWN,
2797 HBA_WWN discoveredPortWWN,
2798 HBA_UINT64 fcLUN,
2799 HBA_UINT8 CDB_Byte1,
2800 HBA_UINT8 CDB_Byte2,
2801 void *pRspBuffer,
2802 HBA_UINT32 *pRspBufferSize,
2803 HBA_UINT8 *pScsiStatus,
2804 void *pSenseBuffer,
2805 HBA_UINT32 *pSenseBufferSize)
2806 {
2807 HBA_STATUS status;
2808 HBA_LIBRARY_INFO *lib_infop;
2809 HBA_HANDLE vendorHandle;
2810 HBAScsiInquiryV2Func ScsiInquiryV2Func;
2811
2812 DEBUG(2, "HBA_ScsiInquiryV2 to discoveredPortWWN: %s",
2813 WWN2STR1(&discoveredPortWWN), 0, 0);
2814
2815 CHECKLIBRARYANDVERSION(HBAAPIV2);
2816
2817 ScsiInquiryV2Func =
2818 lib_infop->ftable.functionTable.ScsiInquiryV2Handler;
2819 if (ScsiInquiryV2Func != NULL) {
2820 status = ((ScsiInquiryV2Func)(
2821 vendorHandle, hbaPortWWN, discoveredPortWWN, fcLUN, CDB_Byte1,
2822 CDB_Byte2, pRspBuffer, pRspBufferSize, pScsiStatus,
2823 pSenseBuffer, pSenseBufferSize));
2824 } else {
2825 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2826 }
2827 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2828 }
2829
2830 HBA_STATUS
2831 HBA_SendScsiInquiry(
2832 HBA_HANDLE handle,
2833 HBA_WWN PortWWN,
2834 HBA_UINT64 fcLUN,
2835 HBA_UINT8 EVPD,
2836 HBA_UINT32 PageCode,
2837 void *pRspBuffer,
2838 HBA_UINT32 RspBufferSize,
2839 void *pSenseBuffer,
2840 HBA_UINT32 SenseBufferSize)
2841 {
2842 HBA_STATUS status;
2843 HBA_LIBRARY_INFO *lib_infop;
2844 HBA_HANDLE vendorHandle;
2845 HBASendScsiInquiryFunc SendScsiInquiryFunc;
2846
2847 DEBUG(2, "HBA_SendScsiInquiry to PortWWN: %s",
2848 WWN2STR1(&PortWWN), 0, 0);
2849
2850 CHECKLIBRARY();
2851 if (lib_infop->version == SMHBA) {
2852 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2853 }
2854
2855 SendScsiInquiryFunc =
2856 lib_infop->ftable.functionTable.ScsiInquiryHandler;
2857 if (SendScsiInquiryFunc != NULL) {
2858 status = ((SendScsiInquiryFunc)(
2859 vendorHandle, PortWWN, fcLUN, EVPD, PageCode, pRspBuffer,
2860 RspBufferSize, pSenseBuffer, SenseBufferSize));
2861 } else {
2862 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2863 }
2864 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2865 }
2866
2867 HBA_STATUS
2868 HBA_ScsiReportLUNsV2(
2869 HBA_HANDLE handle,
2870 HBA_WWN hbaPortWWN,
2871 HBA_WWN discoveredPortWWN,
2872 void *pRespBuffer,
2873 HBA_UINT32 *pRespBufferSize,
2874 HBA_UINT8 *pScsiStatus,
2875 void *pSenseBuffer,
2876 HBA_UINT32 *pSenseBufferSize)
2877 {
2878 HBA_STATUS status;
2879 HBA_LIBRARY_INFO *lib_infop;
2880 HBA_HANDLE vendorHandle;
2881 HBAScsiReportLUNsV2Func ScsiReportLUNsV2Func;
2882
2883 DEBUG(2, "HBA_ScsiReportLUNsV2 to discoveredPortWWN: %s",
2884 WWN2STR1(&discoveredPortWWN), 0, 0);
2885
2886 CHECKLIBRARYANDVERSION(HBAAPIV2);
2887
2888 ScsiReportLUNsV2Func =
2889 lib_infop->ftable.functionTable.ScsiReportLUNsV2Handler;
2890 if (ScsiReportLUNsV2Func != NULL) {
2891 status = ((ScsiReportLUNsV2Func)(
2892 vendorHandle, hbaPortWWN, discoveredPortWWN,
2893 pRespBuffer, pRespBufferSize,
2894 pScsiStatus,
2895 pSenseBuffer, pSenseBufferSize));
2896 } else {
2897 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2898 }
2899 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2900 }
2901
2902 HBA_STATUS
2903 HBA_SendReportLUNs(
2904 HBA_HANDLE handle,
2905 HBA_WWN portWWN,
2906 void *pRspBuffer,
2907 HBA_UINT32 RspBufferSize,
2908 void *pSenseBuffer,
2909 HBA_UINT32 SenseBufferSize)
2910 {
2911 HBA_STATUS status;
2912 HBA_LIBRARY_INFO *lib_infop;
2913 HBA_HANDLE vendorHandle;
2914 HBASendReportLUNsFunc SendReportLUNsFunc;
2915
2916 DEBUG(2, "HBA_SendReportLUNs to PortWWN: %s", WWN2STR1(&portWWN), 0, 0);
2917
2918 CHECKLIBRARY();
2919 if (lib_infop->version == SMHBA) {
2920 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2921 }
2922
2923 SendReportLUNsFunc = lib_infop->ftable.functionTable.ReportLUNsHandler;
2924 if (SendReportLUNsFunc != NULL) {
2925 status = ((SendReportLUNsFunc)(
2926 vendorHandle, portWWN, pRspBuffer,
2927 RspBufferSize, pSenseBuffer, SenseBufferSize));
2928 } else {
2929 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2930 }
2931 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2932 }
2933
2934 HBA_STATUS
2935 HBA_ScsiReadCapacityV2(
2936 HBA_HANDLE handle,
2937 HBA_WWN hbaPortWWN,
2938 HBA_WWN discoveredPortWWN,
2939 HBA_UINT64 fcLUN,
2940 void *pRspBuffer,
2941 HBA_UINT32 *pRspBufferSize,
2942 HBA_UINT8 *pScsiStatus,
2943 void *pSenseBuffer,
2944 HBA_UINT32 *SenseBufferSize)
2945 {
2946 HBA_STATUS status;
2947 HBA_LIBRARY_INFO *lib_infop;
2948 HBA_HANDLE vendorHandle;
2949 HBAScsiReadCapacityV2Func ScsiReadCapacityV2Func;
2950
2951 DEBUG(2, "HBA_ScsiReadCapacityV2 to discoveredPortWWN: %s",
2952 WWN2STR1(&discoveredPortWWN), 0, 0);
2953
2954 CHECKLIBRARYANDVERSION(HBAAPIV2);
2955
2956 ScsiReadCapacityV2Func =
2957 lib_infop->ftable.functionTable.ScsiReadCapacityV2Handler;
2958 if (ScsiReadCapacityV2Func != NULL) {
2959 status = ((ScsiReadCapacityV2Func)(
2960 vendorHandle, hbaPortWWN, discoveredPortWWN, fcLUN,
2961 pRspBuffer, pRspBufferSize,
2962 pScsiStatus,
2963 pSenseBuffer, SenseBufferSize));
2964 } else {
2965 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
2966 }
2967 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
2968 }
2969
2970 HBA_STATUS
2971 HBA_SendReadCapacity(
2972 HBA_HANDLE handle,
2973 HBA_WWN portWWN,
2974 HBA_UINT64 fcLUN,
2975 void *pRspBuffer,
2976 HBA_UINT32 RspBufferSize,
2977 void *pSenseBuffer,
2978 HBA_UINT32 SenseBufferSize)
2979 {
2980 HBA_STATUS status;
2981 HBA_LIBRARY_INFO *lib_infop;
2982 HBA_HANDLE vendorHandle;
2983 HBASendReadCapacityFunc SendReadCapacityFunc;
2984
2985 DEBUG(2, "HBA_SendReadCapacity to portWWN: %s",
2986 WWN2STR1(&portWWN), 0, 0);
2987
2988 CHECKLIBRARY();
2989 if (lib_infop->version == SMHBA) {
2990 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_INCOMPATIBLE);
2991 }
2992
2993 SendReadCapacityFunc =
2994 lib_infop->ftable.functionTable.ReadCapacityHandler;
2995 if (SendReadCapacityFunc != NULL) {
2996 status = ((SendReadCapacityFunc)
2997 (vendorHandle, portWWN, fcLUN, pRspBuffer,
2998 RspBufferSize, pSenseBuffer, SenseBufferSize));
2999 } else {
3000 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3001 }
3002 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3003 }
3004
3005 HBA_STATUS
3006 HBA_SendRPL(
3007 HBA_HANDLE handle,
3008 HBA_WWN hbaPortWWN,
3009 HBA_WWN agent_wwn,
3010 HBA_UINT32 agent_domain,
3011 HBA_UINT32 portindex,
3012 void *pRspBuffer,
3013 HBA_UINT32 *pRspBufferSize)
3014 {
3015 HBA_STATUS status;
3016 HBA_LIBRARY_INFO *lib_infop;
3017 HBA_HANDLE vendorHandle;
3018 HBASendRPLFunc registeredfunc;
3019
3020 DEBUG(2, "HBA_SendRPL to agent_wwn: %s:%d",
3021 WWN2STR1(&agent_wwn), agent_domain, 0);
3022
3023 CHECKLIBRARY();
3024 registeredfunc = FUNCCOMMON(lib_infop, SendRPLHandler);
3025 if (registeredfunc != NULL) {
3026 status = (registeredfunc)(
3027 vendorHandle, hbaPortWWN, agent_wwn, agent_domain, portindex,
3028 pRspBuffer, pRspBufferSize);
3029 } else {
3030 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3031 }
3032 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3033 }
3034
3035 HBA_STATUS
3036 HBA_SendRPS(
3037 HBA_HANDLE handle,
3038 HBA_WWN hbaPortWWN,
3039 HBA_WWN agent_wwn,
3040 HBA_UINT32 agent_domain,
3041 HBA_WWN object_wwn,
3042 HBA_UINT32 object_port_number,
3043 void *pRspBuffer,
3044 HBA_UINT32 *pRspBufferSize)
3045 {
3046 HBA_STATUS status;
3047 HBA_LIBRARY_INFO *lib_infop;
3048 HBA_HANDLE vendorHandle;
3049 HBASendRPSFunc registeredfunc;
3050
3051 DEBUG(2, "HBA_SendRPS to agent_wwn: %s:%d",
3052 WWN2STR1(&agent_wwn), agent_domain, 0);
3053
3054 CHECKLIBRARY();
3055 registeredfunc = FUNCCOMMON(lib_infop, SendRPSHandler);
3056 if (registeredfunc != NULL) {
3057 status = (registeredfunc)(
3058 vendorHandle, hbaPortWWN, agent_wwn, agent_domain,
3059 object_wwn, object_port_number,
3060 pRspBuffer, pRspBufferSize);
3061 } else {
3062 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3063 }
3064 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3065 }
3066
3067 HBA_STATUS
3068 HBA_SendSRL(
3069 HBA_HANDLE handle,
3070 HBA_WWN hbaPortWWN,
3071 HBA_WWN wwn,
3072 HBA_UINT32 domain,
3073 void *pRspBuffer,
3074 HBA_UINT32 *pRspBufferSize)
3075 {
3076 HBA_STATUS status;
3077 HBA_LIBRARY_INFO *lib_infop;
3078 HBA_HANDLE vendorHandle;
3079 HBASendSRLFunc registeredfunc;
3080
3081 DEBUG(2, "HBA_SendSRL to wwn:%s domain:%d", WWN2STR1(&wwn), domain, 0);
3082
3083 CHECKLIBRARY();
3084 registeredfunc = FUNCCOMMON(lib_infop, SendSRLHandler);
3085 if (registeredfunc != NULL) {
3086 status = (registeredfunc)(
3087 vendorHandle, hbaPortWWN, wwn, domain,
3088 pRspBuffer, pRspBufferSize);
3089 } else {
3090 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3091 }
3092 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3093 }
3094 HBA_STATUS
3095 HBA_SendRLS(
3096 HBA_HANDLE handle,
3097 HBA_WWN hbaPortWWN,
3098 HBA_WWN destWWN,
3099 void *pRspBuffer,
3100 HBA_UINT32 *pRspBufferSize)
3101 {
3102 HBA_STATUS status;
3103 HBA_LIBRARY_INFO *lib_infop;
3104 HBA_HANDLE vendorHandle;
3105 HBASendRLSFunc registeredfunc;
3106
3107 DEBUG(2, "HBA_SendRLS dest_wwn: %s",
3108 WWN2STR1(&destWWN), 0, 0);
3109
3110 CHECKLIBRARY();
3111 registeredfunc = FUNCCOMMON(lib_infop, SendRLSHandler);
3112 if (registeredfunc != NULL) {
3113 status = (registeredfunc)(
3114 vendorHandle, hbaPortWWN, destWWN,
3115 pRspBuffer, pRspBufferSize);
3116 } else {
3117 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3118 }
3119 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3120 }
3121
3122 HBA_STATUS
3123 HBA_SendLIRR(
3124 HBA_HANDLE handle,
3125 HBA_WWN sourceWWN,
3126 HBA_WWN destWWN,
3127 HBA_UINT8 function,
3128 HBA_UINT8 type,
3129 void *pRspBuffer,
3130 HBA_UINT32 *pRspBufferSize)
3131 {
3132 HBA_STATUS status;
3133 HBA_LIBRARY_INFO *lib_infop;
3134 HBA_HANDLE vendorHandle;
3135 HBASendLIRRFunc registeredfunc;
3136
3137 DEBUG(2, "HBA_SendLIRR destWWN:%s", WWN2STR1(&destWWN), 0, 0);
3138
3139 CHECKLIBRARY();
3140 registeredfunc = FUNCCOMMON(lib_infop, SendLIRRHandler);
3141 if (registeredfunc != NULL) {
3142 status = (registeredfunc)(
3143 vendorHandle, sourceWWN, destWWN, function, type,
3144 pRspBuffer, pRspBufferSize);
3145 } else {
3146 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3147 }
3148 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3149 }
3150
3151 HBA_STATUS
3152 HBA_GetBindingCapability(
3153 HBA_HANDLE handle,
3154 HBA_WWN hbaPortWWN,
3155 HBA_BIND_CAPABILITY *pcapability)
3156 {
3157 HBA_STATUS status;
3158 HBA_LIBRARY_INFO *lib_infop;
3159 HBA_HANDLE vendorHandle;
3160 HBAGetBindingCapabilityFunc
3161 registeredfunc;
3162
3163 DEBUG(2, "HBA_GetBindingCapability", 0, 0, 0);
3164
3165 CHECKLIBRARYANDVERSION(HBAAPIV2);
3166
3167 registeredfunc =
3168 lib_infop->ftable.functionTable.GetBindingCapabilityHandler;
3169 if (registeredfunc != NULL) {
3170 status = (registeredfunc)(vendorHandle, hbaPortWWN, pcapability);
3171 } else {
3172 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3173 }
3174 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3175 }
3176
3177 HBA_STATUS
3178 HBA_GetBindingSupport(
3179 HBA_HANDLE handle,
3180 HBA_WWN hbaPortWWN,
3181 HBA_BIND_CAPABILITY *pcapability)
3182 {
3183 HBA_STATUS status;
3184 HBA_LIBRARY_INFO *lib_infop;
3185 HBA_HANDLE vendorHandle;
3186 HBAGetBindingSupportFunc
3187 registeredfunc;
3188
3189 DEBUG(2, "HBA_GetBindingSupport", 0, 0, 0);
3190
3191 CHECKLIBRARYANDVERSION(HBAAPIV2);
3192
3193 registeredfunc =
3194 lib_infop->ftable.functionTable.GetBindingSupportHandler;
3195 if (registeredfunc != NULL) {
3196 status = (registeredfunc)(vendorHandle, hbaPortWWN, pcapability);
3197 } else {
3198 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3199 }
3200 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3201 }
3202
3203 HBA_STATUS
3204 HBA_SetBindingSupport(
3205 HBA_HANDLE handle,
3206 HBA_WWN hbaPortWWN,
3207 HBA_BIND_CAPABILITY capability)
3208 {
3209 HBA_STATUS status;
3210 HBA_LIBRARY_INFO *lib_infop;
3211 HBA_HANDLE vendorHandle;
3212 HBASetBindingSupportFunc
3213 registeredfunc;
3214
3215 DEBUG(2, "HBA_SetBindingSupport", 0, 0, 0);
3216
3217 CHECKLIBRARYANDVERSION(HBAAPIV2);
3218
3219 registeredfunc =
3220 lib_infop->ftable.functionTable.SetBindingSupportHandler;
3221 if (registeredfunc != NULL) {
3222 status = (registeredfunc)(vendorHandle, hbaPortWWN, capability);
3223 } else {
3224 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3225 }
3226 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3227 }
3228
3229 HBA_STATUS
3230 HBA_SetPersistentBindingV2(
3231 HBA_HANDLE handle,
3232 HBA_WWN hbaPortWWN,
3233 const HBA_FCPBINDING2 *pbinding)
3234 {
3235 HBA_STATUS status;
3236 HBA_LIBRARY_INFO *lib_infop;
3237 HBA_HANDLE vendorHandle;
3238 HBASetPersistentBindingV2Func
3239 registeredfunc;
3240
3241 DEBUG(2, "HBA_SetPersistentBindingV2 port: %s",
3242 WWN2STR1(&hbaPortWWN), 0, 0);
3243
3244 CHECKLIBRARYANDVERSION(HBAAPIV2);
3245
3246 registeredfunc =
3247 lib_infop->ftable.functionTable.SetPersistentBindingV2Handler;
3248 if (registeredfunc != NULL) {
3249 status = (registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
3250 } else {
3251 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3252 }
3253 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3254 }
3255
3256 HBA_STATUS
3257 HBA_GetPersistentBindingV2(
3258 HBA_HANDLE handle,
3259 HBA_WWN hbaPortWWN,
3260 HBA_FCPBINDING2 *pbinding)
3261 {
3262 HBA_STATUS status;
3263 HBA_LIBRARY_INFO *lib_infop;
3264 HBA_HANDLE vendorHandle;
3265 HBAGetPersistentBindingV2Func
3266 registeredfunc;
3267
3268 DEBUG(2, "HBA_GetPersistentBindingV2 port: %s",
3269 WWN2STR1(&hbaPortWWN), 0, 0);
3270
3271 CHECKLIBRARYANDVERSION(HBAAPIV2);
3272
3273 registeredfunc =
3274 lib_infop->ftable.functionTable.GetPersistentBindingV2Handler;
3275 if (registeredfunc != NULL) {
3276 status = (registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
3277 } else {
3278 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3279 }
3280 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3281 }
3282
3283 HBA_STATUS
3284 HBA_RemovePersistentBinding(
3285 HBA_HANDLE handle,
3286 HBA_WWN hbaPortWWN,
3287 const HBA_FCPBINDING2
3288 *pbinding)
3289 {
3290 HBA_STATUS status;
3291 HBA_LIBRARY_INFO *lib_infop;
3292 HBA_HANDLE vendorHandle;
3293 HBARemovePersistentBindingFunc
3294 registeredfunc;
3295
3296 DEBUG(2, "HBA_RemovePersistentBinding", 0, 0, 0);
3297
3298 CHECKLIBRARYANDVERSION(HBAAPIV2);
3299
3300 registeredfunc =
3301 lib_infop->ftable.functionTable.RemovePersistentBindingHandler;
3302 if (registeredfunc != NULL) {
3303 status = (registeredfunc)(vendorHandle, hbaPortWWN, pbinding);
3304 } else {
3305 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3306 }
3307 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3308 }
3309
3310 HBA_STATUS
3311 HBA_RemoveAllPersistentBindings(
3312 HBA_HANDLE handle,
3313 HBA_WWN hbaPortWWN)
3314 {
3315 HBA_STATUS status;
3316 HBA_LIBRARY_INFO *lib_infop;
3317 HBA_HANDLE vendorHandle;
3318 HBARemoveAllPersistentBindingsFunc
3319 registeredfunc;
3320
3321 DEBUG(2, "HBA_RemoveAllPersistentBindings", 0, 0, 0);
3322
3323 CHECKLIBRARYANDVERSION(HBAAPIV2);
3324
3325 registeredfunc =
3326 lib_infop->ftable.functionTable.RemoveAllPersistentBindingsHandler;
3327 if (registeredfunc != NULL) {
3328 status = (registeredfunc)(vendorHandle, hbaPortWWN);
3329 } else {
3330 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3331 }
3332 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3333 }
3334
3335 HBA_STATUS
3336 HBA_GetFC4Statistics(
3337 HBA_HANDLE handle,
3338 HBA_WWN portWWN,
3339 HBA_UINT8 FC4type,
3340 HBA_FC4STATISTICS *pstatistics)
3341 {
3342 HBA_STATUS status;
3343 HBA_LIBRARY_INFO *lib_infop;
3344 HBA_HANDLE vendorHandle;
3345 HBAGetFC4StatisticsFunc
3346 registeredfunc;
3347
3348 DEBUG(2, "HBA_GetFC4Statistics port: %s", WWN2STR1(&portWWN), 0, 0);
3349
3350 CHECKLIBRARYANDVERSION(HBAAPIV2);
3351
3352 registeredfunc =
3353 lib_infop->ftable.functionTable.GetFC4StatisticsHandler;
3354 if (registeredfunc != NULL) {
3355 status = (registeredfunc)
3356 (vendorHandle, portWWN, FC4type, pstatistics);
3357 } else {
3358 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3359 }
3360 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3361 }
3362
3363 HBA_STATUS
3364 HBA_GetFCPStatistics(
3365 HBA_HANDLE handle,
3366 const HBA_SCSIID *lunit,
3367 HBA_FC4STATISTICS *pstatistics)
3368 {
3369 HBA_STATUS status;
3370 HBA_LIBRARY_INFO *lib_infop;
3371 HBA_HANDLE vendorHandle;
3372 HBAGetFCPStatisticsFunc
3373 registeredfunc;
3374
3375 DEBUG(2, "HBA_GetFCPStatistics", 0, 0, 0);
3376
3377 CHECKLIBRARYANDVERSION(HBAAPIV2);
3378
3379 registeredfunc =
3380 lib_infop->ftable.functionTable.GetFCPStatisticsHandler;
3381 if (registeredfunc != NULL) {
3382 status = (registeredfunc)(vendorHandle, lunit, pstatistics);
3383 } else {
3384 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3385 }
3386 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3387 }
3388
3389 HBA_UINT32
3390 HBA_GetVendorLibraryAttributes(
3391 HBA_UINT32 adapter_index,
3392 HBA_LIBRARYATTRIBUTES *attributes)
3393 {
3394 HBA_ADAPTER_INFO *adapt_infop;
3395 HBAGetVendorLibraryAttributesFunc
3396 registeredfunc;
3397 HBA_UINT32 ret = 0;
3398
3399 DEBUG(2, "HBA_GetVendorLibraryAttributes adapterindex:%d",
3400 adapter_index, 0, 0);
3401 if (_hbaapi_librarylist == NULL) {
3402 DEBUG(1, "HBAAPI not loaded yet.", 0, 0, 0);
3403 return (0);
3404 }
3405
3406 if (attributes == NULL) {
3407 DEBUG(1,
3408 "HBA_GetVendorLibraryAttributes: NULL pointer attributes",
3409 0, 0, 0);
3410 return (HBA_STATUS_ERROR_ARG);
3411 }
3412
3413 (void) memset(attributes, 0, sizeof (HBA_LIBRARYATTRIBUTES));
3414
3415 GRAB_MUTEX(&_hbaapi_LL_mutex);
3416 GRAB_MUTEX(&_hbaapi_AL_mutex);
3417 for (adapt_infop = _hbaapi_adapterlist;
3418 adapt_infop != NULL;
3419 adapt_infop = adapt_infop->next) {
3420
3421 if (adapt_infop->index == adapter_index) {
3422
3423 if (adapt_infop->library->version == SMHBA) {
3424 RELEASE_MUTEX(&_hbaapi_AL_mutex);
3425 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex,
3426 HBA_STATUS_ERROR_INCOMPATIBLE);
3427 }
3428
3429 registeredfunc = adapt_infop->library->
3430 ftable.functionTable.GetVendorLibraryAttributesHandler;
3431 if (registeredfunc != NULL) {
3432 ret = (registeredfunc)(attributes);
3433 } else {
3434 /* Version 1 libary? */
3435 HBAGetVersionFunc GetVersionFunc;
3436 GetVersionFunc = adapt_infop->library->
3437 ftable.functionTable.GetVersionHandler;
3438 if (GetVersionFunc != NULL) {
3439 ret = ((GetVersionFunc)());
3440 }
3441 #ifdef NOTDEF
3442 else {
3443 /* This should not happen, dont think its going to */
3444 }
3445 #endif
3446 }
3447 if (attributes->LibPath[0] == '\0') {
3448 if (strlen(adapt_infop->library->LibraryPath) < 256) {
3449 (void) strcpy(attributes->LibPath,
3450 adapt_infop->library->LibraryPath);
3451 }
3452 }
3453 break;
3454 }
3455 }
3456 RELEASE_MUTEX(&_hbaapi_AL_mutex);
3457 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, ret);
3458 }
3459
3460
3461 /*
3462 * This function returns SM-HBA version that the warpper library implemented.
3463 */
3464 HBA_UINT32
3465 SMHBA_GetVersion() {
3466 DEBUG(2, "SMHBA_GetVersion", 0, 0, 0);
3467 return (SMHBA_LIBVERSION);
3468 }
3469
3470 /*
3471 * This function returns the attributes for the warpper library.
3472 */
3473 HBA_UINT32
3474 SMHBA_GetWrapperLibraryAttributes(
3475 SMHBA_LIBRARYATTRIBUTES *attributes)
3476 {
3477
3478 struct timeval tv;
3479 struct tm tp;
3480
3481 DEBUG(2, "SMHBA_GetWrapperLibraryAttributes", 0, 0, 0);
3482
3483 if (attributes == NULL) {
3484 DEBUG(1, "SMHBA_GetWrapperLibraryAttributes: "
3485 "NULL pointer attributes",
3486 0, 0, 0);
3487 return (HBA_STATUS_ERROR_ARG);
3488 }
3489
3490 (void) memset(attributes, 0, sizeof (SMHBA_LIBRARYATTRIBUTES));
3491
3492 #if defined(SOLARIS)
3493 if ((handle = dlopen("libSMHBAAPI.so", RTLD_NOW)) != NULL) {
3494 if (dlinfo(handle, RTLD_DI_LINKMAP, &map) >= 0) {
3495 for (mp = map; mp != NULL; mp = mp->l_next) {
3496 if (strlen(map->l_name) < 256) {
3497 (void) strcpy(attributes->LibPath, map->l_name);
3498 }
3499 }
3500 }
3501 }
3502
3503 #endif
3504
3505 #if defined(VENDOR)
3506 (void) strcpy(attributes->VName, VENDOR);
3507 #else
3508 attributes->VName[0] = '\0';
3509 #endif
3510 #if defined(VERSION)
3511 (void) strcpy(attributes->VVersion, VERSION);
3512 #else
3513 attributes->VVersion[0] = '\0';
3514 #endif
3515
3516 if (gettimeofday(&tv, (void *)0) == 0) {
3517 if (localtime_r(&tv.tv_sec, &tp) != NULL) {
3518 attributes->build_date.tm_mday = tp.tm_mday;
3519 attributes->build_date.tm_mon = tp.tm_mon;
3520 attributes->build_date.tm_year = tp.tm_year;
3521 } else {
3522 (void) memset(&attributes->build_date, 0,
3523 sizeof (attributes->build_date));
3524 }
3525 (void) memset(&attributes->build_date, 0,
3526 sizeof (attributes->build_date));
3527 }
3528
3529 return (1);
3530 }
3531
3532 /*
3533 * This function returns the attributes for the warpper library.
3534 */
3535 HBA_UINT32
3536 SMHBA_GetVendorLibraryAttributes(
3537 HBA_UINT32 adapter_index,
3538 SMHBA_LIBRARYATTRIBUTES *attributes)
3539 {
3540 HBA_ADAPTER_INFO *adapt_infop;
3541 SMHBAGetVendorLibraryAttributesFunc
3542 registeredfunc;
3543 HBA_UINT32 ret = 0;
3544
3545 DEBUG(2, "SMHBA_GetVendorLibraryAttributes adapterindex:%d",
3546 adapter_index, 0, 0);
3547 if (_hbaapi_librarylist == NULL) {
3548 DEBUG(1, "SMHBAAPI not loaded yet.", 0, 0, 0);
3549 return (0);
3550 }
3551
3552 if (attributes == NULL) {
3553 DEBUG(1, "SMHBA_GetVendorLibraryAttributes: "
3554 "NULL pointer attributes",
3555 0, 0, 0);
3556 return (HBA_STATUS_ERROR_ARG);
3557 }
3558
3559 (void) memset(attributes, 0, sizeof (SMHBA_LIBRARYATTRIBUTES));
3560
3561 GRAB_MUTEX(&_hbaapi_LL_mutex);
3562 GRAB_MUTEX(&_hbaapi_AL_mutex);
3563 for (adapt_infop = _hbaapi_adapterlist;
3564 adapt_infop != NULL;
3565 adapt_infop = adapt_infop->next) {
3566
3567 if (adapt_infop->index == adapter_index) {
3568
3569 if (adapt_infop->library->version != SMHBA) {
3570 RELEASE_MUTEX(&_hbaapi_AL_mutex);
3571 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex,
3572 HBA_STATUS_ERROR_INCOMPATIBLE);
3573 }
3574
3575 registeredfunc = adapt_infop->library->
3576 ftable.smhbafunctionTable.GetVendorLibraryAttributesHandler;
3577 if (registeredfunc != NULL) {
3578 ret = (registeredfunc)(attributes);
3579 #ifdef NOTDEF
3580 } else {
3581 /* This should not happen since the VSL is already loaded. */
3582 #endif
3583 }
3584 if (attributes->LibPath[0] == '\0') {
3585 if (strlen(adapt_infop->library->LibraryPath) < 256) {
3586 (void) strcpy(attributes->LibPath,
3587 adapt_infop->library->LibraryPath);
3588 }
3589 }
3590 break;
3591 }
3592 }
3593 RELEASE_MUTEX(&_hbaapi_AL_mutex);
3594 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, ret);
3595 }
3596
3597 HBA_STATUS
3598 SMHBA_GetAdapterAttributes(
3599 HBA_HANDLE handle,
3600 SMHBA_ADAPTERATTRIBUTES *hbaattributes)
3601 {
3602 HBA_STATUS status;
3603 HBA_LIBRARY_INFO *lib_infop;
3604 HBA_HANDLE vendorHandle;
3605 SMHBAGetAdapterAttributesFunc GetAdapterAttributesFunc;
3606
3607 DEBUG(2, "SMHBA_GetAdapterAttributes", 0, 0, 0);
3608
3609 CHECKLIBRARYANDVERSION(SMHBA);
3610
3611 GetAdapterAttributesFunc =
3612 lib_infop->ftable.smhbafunctionTable.GetAdapterAttributesHandler;
3613 if (GetAdapterAttributesFunc != NULL) {
3614 status = ((GetAdapterAttributesFunc)(vendorHandle, hbaattributes));
3615 } else {
3616 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3617 }
3618 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3619 }
3620
3621 HBA_STATUS
3622 SMHBA_GetNumberOfPorts(
3623 HBA_HANDLE handle,
3624 HBA_UINT32 *numberofports)
3625 {
3626 HBA_STATUS status;
3627 HBA_LIBRARY_INFO *lib_infop;
3628 HBA_HANDLE vendorHandle;
3629 SMHBAGetNumberOfPortsFunc GetNumberOfPortsFunc;
3630
3631 DEBUG(2, "SMHBA_GetAdapterAttributes", 0, 0, 0);
3632
3633 CHECKLIBRARYANDVERSION(SMHBA);
3634
3635 GetNumberOfPortsFunc =
3636 lib_infop->ftable.smhbafunctionTable.GetNumberOfPortsHandler;
3637 if (GetNumberOfPortsFunc != NULL) {
3638 status = ((GetNumberOfPortsFunc)(vendorHandle, numberofports));
3639 } else {
3640 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3641 }
3642 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3643 }
3644
3645 HBA_STATUS
3646 SMHBA_GetPortType(
3647 HBA_HANDLE handle,
3648 HBA_UINT32 portindex,
3649 HBA_PORTTYPE *porttype)
3650 {
3651 HBA_STATUS status;
3652 HBA_LIBRARY_INFO *lib_infop;
3653 HBA_HANDLE vendorHandle;
3654 SMHBAGetPortTypeFunc GetPortTypeFunc;
3655
3656 DEBUG(2, "SMHBA_GetAdapterAttributes", 0, 0, 0);
3657
3658 CHECKLIBRARYANDVERSION(SMHBA);
3659
3660 GetPortTypeFunc =
3661 lib_infop->ftable.smhbafunctionTable.GetPortTypeHandler;
3662 if (GetPortTypeFunc != NULL) {
3663 status = ((GetPortTypeFunc)(vendorHandle, portindex, porttype));
3664 } else {
3665 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3666 }
3667 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3668 }
3669
3670 HBA_STATUS
3671 SMHBA_GetAdapterPortAttributes(
3672 HBA_HANDLE handle,
3673 HBA_UINT32 portindex,
3674 SMHBA_PORTATTRIBUTES *portattributes)
3675 {
3676 HBA_STATUS status;
3677 HBA_LIBRARY_INFO *lib_infop;
3678 HBA_HANDLE vendorHandle;
3679 SMHBAGetAdapterPortAttributesFunc
3680 GetAdapterPortAttributesFunc;
3681
3682 DEBUG(2, "SMHBA_GetAdapterPortAttributes", 0, 0, 0);
3683
3684 CHECKLIBRARYANDVERSION(SMHBA);
3685
3686 GetAdapterPortAttributesFunc =
3687 lib_infop->ftable.smhbafunctionTable.\
3688 GetAdapterPortAttributesHandler;
3689 if (GetAdapterPortAttributesFunc != NULL) {
3690 status = ((GetAdapterPortAttributesFunc)
3691 (vendorHandle, portindex, portattributes));
3692 } else {
3693 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3694 }
3695 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3696 }
3697
3698 HBA_STATUS
3699 SMHBA_GetDiscoveredPortAttributes(
3700 HBA_HANDLE handle,
3701 HBA_UINT32 portindex,
3702 HBA_UINT32 discoveredportindex,
3703 SMHBA_PORTATTRIBUTES *portattributes)
3704 {
3705 HBA_STATUS status;
3706 HBA_LIBRARY_INFO *lib_infop;
3707 HBA_HANDLE vendorHandle;
3708 SMHBAGetDiscoveredPortAttributesFunc
3709 GetDiscoveredPortAttributesFunc;
3710
3711 DEBUG(2, "SMHBA_GetDiscoveredPortAttributes", 0, 0, 0);
3712
3713 CHECKLIBRARYANDVERSION(SMHBA);
3714
3715 GetDiscoveredPortAttributesFunc =
3716 lib_infop->ftable.smhbafunctionTable.\
3717 GetDiscoveredPortAttributesHandler;
3718 if (GetDiscoveredPortAttributesFunc != NULL) {
3719 status = ((GetDiscoveredPortAttributesFunc)
3720 (vendorHandle, portindex, discoveredportindex,
3721 portattributes));
3722 } else {
3723 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3724 }
3725 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3726 }
3727
3728 HBA_STATUS
3729 SMHBA_GetPortAttributesByWWN(
3730 HBA_HANDLE handle,
3731 HBA_WWN portWWN,
3732 HBA_WWN domainPortWWN,
3733 SMHBA_PORTATTRIBUTES *portattributes)
3734 {
3735 HBA_STATUS status;
3736 HBA_LIBRARY_INFO *lib_infop;
3737 HBA_HANDLE vendorHandle;
3738 SMHBAGetPortAttributesByWWNFunc
3739 GetPortAttributesByWWNFunc;
3740
3741 DEBUG(2, "SMHBA_GetPortAttributesByWWN: %s", WWN2STR1(&portWWN), 0, 0);
3742
3743 CHECKLIBRARYANDVERSION(SMHBA);
3744
3745 GetPortAttributesByWWNFunc =
3746 lib_infop->ftable.smhbafunctionTable.GetPortAttributesByWWNHandler;
3747 if (GetPortAttributesByWWNFunc != NULL) {
3748 status = ((GetPortAttributesByWWNFunc)
3749 (vendorHandle, portWWN, domainPortWWN, portattributes));
3750 } else {
3751 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3752 }
3753 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3754 }
3755
3756 HBA_STATUS
3757 SMHBA_GetFCPhyAttributes(
3758 HBA_HANDLE handle,
3759 HBA_UINT32 portindex,
3760 HBA_UINT32 phyindex,
3761 SMHBA_FC_PHY *phytype)
3762 {
3763 HBA_STATUS status;
3764 HBA_LIBRARY_INFO *lib_infop;
3765 HBA_HANDLE vendorHandle;
3766 SMHBAGetFCPhyAttributesFunc GetFCPhyAttributesFunc;
3767
3768 DEBUG(2, "SMHBA_GetFCPhyAttributesByWWN", 0, 0, 0);
3769
3770 CHECKLIBRARYANDVERSION(SMHBA);
3771
3772 GetFCPhyAttributesFunc =
3773 lib_infop->ftable.smhbafunctionTable.GetFCPhyAttributesHandler;
3774 if (GetFCPhyAttributesFunc != NULL) {
3775 status = ((GetFCPhyAttributesFunc)
3776 (vendorHandle, portindex, phyindex, phytype));
3777 } else {
3778 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3779 }
3780 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3781 }
3782
3783 HBA_STATUS
3784 SMHBA_GetSASPhyAttributes(
3785 HBA_HANDLE handle,
3786 HBA_UINT32 portindex,
3787 HBA_UINT32 phyindex,
3788 SMHBA_SAS_PHY *phytype)
3789 {
3790 HBA_STATUS status;
3791 HBA_LIBRARY_INFO *lib_infop;
3792 HBA_HANDLE vendorHandle;
3793 SMHBAGetSASPhyAttributesFunc GetSASPhyAttributesFunc;
3794
3795 DEBUG(2, "SMHBA_GetFCPhyAttributesByWWN", 0, 0, 0);
3796
3797 CHECKLIBRARYANDVERSION(SMHBA);
3798
3799 GetSASPhyAttributesFunc =
3800 lib_infop->ftable.smhbafunctionTable.GetSASPhyAttributesHandler;
3801 if (GetSASPhyAttributesFunc != NULL) {
3802 status = ((GetSASPhyAttributesFunc)
3803 (vendorHandle, portindex, phyindex, phytype));
3804 } else {
3805 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3806 }
3807 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3808 }
3809
3810 HBA_STATUS
3811 SMHBA_GetProtocolStatistics(
3812 HBA_HANDLE handle,
3813 HBA_UINT32 portindex,
3814 HBA_UINT32 protocoltype,
3815 SMHBA_PROTOCOLSTATISTICS *pProtocolStatistics)
3816 {
3817 HBA_STATUS status;
3818 HBA_LIBRARY_INFO *lib_infop;
3819 HBA_HANDLE vendorHandle;
3820 SMHBAGetProtocolStatisticsFunc
3821 GetProtocolStatisticsFunc;
3822
3823 DEBUG(2, "SMHBA_GetProtocolStatistics port index: %d protocol type: %d",
3824 portindex, protocoltype, 0);
3825
3826 CHECKLIBRARYANDVERSION(SMHBA);
3827
3828 GetProtocolStatisticsFunc =
3829 lib_infop->ftable.smhbafunctionTable.GetProtocolStatisticsHandler;
3830 if (GetProtocolStatisticsFunc != NULL) {
3831 status = (GetProtocolStatisticsFunc)
3832 (vendorHandle, portindex, protocoltype, pProtocolStatistics);
3833 } else {
3834 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3835 }
3836 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3837 }
3838
3839 HBA_STATUS
3840 SMHBA_GetPhyStatistics(
3841 HBA_HANDLE handle,
3842 HBA_UINT32 portindex,
3843 HBA_UINT32 phyindex,
3844 SMHBA_PHYSTATISTICS *pPhyStatistics)
3845 {
3846 HBA_STATUS status;
3847 HBA_LIBRARY_INFO *lib_infop;
3848 HBA_HANDLE vendorHandle;
3849 SMHBAGetPhyStatisticsFunc
3850 GetPhyStatisticsFunc;
3851
3852 DEBUG(2, "SMHBA_GetPhyStatistics port index: %d phy idex: %d",
3853 portindex, phyindex, 0);
3854
3855 CHECKLIBRARYANDVERSION(SMHBA);
3856
3857 GetPhyStatisticsFunc =
3858 lib_infop->ftable.smhbafunctionTable.GetPhyStatisticsHandler;
3859 if (GetPhyStatisticsFunc != NULL) {
3860 status = (GetPhyStatisticsFunc)
3861 (vendorHandle, portindex, phyindex, pPhyStatistics);
3862 } else {
3863 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3864 }
3865 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3866 }
3867
3868 HBA_STATUS
3869 SMHBA_GetBindingCapability(
3870 HBA_HANDLE handle,
3871 HBA_WWN hbaPortWWN,
3872 HBA_WWN domainPortWWN,
3873 SMHBA_BIND_CAPABILITY *pFlags)
3874 {
3875 HBA_STATUS status;
3876 HBA_LIBRARY_INFO *lib_infop;
3877 HBA_HANDLE vendorHandle;
3878 SMHBAGetBindingCapabilityFunc GetBindingCapabilityFunc;
3879
3880 DEBUG(2, "HBA_GetBindingCapability", 0, 0, 0);
3881
3882 CHECKLIBRARYANDVERSION(SMHBA);
3883
3884 GetBindingCapabilityFunc =
3885 lib_infop->ftable.smhbafunctionTable.GetBindingCapabilityHandler;
3886 if (GetBindingCapabilityFunc != NULL) {
3887 status = (GetBindingCapabilityFunc)(vendorHandle, hbaPortWWN,
3888 domainPortWWN, pFlags);
3889 } else {
3890 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3891 }
3892 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3893 }
3894
3895 HBA_STATUS
3896 SMHBA_GetBindingSupport(
3897 HBA_HANDLE handle,
3898 HBA_WWN hbaPortWWN,
3899 HBA_WWN domainPortWWN,
3900 SMHBA_BIND_CAPABILITY *pFlags)
3901 {
3902 HBA_STATUS status;
3903 HBA_LIBRARY_INFO *lib_infop;
3904 HBA_HANDLE vendorHandle;
3905 SMHBAGetBindingSupportFunc
3906 GetBindingSupporFunc;
3907
3908 DEBUG(2, "SMHBA_GetBindingSupport port: %s",
3909 WWN2STR1(&hbaPortWWN), 0, 0);
3910
3911 CHECKLIBRARYANDVERSION(SMHBA);
3912
3913 GetBindingSupporFunc =
3914 lib_infop->ftable.smhbafunctionTable.GetBindingSupportHandler;
3915 if (GetBindingSupporFunc != NULL) {
3916 status = (GetBindingSupporFunc)(vendorHandle,
3917 hbaPortWWN, domainPortWWN, pFlags);
3918 } else {
3919 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3920 }
3921 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3922 }
3923
3924 HBA_STATUS
3925 SMHBA_SetBindingSupport(
3926 HBA_HANDLE handle,
3927 HBA_WWN hbaPortWWN,
3928 HBA_WWN domainPortWWN,
3929 SMHBA_BIND_CAPABILITY flags)
3930 {
3931 HBA_STATUS status;
3932 HBA_LIBRARY_INFO *lib_infop;
3933 HBA_HANDLE vendorHandle;
3934 SMHBASetBindingSupportFunc
3935 SetBindingSupporFunc;
3936
3937 DEBUG(2, "SMHBA_GetBindingSupport port: %s",
3938 WWN2STR1(&hbaPortWWN), 0, 0);
3939
3940 CHECKLIBRARYANDVERSION(HBAAPIV2);
3941
3942 SetBindingSupporFunc =
3943 lib_infop->ftable.smhbafunctionTable.SetBindingSupportHandler;
3944 if (SetBindingSupporFunc != NULL) {
3945 status = (SetBindingSupporFunc)
3946 (vendorHandle, hbaPortWWN, domainPortWWN, flags);
3947 } else {
3948 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3949 }
3950 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3951 }
3952
3953 HBA_STATUS
3954 SMHBA_GetTargetMapping(
3955 HBA_HANDLE handle,
3956 HBA_WWN hbaPortWWN,
3957 HBA_WWN domainPortWWN,
3958 SMHBA_TARGETMAPPING *pMapping)
3959 {
3960 HBA_STATUS status;
3961 HBA_LIBRARY_INFO *lib_infop;
3962 HBA_HANDLE vendorHandle;
3963 SMHBAGetTargetMappingFunc GetTargetMappingFunc;
3964
3965 DEBUG(2, "SMHBA_GetTargetMapping port WWN: %s",
3966 WWN2STR1(&hbaPortWWN), 0, 0);
3967
3968 CHECKLIBRARYANDVERSION(SMHBA);
3969
3970 GetTargetMappingFunc =
3971 lib_infop->ftable.smhbafunctionTable.GetTargetMappingHandler;
3972 if (GetTargetMappingFunc != NULL) {
3973 status = ((GetTargetMappingFunc)(vendorHandle,
3974 hbaPortWWN, domainPortWWN, pMapping));
3975 } else {
3976 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
3977 }
3978 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
3979 }
3980
3981 HBA_STATUS
3982 SMHBA_GetPersistentBinding(
3983 HBA_HANDLE handle,
3984 HBA_WWN hbaPortWWN,
3985 HBA_WWN domainPortWWN,
3986 SMHBA_BINDING *binding)
3987 {
3988 HBA_STATUS status;
3989 HBA_LIBRARY_INFO *lib_infop;
3990 HBA_HANDLE vendorHandle;
3991 SMHBAGetPersistentBindingFunc
3992 GetPersistentBindingFunc;
3993
3994 DEBUG(2, "SMHBA_GetPersistentBinding port WWN: %s",
3995 WWN2STR1(&hbaPortWWN), 0, 0);
3996
3997 CHECKLIBRARYANDVERSION(SMHBA);
3998
3999 GetPersistentBindingFunc =
4000 lib_infop->ftable.smhbafunctionTable.GetPersistentBindingHandler;
4001 if (GetPersistentBindingFunc != NULL) {
4002 status = ((GetPersistentBindingFunc)(vendorHandle,
4003 hbaPortWWN, domainPortWWN, binding));
4004 } else {
4005 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4006 }
4007 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4008 }
4009
4010 HBA_STATUS
4011 SMHBA_SetPersistentBinding(
4012 HBA_HANDLE handle,
4013 HBA_WWN hbaPortWWN,
4014 HBA_WWN domainPortWWN,
4015 const SMHBA_BINDING *binding)
4016 {
4017 HBA_STATUS status;
4018 HBA_LIBRARY_INFO *lib_infop;
4019 HBA_HANDLE vendorHandle;
4020 SMHBASetPersistentBindingFunc
4021 SetPersistentBindingFunc;
4022
4023 DEBUG(2, "SMHBA_SetPersistentBinding port WWN: %s",
4024 WWN2STR1(&hbaPortWWN), 0, 0);
4025
4026 CHECKLIBRARYANDVERSION(SMHBA);
4027
4028 SetPersistentBindingFunc =
4029 lib_infop->ftable.smhbafunctionTable.SetPersistentBindingHandler;
4030 if (SetPersistentBindingFunc != NULL) {
4031 status = ((SetPersistentBindingFunc)(vendorHandle,
4032 hbaPortWWN, domainPortWWN, binding));
4033 } else {
4034 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4035 }
4036 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4037 }
4038
4039 HBA_STATUS
4040 SMHBA_RemovePersistentBinding(
4041 HBA_HANDLE handle,
4042 HBA_WWN hbaPortWWN,
4043 HBA_WWN domainPortWWN,
4044 const SMHBA_BINDING *binding)
4045 {
4046 HBA_STATUS status;
4047 HBA_LIBRARY_INFO *lib_infop;
4048 HBA_HANDLE vendorHandle;
4049 SMHBARemovePersistentBindingFunc
4050 RemovePersistentBindingFunc;
4051
4052 DEBUG(2, "SMHBA_RemovePersistentBinding port WWN: %s",
4053 WWN2STR1(&hbaPortWWN), 0, 0);
4054
4055 CHECKLIBRARYANDVERSION(SMHBA);
4056
4057 RemovePersistentBindingFunc =
4058 lib_infop->ftable.smhbafunctionTable.RemovePersistentBindingHandler;
4059 if (RemovePersistentBindingFunc != NULL) {
4060 status = ((RemovePersistentBindingFunc)(vendorHandle,
4061 hbaPortWWN, domainPortWWN, binding));
4062 } else {
4063 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4064 }
4065 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4066 }
4067
4068 HBA_STATUS
4069 SMHBA_RemoveAllPersistentBindings(
4070 HBA_HANDLE handle,
4071 HBA_WWN hbaPortWWN,
4072 HBA_WWN domainPortWWN)
4073 {
4074 HBA_STATUS status;
4075 HBA_LIBRARY_INFO *lib_infop;
4076 HBA_HANDLE vendorHandle;
4077 SMHBARemoveAllPersistentBindingsFunc
4078 RemoveAllPersistentBindingsFunc;
4079
4080 DEBUG(2, "SMHBA_RemoveAllPersistentBinding port WWN: %s",
4081 WWN2STR1(&hbaPortWWN), 0, 0);
4082
4083 CHECKLIBRARYANDVERSION(SMHBA);
4084
4085 RemoveAllPersistentBindingsFunc =
4086 lib_infop->ftable.smhbafunctionTable.\
4087 RemoveAllPersistentBindingsHandler;
4088 if (RemoveAllPersistentBindingsFunc != NULL) {
4089 status = ((RemoveAllPersistentBindingsFunc)(vendorHandle,
4090 hbaPortWWN, domainPortWWN));
4091 } else {
4092 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4093 }
4094 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4095 }
4096
4097 HBA_STATUS
4098 SMHBA_GetLUNStatistics(
4099 HBA_HANDLE handle,
4100 const HBA_SCSIID *lunit,
4101 SMHBA_PROTOCOLSTATISTICS *statistics)
4102 {
4103 HBA_STATUS status;
4104 HBA_LIBRARY_INFO *lib_infop;
4105 HBA_HANDLE vendorHandle;
4106 SMHBAGetLUNStatisticsFunc GetLUNStatisticsFunc;
4107
4108 DEBUG(2, "SMHBA_GetLUNStatistics", 0, 0, 0);
4109
4110 CHECKLIBRARYANDVERSION(SMHBA);
4111
4112 GetLUNStatisticsFunc =
4113 lib_infop->ftable.smhbafunctionTable.GetLUNStatisticsHandler;
4114 if (GetLUNStatisticsFunc != NULL) {
4115 status = ((GetLUNStatisticsFunc)(vendorHandle, lunit, statistics));
4116 } else {
4117 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4118 }
4119 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4120 }
4121
4122 HBA_STATUS
4123 SMHBA_ScsiInquiry(
4124 HBA_HANDLE handle,
4125 HBA_WWN hbaPortWWN,
4126 HBA_WWN discoveredPortWWN,
4127 HBA_WWN domainPortWWN,
4128 SMHBA_SCSILUN smhbaLUN,
4129 HBA_UINT8 CDB_Byte1,
4130 HBA_UINT8 CDB_Byte2,
4131 void *pRspBuffer,
4132 HBA_UINT32 *pRspBufferSize,
4133 HBA_UINT8 *pScsiStatus,
4134 void *pSenseBuffer,
4135 HBA_UINT32 *pSenseBufferSize)
4136 {
4137 HBA_STATUS status;
4138 HBA_LIBRARY_INFO *lib_infop;
4139 HBA_HANDLE vendorHandle;
4140 SMHBAScsiInquiryFunc ScsiInquiryFunc;
4141
4142 DEBUG(2, "SMHBA_ScsiInquiry to hba port: %s discoveredPortWWN: %s",
4143 WWN2STR1(&hbaPortWWN), WWN2STR1(&discoveredPortWWN), 0);
4144
4145 CHECKLIBRARYANDVERSION(SMHBA);
4146
4147 ScsiInquiryFunc =
4148 lib_infop->ftable.smhbafunctionTable.ScsiInquiryHandler;
4149 if (ScsiInquiryFunc != NULL) {
4150 status = ((ScsiInquiryFunc)(
4151 vendorHandle, hbaPortWWN, discoveredPortWWN, domainPortWWN,
4152 smhbaLUN, CDB_Byte1, CDB_Byte2, pRspBuffer, pRspBufferSize,
4153 pScsiStatus, pSenseBuffer, pSenseBufferSize));
4154 } else {
4155 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4156 }
4157 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4158 }
4159
4160 HBA_STATUS
4161 SMHBA_ScsiReportLUNs(
4162 HBA_HANDLE handle,
4163 HBA_WWN hbaPortWWN,
4164 HBA_WWN discoveredPortWWN,
4165 HBA_WWN domainPortWWN,
4166 void *pRspBuffer,
4167 HBA_UINT32 *pRspBufferSize,
4168 HBA_UINT8 *pScsiStatus,
4169 void *pSenseBuffer,
4170 HBA_UINT32 *pSenseBufferSize)
4171 {
4172 HBA_STATUS status;
4173 HBA_LIBRARY_INFO *lib_infop;
4174 HBA_HANDLE vendorHandle;
4175 SMHBAScsiReportLUNsFunc ScsiReportLUNsFunc;
4176
4177 DEBUG(2, "SMHBA_ScsiReportLuns to hba port: %s discoveredPortWWN: %s",
4178 WWN2STR1(&hbaPortWWN), WWN2STR1(&discoveredPortWWN), 0);
4179
4180 CHECKLIBRARYANDVERSION(SMHBA);
4181
4182 ScsiReportLUNsFunc =
4183 lib_infop->ftable.smhbafunctionTable.ScsiReportLUNsHandler;
4184 if (ScsiReportLUNsFunc != NULL) {
4185 status = ((ScsiReportLUNsFunc)(
4186 vendorHandle, hbaPortWWN, discoveredPortWWN, domainPortWWN,
4187 pRspBuffer, pRspBufferSize, pScsiStatus, pSenseBuffer,
4188 pSenseBufferSize));
4189 } else {
4190 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4191 }
4192 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4193 }
4194
4195 HBA_STATUS
4196 SMHBA_ScsiReadCapacity(
4197 HBA_HANDLE handle,
4198 HBA_WWN hbaPortWWN,
4199 HBA_WWN discoveredPortWWN,
4200 HBA_WWN domainPortWWN,
4201 SMHBA_SCSILUN smhbaLUN,
4202 void *pRspBuffer,
4203 HBA_UINT32 *pRspBufferSize,
4204 HBA_UINT8 *pScsiStatus,
4205 void *pSenseBuffer,
4206 HBA_UINT32 *pSenseBufferSize)
4207 {
4208 HBA_STATUS status;
4209 HBA_LIBRARY_INFO *lib_infop;
4210 HBA_HANDLE vendorHandle;
4211 SMHBAScsiReadCapacityFunc ScsiReadCapacityFunc;
4212
4213 DEBUG(2, "SMHBA_ScsiReadCapacity to hba port: %s discoveredPortWWN: %s",
4214 WWN2STR1(&hbaPortWWN), WWN2STR1(&discoveredPortWWN), 0);
4215
4216 CHECKLIBRARYANDVERSION(SMHBA);
4217
4218 ScsiReadCapacityFunc =
4219 lib_infop->ftable.smhbafunctionTable.ScsiReadCapacityHandler;
4220 if (ScsiReadCapacityFunc != NULL) {
4221 status = ((ScsiReadCapacityFunc)(
4222 vendorHandle, hbaPortWWN, discoveredPortWWN, domainPortWWN,
4223 smhbaLUN, pRspBuffer, pRspBufferSize, pScsiStatus, pSenseBuffer,
4224 pSenseBufferSize));
4225 } else {
4226 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4227 }
4228 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4229 }
4230
4231 HBA_STATUS
4232 SMHBA_SendTEST(
4233 HBA_HANDLE handle,
4234 HBA_WWN hbaPortWWN,
4235 HBA_WWN destWWN,
4236 HBA_UINT32 destFCID,
4237 void *pRspBuffer,
4238 HBA_UINT32 pRspBufferSize)
4239 {
4240 HBA_STATUS status;
4241 HBA_LIBRARY_INFO *lib_infop;
4242 HBA_HANDLE vendorHandle;
4243 SMHBASendTESTFunc SendTESTFunc;
4244
4245 DEBUG(2, "SMHBA_SendTEST, hbaPortWWN: %s destWWN",
4246 WWN2STR1(&hbaPortWWN),
4247 WWN2STR1(&destWWN), 0);
4248
4249 CHECKLIBRARYANDVERSION(SMHBA);
4250
4251 SendTESTFunc = lib_infop->ftable.smhbafunctionTable.SendTESTHandler;
4252 if (SendTESTFunc != NULL) {
4253 status = (SendTESTFunc)
4254 (vendorHandle, hbaPortWWN, destWWN, destFCID,
4255 pRspBuffer, pRspBufferSize);
4256 } else {
4257 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4258 }
4259 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4260 }
4261
4262 HBA_STATUS
4263 SMHBA_SendECHO(
4264 HBA_HANDLE handle,
4265 HBA_WWN hbaPortWWN,
4266 HBA_WWN destWWN,
4267 HBA_UINT32 destFCID,
4268 void *pReqBuffer,
4269 HBA_UINT32 ReqBufferSize,
4270 void *pRspBuffer,
4271 HBA_UINT32 *pRspBufferSize)
4272 {
4273 HBA_STATUS status;
4274 HBA_LIBRARY_INFO *lib_infop;
4275 HBA_HANDLE vendorHandle;
4276 SMHBASendECHOFunc SendECHOFunc;
4277
4278 DEBUG(2, "SMHBA_SendECHO, hbaPortWWN: %s destWWN",
4279 WWN2STR1(&hbaPortWWN), WWN2STR1(&destWWN), 0);
4280
4281 CHECKLIBRARYANDVERSION(SMHBA);
4282
4283 SendECHOFunc = lib_infop->ftable.smhbafunctionTable.SendECHOHandler;
4284 if (SendECHOFunc != NULL) {
4285 status = (SendECHOFunc)
4286 (vendorHandle, hbaPortWWN, destWWN, destFCID,
4287 pReqBuffer, ReqBufferSize, pRspBuffer, pRspBufferSize);
4288 } else {
4289 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4290 }
4291 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4292 }
4293
4294 HBA_STATUS
4295 SMHBA_SendSMPPassThru(
4296 HBA_HANDLE handle,
4297 HBA_WWN hbaPortWWN,
4298 HBA_WWN destWWN,
4299 HBA_WWN domainPortWWN,
4300 void *pReqBuffer,
4301 HBA_UINT32 ReqBufferSize,
4302 void *pRspBuffer,
4303 HBA_UINT32 *pRspBufferSize)
4304 {
4305 HBA_STATUS status;
4306 HBA_LIBRARY_INFO *lib_infop;
4307 HBA_HANDLE vendorHandle;
4308 SMHBASendSMPPassThruFunc SendSMPPassThruFunc;
4309
4310 DEBUG(2, "SMHBA_SendSMPPassThru, hbaPortWWN: %s destWWN: %s",
4311 WWN2STR1(&hbaPortWWN), WWN2STR1(&destWWN), 0);
4312
4313 CHECKLIBRARYANDVERSION(SMHBA);
4314
4315 SendSMPPassThruFunc = lib_infop->ftable.\
4316 smhbafunctionTable.SendSMPPassThruHandler;
4317
4318 if (SendSMPPassThruFunc != NULL) {
4319 status = (SendSMPPassThruFunc)
4320 (vendorHandle, hbaPortWWN, destWWN, domainPortWWN,
4321 pReqBuffer, ReqBufferSize, pRspBuffer, pRspBufferSize);
4322 } else {
4323 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4324 }
4325 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4326 }
4327
4328 /*
4329 * Following the similar logic of HBAAPI addaspterevents_callback.
4330 *
4331 * Unlike other events Adapter Add Event is not limited to a specific
4332 * adpater(i.e. no adatper handle is passed for registration) so
4333 * the event should be passed to all registrants. The routine below
4334 * is passed to the VSLs as a callback and when Adapter Add event is detected
4335 * by VSL it will call smhba_adapteraddevents_callback() which in turn check
4336 * if the passed userdata ptr matches with the one stored in the callback list
4337 * and calls the stored callback.
4338 *
4339 * For the situation that multiple clients are registered for Adapter Add event
4340 * each registration is passed to VSLs so VSL may call
4341 * smhba_adapteraddevents_callback() multiple times or it may call only once
4342 * since the callback function is same. For this implemneation, the userdata
4343 * is stored in HBA_ALLADAPTERSCALLBACK_ELEM so it is expected that VSL call
4344 * smhba_adapteraddevents_callback() only once and
4345 * smhba_adapteraddevents_callback() will call the client callback with proper
4346 * userdata.
4347 */
4348 static void
4349 smhba_adapteraddevents_callback(
4350 /* LINTED E_FUNC_ARG_UNUSED */
4351 void *data,
4352 HBA_WWN PortWWN,
4353 /* LINTED E_FUNC_ARG_UNUSED */
4354 HBA_UINT32 eventType)
4355 {
4356 HBA_ALLADAPTERSCALLBACK_ELEM *cbp;
4357
4358 DEBUG(3, "AddAdapterEvent, port:%s", WWN2STR1(&PortWWN), 0, 0);
4359
4360 GRAB_MUTEX(&_smhba_AAE_mutex);
4361 for (cbp = _smhba_adapteraddevents_callback_list;
4362 cbp != NULL;
4363 cbp = cbp->next) {
4364 (*cbp->callback)(cbp->userdata, PortWWN, HBA_EVENT_ADAPTER_ADD);
4365 }
4366 RELEASE_MUTEX(&_smhba_AAE_mutex);
4367
4368 }
4369
4370 HBA_STATUS
4371 SMHBA_RegisterForAdapterAddEvents(
4372 void (*pCallback) (
4373 void *data,
4374 HBA_WWN PortWWN,
4375 HBA_UINT32 eventType),
4376 void *pUserData,
4377 HBA_CALLBACKHANDLE *pCallbackHandle) {
4378
4379 HBA_ALLADAPTERSCALLBACK_ELEM *cbp;
4380 HBA_VENDORCALLBACK_ELEM *vcbp;
4381 HBA_VENDORCALLBACK_ELEM *vendorhandlelist;
4382 SMHBARegisterForAdapterAddEventsFunc registeredfunc;
4383 HBA_STATUS status = HBA_STATUS_OK;
4384 HBA_STATUS failure = HBA_STATUS_OK;
4385 HBA_LIBRARY_INFO *lib_infop;
4386 int registered_cnt = 0;
4387 int vendor_cnt = 0;
4388 int not_supported_cnt = 0;
4389 int status_OK_bar_cnt = 0;
4390 int status_OK_cnt = 0;
4391
4392 DEBUG(2, "SMHBA_RegisterForAdapterAddEvents", 0, 0, 0);
4393 ARE_WE_INITED();
4394
4395 cbp = (HBA_ALLADAPTERSCALLBACK_ELEM *)
4396 calloc(1, sizeof (HBA_ALLADAPTERSCALLBACK_ELEM));
4397 *pCallbackHandle = (HBA_CALLBACKHANDLE) cbp;
4398 if (cbp == NULL) {
4399 return (HBA_STATUS_ERROR);
4400 }
4401
4402 GRAB_MUTEX(&_hbaapi_LL_mutex);
4403 GRAB_MUTEX(&_smhba_AAE_mutex);
4404 cbp->callback = pCallback;
4405 cbp->userdata = pUserData;
4406 cbp->next = _smhba_adapteraddevents_callback_list;
4407 _smhba_adapteraddevents_callback_list = cbp;
4408
4409 /*
4410 * Need to release the mutex now incase the vendor function invokes the
4411 * callback. We will grap the mutex later to attach the vendor handle
4412 * list to the callback structure
4413 */
4414 RELEASE_MUTEX(&_smhba_AAE_mutex);
4415
4416
4417 /*
4418 * now create a list of vendors (vendor libraryies, NOT ADAPTERS)
4419 * that have successfully registerred
4420 */
4421 vendorhandlelist = NULL;
4422 for (lib_infop = _hbaapi_librarylist;
4423 lib_infop != NULL;
4424 lib_infop = lib_infop->next) {
4425
4426 /* only for HBAAPI V2 */
4427 if (lib_infop->version != SMHBA) {
4428 continue;
4429 } else {
4430 vendor_cnt++;
4431 }
4432
4433 registeredfunc =
4434 lib_infop->ftable.smhbafunctionTable.\
4435 RegisterForAdapterAddEventsHandler;
4436 if (registeredfunc == NULL) {
4437 continue;
4438 }
4439
4440 vcbp = (HBA_VENDORCALLBACK_ELEM *)
4441 calloc(1, sizeof (HBA_VENDORCALLBACK_ELEM));
4442 if (vcbp == NULL) {
4443 freevendorhandlelist(vendorhandlelist);
4444 status = HBA_STATUS_ERROR;
4445 break;
4446 }
4447
4448 registered_cnt++;
4449 status = (registeredfunc)(smhba_adapteraddevents_callback,
4450 pUserData, &vcbp->vendorcbhandle);
4451 if (status == HBA_STATUS_ERROR_NOT_SUPPORTED) {
4452 not_supported_cnt++;
4453 free(vcbp);
4454 continue;
4455 } else if (status != HBA_STATUS_OK) {
4456 status_OK_bar_cnt++;
4457 DEBUG(1,
4458 "SMHBA_RegisterForAdapterAddEvents: Library->%s, Error->%d",
4459 lib_infop->LibraryPath, status, 0);
4460 failure = status;
4461 free(vcbp);
4462 continue;
4463 } else {
4464 status_OK_cnt++;
4465 }
4466 vcbp->lib_info = lib_infop;
4467 vcbp->next = vendorhandlelist;
4468 vendorhandlelist = vcbp;
4469 }
4470
4471 if (vendor_cnt == 0) {
4472 /* no SMHBA VSL found. Should be okay?? */
4473 status = HBA_STATUS_ERROR;
4474 } else if (registered_cnt == 0) {
4475 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4476 freevendorhandlelist(vendorhandlelist);
4477 (void) local_remove_callback((HBA_CALLBACKHANDLE) cbp);
4478 } else if (status_OK_cnt == 0 && not_supported_cnt != 0) {
4479 status = HBA_STATUS_ERROR_NOT_SUPPORTED;
4480 } else if (status_OK_cnt == 0) {
4481 /*
4482 * At least one vendor library registered this function, but no
4483 * vendor call succeeded
4484 */
4485 (void) local_remove_callback((HBA_CALLBACKHANDLE) cbp);
4486 status = failure;
4487 } else {
4488 /* we have had atleast some success, now finish up */
4489 GRAB_MUTEX(&_smhba_AAE_mutex);
4490 /*
4491 * this seems silly, but what if another thread called
4492 * the callback remove
4493 */
4494 for (cbp = _smhba_adapteraddevents_callback_list;
4495 cbp != NULL; cbp = cbp->next) {
4496 if ((HBA_CALLBACKHANDLE)cbp == *pCallbackHandle) {
4497 /* yup, its still there, hooray */
4498 cbp->vendorhandlelist = vendorhandlelist;
4499 vendorhandlelist = NULL;
4500 break;
4501 }
4502 }
4503 RELEASE_MUTEX(&_smhba_AAE_mutex);
4504 if (vendorhandlelist != NULL) {
4505 /*
4506 * bummer, somebody removed the callback before we finished
4507 * registration, probably will never happen
4508 */
4509 freevendorhandlelist(vendorhandlelist);
4510 DEBUG(1,
4511 "HBA_RegisterForAdapterAddEvents: HBA_RemoveCallback was "
4512 "called for a handle before registration was finished.",
4513 0, 0, 0);
4514 status = HBA_STATUS_ERROR;
4515 } else {
4516 status = HBA_STATUS_OK;
4517 }
4518 }
4519 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4520 }
4521
4522 /* SMHBA Adapter Events (other than add) ******************************** */
4523 static void
4524 smhba_adapterevents_callback(void *data,
4525 HBA_WWN PortWWN,
4526 HBA_UINT32 eventType)
4527 {
4528 HBA_ADAPTERCALLBACK_ELEM *acbp;
4529
4530 DEBUG(3, "AdapterEvent, port:%s, eventType:%d", WWN2STR1(&PortWWN),
4531 eventType, 0);
4532
4533 GRAB_MUTEX(&_hbaapi_AE_mutex);
4534 for (acbp = _smhba_adapterevents_callback_list;
4535 acbp != NULL;
4536 acbp = acbp->next) {
4537 if (data == (void *)acbp) {
4538 (*acbp->callback)(acbp->userdata, PortWWN, eventType);
4539 break;
4540 }
4541 }
4542 RELEASE_MUTEX(&_hbaapi_AE_mutex);
4543 }
4544
4545 HBA_STATUS
4546 SMHBA_RegisterForAdapterEvents(
4547 void (*pCallback) (
4548 void *data,
4549 HBA_WWN PortWWN,
4550 HBA_UINT32 eventType),
4551 void *pUserData,
4552 HBA_HANDLE handle,
4553 HBA_CALLBACKHANDLE *pCallbackHandle) {
4554
4555 HBA_ADAPTERCALLBACK_ELEM *acbp;
4556 SMHBARegisterForAdapterEventsFunc registeredfunc;
4557 HBA_STATUS status;
4558 HBA_LIBRARY_INFO *lib_infop;
4559 HBA_HANDLE vendorHandle;
4560
4561 DEBUG(2, "SMHBA_RegisterForAdapterEvents", 0, 0, 0);
4562
4563 CHECKLIBRARYANDVERSION(SMHBA);
4564
4565 /* we now have the _hbaapi_LL_mutex */
4566
4567 registeredfunc = lib_infop->ftable.smhbafunctionTable.\
4568 RegisterForAdapterEventsHandler;
4569 if (registeredfunc == NULL) {
4570 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
4571 }
4572
4573 /*
4574 * that allocated memory is used both as the handle for the
4575 * caller, and as userdata to the vendor call so that on
4576 * callback the specific registration may be recalled
4577 */
4578 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
4579 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
4580 if (acbp == NULL) {
4581 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
4582 }
4583 *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
4584 acbp->callback = pCallback;
4585 acbp->userdata = pUserData;
4586 acbp->lib_info = lib_infop;
4587
4588 status = (registeredfunc)(smhba_adapterevents_callback,
4589 (void *)acbp,
4590 vendorHandle,
4591 &acbp->vendorcbhandle);
4592 if (status != HBA_STATUS_OK) {
4593 free(acbp);
4594 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4595 }
4596
4597 GRAB_MUTEX(&_smhba_AE_mutex);
4598 acbp->next = _smhba_adapterevents_callback_list;
4599 _hbaapi_adapterevents_callback_list = acbp;
4600
4601 RELEASE_MUTEX(&_smhba_AE_mutex);
4602 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
4603 }
4604
4605 /* Adapter Port Events *********************************************** */
4606 static void
4607 smhba_adapterportevents_callback(void *data,
4608 HBA_WWN PortWWN,
4609 HBA_UINT32 eventType,
4610 HBA_UINT32 fabricPortID)
4611 {
4612 HBA_ADAPTERCALLBACK_ELEM *acbp;
4613
4614 DEBUG(3,
4615 "SMHBA_AdapterPortEvent, port:%s, eventType:%d fabricPortID:0X%06x",
4616 WWN2STR1(&PortWWN), eventType, fabricPortID);
4617
4618 GRAB_MUTEX(&_smhba_APE_mutex);
4619
4620 for (acbp = _smhba_adapterportevents_callback_list;
4621 acbp != NULL;
4622 acbp = acbp->next) {
4623 if (data == (void *)acbp) {
4624 (*acbp->callback)(acbp->userdata, PortWWN,
4625 eventType, fabricPortID);
4626 break;
4627 }
4628 }
4629 RELEASE_MUTEX(&_smhba_APE_mutex);
4630 }
4631
4632 HBA_STATUS
4633 SMHBA_RegisterForAdapterPortEvents(
4634 void (*pCallback) (
4635 void *pData,
4636 HBA_WWN PortWWN,
4637 HBA_UINT32 eventType,
4638 HBA_UINT32 fabricPortID),
4639 void *pUserData,
4640 HBA_HANDLE handle,
4641 HBA_WWN portWWN,
4642 HBA_UINT32 specificEventType,
4643 HBA_CALLBACKHANDLE *pCallbackHandle) {
4644
4645 HBA_ADAPTERCALLBACK_ELEM *acbp;
4646 SMHBARegisterForAdapterPortEventsFunc registeredfunc;
4647 HBA_STATUS status;
4648 HBA_LIBRARY_INFO *lib_infop;
4649 HBA_HANDLE vendorHandle;
4650
4651 DEBUG(2, "SMHBA_RegisterForAdapterPortEvents for port: %s",
4652 WWN2STR1(&portWWN), 0, 0);
4653
4654 CHECKLIBRARYANDVERSION(SMHBA);
4655 /* we now have the _hbaapi_LL_mutex */
4656
4657 registeredfunc =
4658 lib_infop->ftable.smhbafunctionTable.\
4659 RegisterForAdapterPortEventsHandler;
4660 if (registeredfunc == NULL) {
4661 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
4662 }
4663
4664 /*
4665 * that allocated memory is used both as the handle for the
4666 * caller, and as userdata to the vendor call so that on
4667 * callback the specific registration may be recalled
4668 */
4669 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
4670 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
4671 if (acbp == NULL) {
4672 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
4673 }
4674 *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
4675 acbp->callback = pCallback;
4676 acbp->userdata = pUserData;
4677 acbp->lib_info = lib_infop;
4678
4679 status = (registeredfunc)(smhba_adapterportevents_callback,
4680 (void *)acbp,
4681 vendorHandle,
4682 portWWN,
4683 specificEventType,
4684 &acbp->vendorcbhandle);
4685 if (status != HBA_STATUS_OK) {
4686 free(acbp);
4687 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4688 }
4689
4690 GRAB_MUTEX(&_smhba_APE_mutex);
4691 acbp->next = _smhba_adapterportevents_callback_list;
4692 _smhba_adapterportevents_callback_list = acbp;
4693
4694 RELEASE_MUTEX(&_smhba_APE_mutex);
4695 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
4696 }
4697
4698 /* SMHBA Adapter Port Stat Events ******************************** */
4699 static void
4700 smhba_adapterportstatevents_callback(void *data,
4701 HBA_WWN portWWN,
4702 HBA_UINT32 protocolType,
4703 HBA_UINT32 eventType)
4704 {
4705 HBA_ADAPTERCALLBACK_ELEM *acbp;
4706
4707 DEBUG(3,
4708 "SMBA_AdapterPortStateEvent, port:%s, eventType:%d",
4709 WWN2STR1(&portWWN), eventType, 0);
4710
4711 GRAB_MUTEX(&_smhba_APSE_mutex);
4712 for (acbp = _smhba_adapterportstatevents_callback_list;
4713 acbp != NULL;
4714 acbp = acbp->next) {
4715 if (data == (void *)acbp) {
4716 (*acbp->callback)(acbp->userdata, portWWN,
4717 protocolType, eventType);
4718 return;
4719 }
4720 }
4721 RELEASE_MUTEX(&_smhba_APSE_mutex);
4722 }
4723
4724 HBA_STATUS
4725 SMHBA_RegisterForAdapterPortStatEvents(
4726 void (*pCallback) (
4727 void *pData,
4728 HBA_WWN portWWN,
4729 HBA_UINT32 protocolType,
4730 HBA_UINT32 eventType),
4731 void *pUserData,
4732 HBA_HANDLE handle,
4733 HBA_WWN portWWN,
4734 HBA_UINT32 protocolType,
4735 SMHBA_PROTOCOLSTATISTICS stats,
4736 HBA_UINT32 statType,
4737 HBA_CALLBACKHANDLE *pCallbackHandle) {
4738
4739 HBA_ADAPTERCALLBACK_ELEM *acbp;
4740 SMHBARegisterForAdapterPortStatEventsFunc
4741 registeredfunc;
4742 HBA_STATUS status;
4743 HBA_LIBRARY_INFO *lib_infop;
4744 HBA_HANDLE vendorHandle;
4745
4746 DEBUG(2, "SMHBA_RegisterForAdapterPortStatEvents for port: %s",
4747 WWN2STR1(&portWWN), 0, 0);
4748
4749 CHECKLIBRARYANDVERSION(SMHBA);
4750 /* we now have the _hbaapi_LL_mutex */
4751
4752 registeredfunc =
4753 lib_infop->ftable.smhbafunctionTable.\
4754 RegisterForAdapterPortStatEventsHandler;
4755 if (registeredfunc == NULL) {
4756 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
4757 }
4758
4759 /*
4760 * that allocated memory is used both as the handle for the
4761 * caller, and as userdata to the vendor call so that on
4762 * callback the specific registration may be recalled
4763 */
4764 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
4765 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
4766 if (acbp == NULL) {
4767 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
4768 }
4769 *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
4770 acbp->callback = pCallback;
4771 acbp->userdata = pUserData;
4772 acbp->lib_info = lib_infop;
4773
4774 status = (registeredfunc)(smhba_adapterportstatevents_callback,
4775 (void *)acbp,
4776 vendorHandle,
4777 portWWN,
4778 protocolType,
4779 stats,
4780 statType,
4781 &acbp->vendorcbhandle);
4782 if (status != HBA_STATUS_OK) {
4783 free(acbp);
4784 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4785 }
4786
4787 GRAB_MUTEX(&_smhba_APSE_mutex);
4788 acbp->next = _smhba_adapterportstatevents_callback_list;
4789 _smhba_adapterportstatevents_callback_list = acbp;
4790
4791 RELEASE_MUTEX(&_smhba_APSE_mutex);
4792 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
4793 }
4794
4795 /* SMHBA Adapter Port Phy Stat Events ************************************ */
4796 static void
4797 smhba_adapterphystatevents_callback(void *data,
4798 HBA_WWN portWWN,
4799 HBA_UINT32 phyIndex,
4800 HBA_UINT32 eventType)
4801 {
4802 HBA_ADAPTERCALLBACK_ELEM *acbp;
4803
4804 DEBUG(3,
4805 "SMBA_AdapterPortStateEvent, port:%s, eventType:%d",
4806 WWN2STR1(&portWWN), eventType, 0);
4807
4808 GRAB_MUTEX(&_smhba_APHYSE_mutex);
4809 for (acbp = _smhba_adapterphystatevents_callback_list;
4810 acbp != NULL;
4811 acbp = acbp->next) {
4812 if (data == (void *)acbp) {
4813 (*acbp->callback)(acbp->userdata, portWWN, phyIndex, eventType);
4814 return;
4815 }
4816 }
4817 RELEASE_MUTEX(&_smhba_APHYSE_mutex);
4818 }
4819
4820 HBA_STATUS
4821 SMHBA_RegisterForAdapterPhyStatEvents(
4822 void (*pCallback) (
4823 void *pData,
4824 HBA_WWN portWWN,
4825 HBA_UINT32 phyIndex,
4826 HBA_UINT32 eventType),
4827 void *pUserData,
4828 HBA_HANDLE handle,
4829 HBA_WWN portWWN,
4830 HBA_UINT32 phyIndex,
4831 SMHBA_PHYSTATISTICS stats,
4832 HBA_UINT32 statType,
4833 HBA_CALLBACKHANDLE *pCallbackHandle) {
4834
4835 HBA_ADAPTERCALLBACK_ELEM *acbp;
4836 SMHBARegisterForAdapterPhyStatEventsFunc
4837 registeredfunc;
4838 HBA_STATUS status;
4839 HBA_LIBRARY_INFO *lib_infop;
4840 HBA_HANDLE vendorHandle;
4841
4842 DEBUG(2, "SMHBA_RegisterForAdapterPhyStatEvents for port: %s",
4843 WWN2STR1(&portWWN), 0, 0);
4844
4845 CHECKLIBRARYANDVERSION(SMHBA);
4846 /* we now have the _hbaapi_LL_mutex */
4847
4848 registeredfunc =
4849 lib_infop->ftable.smhbafunctionTable.\
4850 RegisterForAdapterPhyStatEventsHandler;
4851 if (registeredfunc == NULL) {
4852 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
4853 }
4854
4855 /*
4856 * that allocated memory is used both as the handle for the
4857 * caller, and as userdata to the vendor call so that on
4858 * callback the specific registration may be recalled
4859 */
4860 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
4861 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
4862 if (acbp == NULL) {
4863 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
4864 }
4865 *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
4866 acbp->callback = pCallback;
4867 acbp->userdata = pUserData;
4868 acbp->lib_info = lib_infop;
4869
4870 status = (registeredfunc)(smhba_adapterphystatevents_callback,
4871 (void *)acbp,
4872 vendorHandle,
4873 portWWN,
4874 phyIndex,
4875 stats,
4876 statType,
4877 &acbp->vendorcbhandle);
4878 if (status != HBA_STATUS_OK) {
4879 free(acbp);
4880 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4881 }
4882
4883 GRAB_MUTEX(&_smhba_APHYSE_mutex);
4884 acbp->next = _smhba_adapterphystatevents_callback_list;
4885 _smhba_adapterphystatevents_callback_list = acbp;
4886
4887 RELEASE_MUTEX(&_smhba_APHYSE_mutex);
4888 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
4889 }
4890
4891 /* SMHBA Target Events ********************************************* */
4892 static void
4893 smhba_targetevents_callback(void *data,
4894 HBA_WWN hbaPortWWN,
4895 HBA_WWN discoveredPortWWN,
4896 HBA_WWN domainPortWWN,
4897 HBA_UINT32 eventType)
4898 {
4899 HBA_ADAPTERCALLBACK_ELEM *acbp;
4900
4901 DEBUG(3, "TargetEvent, hbaPort:%s, discoveredPort:%s eventType:%d",
4902 WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), eventType);
4903
4904 GRAB_MUTEX(&_smhba_TE_mutex);
4905 for (acbp = _smhba_targetevents_callback_list;
4906 acbp != NULL;
4907 acbp = acbp->next) {
4908 if (data == (void *)acbp) {
4909 (*acbp->callback)(acbp->userdata, hbaPortWWN,
4910 discoveredPortWWN, domainPortWWN, eventType);
4911 break;
4912 }
4913 }
4914 RELEASE_MUTEX(&_smhba_TE_mutex);
4915 }
4916
4917 HBA_STATUS
4918 SMHBA_RegisterForTargetEvents(
4919 void (*pCallback) (
4920 void *pData,
4921 HBA_WWN hbaPortWWN,
4922 HBA_WWN discoveredPortWWN,
4923 HBA_WWN domainPortWWN,
4924 HBA_UINT32 eventType),
4925 void *pUserData,
4926 HBA_HANDLE handle,
4927 HBA_WWN hbaPortWWN,
4928 HBA_WWN discoveredPortWWN,
4929 HBA_WWN domainPortWWN,
4930 HBA_CALLBACKHANDLE *pCallbackHandle,
4931 HBA_UINT32 allTargets) {
4932
4933 HBA_ADAPTERCALLBACK_ELEM *acbp;
4934 SMHBARegisterForTargetEventsFunc
4935 registeredfunc;
4936 HBA_STATUS status;
4937 HBA_LIBRARY_INFO *lib_infop;
4938 HBA_HANDLE vendorHandle;
4939
4940 DEBUG(2, "SMHBA_RegisterForTargetEvents, hbaPort:"
4941 "%s, discoveredPort: %s",
4942 WWN2STR1(&hbaPortWWN), WWN2STR2(&discoveredPortWWN), 0);
4943
4944 CHECKLIBRARYANDVERSION(SMHBA);
4945 /* we now have the _hbaapi_LL_mutex */
4946
4947 registeredfunc = lib_infop->ftable.smhbafunctionTable.\
4948 RegisterForTargetEventsHandler;
4949
4950 if (registeredfunc == NULL) {
4951 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR_NOT_SUPPORTED);
4952 }
4953
4954 /*
4955 * that allocated memory is used both as the handle for the
4956 * caller, and as userdata to the vendor call so that on
4957 * callback the specific registration may be recalled
4958 */
4959 acbp = (HBA_ADAPTERCALLBACK_ELEM *)
4960 calloc(1, sizeof (HBA_ADAPTERCALLBACK_ELEM));
4961 if (acbp == NULL) {
4962 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_ERROR);
4963 }
4964 *pCallbackHandle = (HBA_CALLBACKHANDLE) acbp;
4965 acbp->callback = pCallback;
4966 acbp->userdata = pUserData;
4967 acbp->lib_info = lib_infop;
4968
4969 status = (registeredfunc)(smhba_targetevents_callback,
4970 (void *)acbp,
4971 vendorHandle,
4972 hbaPortWWN,
4973 discoveredPortWWN,
4974 domainPortWWN,
4975 &acbp->vendorcbhandle,
4976 allTargets);
4977 if (status != HBA_STATUS_OK) {
4978 free(acbp);
4979 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, status);
4980 }
4981
4982 GRAB_MUTEX(&_smhba_TE_mutex);
4983 acbp->next = _smhba_targetevents_callback_list;
4984 _smhba_targetevents_callback_list = acbp;
4985
4986 RELEASE_MUTEX(&_smhba_TE_mutex);
4987 RELEASE_MUTEX_RETURN(&_hbaapi_LL_mutex, HBA_STATUS_OK);
4988 }