/* * Description * hbaapitest.c - Sample application which uses the common library API for * HBA requests. * * License: * The contents of this file are subject to the SNIA Public License * Version 1.0 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * * www.snia.org/smi/developers/cim * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See * the License for the specific language governing rights and limitations * under the License. * * The Original Code is SNIA HBA API Sample Application * * The Initial Developer of the Original Code is: * Dixon Hutchinson, Legato Systems, Inc. (dhutchin@legato.com) * *************************************************************************** * Revision History: * * X-3 OH0104 Oliver Hellwig 5-Jan-2006 * 1) Work on the Read Capacity tests. * 2) Update the URL in the header for the SNIA license. * 3) Work on the getfcptargetmapping test and output * a message if the buffer is too small to receive * all available data. * * X-2 OH0103 Oliver Hellwig 11-Nov-2005 * Minor fixes. * * 23-Jun-2005 Oliver Hellwig Expand the tests for VMS * 12-Nov-2003 J. Malmberg Add new tests. * 30-Oct-2003 J. Malmberg Port to OpenVMS. * *************************************************************************** */ /* * VMS NOTES: * * Define the following system logicals: * * define/system snia$hba_conf sys$library:hba.conf * define/system snia$libhbaapi sys$library:libhbaapi * define/system snia$lib_vms sys$library:hba_vms * * Build this test program (after the above logicals are defined): * * cc/pointer_size=short/standard=relaxed hbaapitest.c * link hbaapitest.obj,libhbaapi.opt/opt * */ /*#define BRIEF 1 /* define to print less information */ #define TESTING /* define to run the current debugging configuration */ #include #include #include #ifndef WIN32 #ifndef __VMS #include /* Dynamic library support for Solaris */ #endif #include #endif #include "hbaapi.h" /*** Came from JNI ********************************************************** ** Utility function that treats the passed value as an array of bytes, then ** formats and prints them in ASCII Hex format. This function will ** optionally insert spaces into the output string at specified intervals. ****************************************************************************/ void PrintHexString(void *Data, int Length, int Break, int space) { int j; unsigned char *pc = (unsigned char *)Data; for (j=1; j<=Length; j++) { printf("%02X", (int)*pc++); if ( (Break != 0) && (jcloseadapter.pass, mtp->closeadapter.fail, mtp->closeadapter.skip, mtp->closeadapter.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "FreeLibrary", mtp->freelibrary.pass, mtp->freelibrary.fail, mtp->freelibrary.skip, mtp->freelibrary.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetAdapterAttributes", mtp->getadapterattributes.pass, mtp->getadapterattributes.fail, mtp->getadapterattributes.skip, mtp->getadapterattributes.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetAdapterName", mtp->getadaptername.pass, mtp->getadaptername.fail, mtp->getadaptername.skip, mtp->getadaptername.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetAdapterPortAttributes", mtp->getadapterportattributes.pass, mtp->getadapterportattributes.fail, mtp->getadapterportattributes.skip, mtp->getadapterportattributes.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetDiscoveredPortAttributes", mtp->getdiscoveredportattributes.pass, mtp->getdiscoveredportattributes.fail, mtp->getdiscoveredportattributes.skip, mtp->getdiscoveredportattributes.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetNumberOfAdapters", mtp->getnumberofadapters.pass, mtp->getnumberofadapters.fail, mtp->getnumberofadapters.skip, mtp->getnumberofadapters.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetPortStatistics", mtp->getportstatistics.pass, mtp->getportstatistics.fail, mtp->getportstatistics.skip, mtp->getportstatistics.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetRNIDMgmtInfo", mtp->getrnidmgmtinfo.pass, mtp->getrnidmgmtinfo.fail, mtp->getrnidmgmtinfo.skip, mtp->getrnidmgmtinfo.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetWrapperLibraryAttributes", mtp->getwrapperlibraryattributes.pass, mtp->getwrapperlibraryattributes.fail, mtp->getwrapperlibraryattributes.skip, mtp->getwrapperlibraryattributes.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetVendorLibraryAttributes", mtp->getvendorlibraryattributes.pass, mtp->getvendorlibraryattributes.fail, mtp->getvendorlibraryattributes.skip, mtp->getvendorlibraryattributes.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "LoadLibrary", mtp->loadlibrary.pass, mtp->loadlibrary.fail, mtp->loadlibrary.skip, mtp->loadlibrary.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "OpenAdapter", mtp->openadapter.pass, mtp->openadapter.fail, mtp->openadapter.skip, mtp->openadapter.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RefreshAdapterConfiguration", mtp->refreshadapterconfiguration.pass, mtp->refreshadapterconfiguration.fail, mtp->refreshadapterconfiguration.skip, mtp->refreshadapterconfiguration.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RefreshInformation", mtp->refreshinformation.pass, mtp->refreshinformation.fail, mtp->refreshinformation.skip, mtp->refreshinformation.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "ResetStatistics", mtp->resetstatistics.pass, mtp->resetstatistics.fail, mtp->resetstatistics.skip, mtp->resetstatistics.unsup); } void management_results(struct management_tests_t *manp) { fprintf(stderr, "\nManagement Required results\t\tpass\tfail\tskip\tunsupported\n"); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetEventBuffer", manp->geteventbuffer.pass, manp->geteventbuffer.fail, manp->geteventbuffer.skip, manp->geteventbuffer.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RegisterForAdapterPortEvents", manp->registerforadapterportevents.pass, manp->registerforadapterportevents.fail, manp->registerforadapterportevents.skip, manp->registerforadapterportevents.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RegisterForLinkEvents", manp->registerforlinkevents.pass, manp->registerforlinkevents.fail, manp->registerforlinkevents.skip, manp->registerforlinkevents.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RemoveCallback", manp->removecallback.pass, manp->removecallback.fail, manp->removecallback.skip, manp->removecallback.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendRNID", manp->sendrnid.pass, manp->sendrnid.fail, manp->sendrnid.skip, manp->sendrnid.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendRNIDV2", manp->sendrnidv2.pass, manp->sendrnidv2.fail, manp->sendrnidv2.skip, manp->sendrnidv2.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendRPL", manp->sendrpl.pass, manp->sendrpl.fail, manp->sendrpl.skip, manp->sendrpl.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendRPS", manp->sendrps.pass, manp->sendrps.fail, manp->sendrps.skip, manp->sendrps.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendSRL", manp->sendsrl.pass, manp->sendsrl.fail, manp->sendsrl.skip, manp->sendsrl.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendLIRR", manp->sendlirr.pass, manp->sendlirr.fail, manp->sendlirr.skip, manp->sendlirr.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendRLS", manp->sendrls.pass, manp->sendrls.fail, manp->sendrls.skip, manp->sendrls.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendCTPassThru", manp->sendctpassthru.pass, manp->sendctpassthru.fail, manp->sendctpassthru.skip, manp->sendctpassthru.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendCTPassThruV2", manp->sendctpassthruv2.pass, manp->sendctpassthruv2.fail, manp->sendctpassthruv2.skip, manp->sendctpassthruv2.unsup); } void optional_results(struct optional_tests_t *otp) { fprintf(stderr, "\nOptional results\t\t\tpass\tfail\tskip\tunsupported\n"); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetBindingCapability", otp->getbindingcapability.pass, otp->getbindingcapability.fail, otp->getbindingcapability.skip, otp->getbindingcapability.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetBindingSupport", otp->getbindingsupport.pass, otp->getbindingsupport.fail, otp->getbindingsupport.skip, otp->getbindingsupport.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetFC4Statistics", otp->getfc4statistics.pass, otp->getfc4statistics.fail, otp->getfc4statistics.skip, otp->getfc4statistics.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetFcpPersistentBinding", otp->getfcppersistentbinding.pass, otp->getfcppersistentbinding.fail, otp->getfcppersistentbinding.skip, otp->getfcppersistentbinding.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetFCPStatistics", otp->getfcpstatistics.pass, otp->getfcpstatistics.fail, otp->getfcpstatistics.skip, otp->getfcpstatistics.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetFcpTargetMapping", otp->getfcptargetmapping.pass, otp->getfcptargetmapping.fail, otp->getfcptargetmapping.skip, otp->getfcptargetmapping.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetFcpTargetMappingV2", otp->getfcptargetmappingv2.pass, otp->getfcptargetmappingv2.fail, otp->getfcptargetmappingv2.skip, otp->getfcptargetmappingv2.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetPersistentBindingV2", otp->getpersistentbindingv2.pass, otp->getpersistentbindingv2.fail, otp->getpersistentbindingv2.skip, otp->getpersistentbindingv2.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetPortAttributesByWWN", otp->getportattributesbywwn.pass, otp->getportattributesbywwn.fail, otp->getportattributesbywwn.skip, otp->getportattributesbywwn.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SBDskGetCapacity", otp->sbdskgetcapacity.pass, otp->sbdskgetcapacity.fail, otp->sbdskgetcapacity.skip, otp->sbdskgetcapacity.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetSBTargetMapping", otp->getsbtargetmapping.pass, otp->getsbtargetmapping.fail, otp->getsbtargetmapping.skip, otp->getsbtargetmapping.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "GetSBStatistics", otp->getsbstatistics.pass, otp->getsbstatistics.fail, otp->getsbstatistics.skip, otp->getsbstatistics.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "OpenAdapterByWWN", otp->openadapterbywwn.pass, otp->openadapterbywwn.fail, otp->openadapterbywwn.skip, otp->openadapterbywwn.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RegisterForAdapterAddEvents", otp->registerforadapteraddevents.pass, otp->registerforadapteraddevents.fail, otp->registerforadapteraddevents.skip, otp->registerforadapteraddevents.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RegisterForAdapterEvents", otp->registerforadapterevents.pass, otp->registerforadapterevents.fail, otp->registerforadapterevents.skip, otp->registerforadapterevents.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RegisterForAdapterPortStatEvents", otp->registerforadapterportstatevents.pass, otp->registerforadapterportstatevents.fail, otp->registerforadapterportstatevents.skip, otp->registerforadapterportstatevents.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RegisterForTargetEvents", otp->registerfortargetevents.pass, otp->registerfortargetevents.fail, otp->registerfortargetevents.skip, otp->registerfortargetevents.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "RemoveAllPersistentBinding", otp->removeallpersistentbinding.pass, otp->removeallpersistentbinding.fail, otp->removeallpersistentbinding.skip, otp->removeallpersistentbinding.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "ScsiInquiryV2", otp->scsiinquiryv2.pass, otp->scsiinquiryv2.fail, otp->scsiinquiryv2.skip, otp->scsiinquiryv2.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "ScsiReadCapacityV2", otp->scsireadcapacityv2.pass, otp->scsireadcapacityv2.fail, otp->scsireadcapacityv2.skip, otp->scsireadcapacityv2.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "ScsiReportLunsV2", otp->scsireportlunsv2.pass, otp->scsireportlunsv2.fail, otp->scsireportlunsv2.skip, otp->scsireportlunsv2.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendReadCapacity", otp->sendreadcapacity.pass, otp->sendreadcapacity.fail, otp->sendreadcapacity.skip, otp->sendreadcapacity.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendReportLUNs", otp->sendreportluns.pass, otp->sendreportluns.fail, otp->sendreportluns.skip, otp->sendreportluns.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SendScsiInquiry", otp->sendscsiinquiry.pass, otp->sendscsiinquiry.fail, otp->sendscsiinquiry.skip, otp->sendscsiinquiry.unsup); fprintf(stderr, "%32.32s\t%d\t%d\t%d\t%d\n", "SetRNIDMgmtInfo", otp->setrnidmgmtinfo.pass, otp->setrnidmgmtinfo.fail, otp->setrnidmgmtinfo.skip, otp->setrnidmgmtinfo.unsup); } #define MAPENTRIES 1024 union { HBA_FCPTARGETMAPPING fcp_tmap; struct { HBA_UINT32 cnt; HBA_FCPSCSIENTRY entry[MAPENTRIES]; } fcp_tmapi; } MAPU; union { HBA_FCPTARGETMAPPINGV2 fcp_tmap; struct { HBA_UINT32 cnt; HBA_FCPSCSIENTRYV2 entry[MAPENTRIES]; } fcp_tmapi; } MAPU_V2; int print_detail = 0; /* print detail information */ int print_results = 0; /* print summary of working / non-working functions */ /* Main test program */ /*-------------------*/ main(int argc, const char * argv[]) { int i, pi, j, dpi, ti, bi; HBA_STATUS retval; HBA_UINT32 hba_cnt; char namebuf[1028]; HBA_HANDLE hba_handle; HBA_ADAPTERATTRIBUTES hba_attrs; HBA_PORTATTRIBUTES hba_portattrs; HBA_PORTSTATISTICS hba_portstats; HBA_PORTATTRIBUTES hba_disc_pattrs; HBA_WWN test_wwnn; int test_wwnn_set; HBA_WWN test_wwpn; int test_wwpn_set; HBA_WWN test_dwwpn; int test_dwwpn_set; HBA_UINT32 test_wwpn_pi; int manditory_fail; int manditory_pass; int manditory_skip; int manditory_unsup; int management_fail; int management_pass; int management_skip; int management_unsup; int optional_fail; int optional_pass; int optional_skip; int optional_unsup; unsigned char large_buf[4096]; unsigned int large_buf_size; unsigned char sense_buf[255]; unsigned int sense_buf_size; unsigned char scsi_status; HBA_SBTARGETMAPPING * sbtmap; int test_scsiid_set; HBA_SCSIID test_scsiid; int test_fcpid_set = 0; HBA_FCPID test_fcpid; HBA_SBDEVID sb_device; HBA_SBSTATISTICS sb_stats; HBA_SBDSKCAPACITY sb_diskcap; HBA_EVENTINFO event_info[4]; HBA_UINT32 event_count; #define BINDENTRIES 512 union{ HBA_FCPBINDING fcp_tbind; struct { HBA_UINT32 cnt; HBA_FCPBINDINGENTRY entry[BINDENTRIES]; }fcp_tbindi; }BINDU; union{ HBA_FCPBINDING2 fcp_tbind; struct { HBA_UINT32 cnt; HBA_FCPBINDINGENTRY2 entry[BINDENTRIES]; }fcp_tbindi; }BINDU_V2; manditory_fail = 0; manditory_pass = 0; manditory_skip = 0; manditory_unsup = 0; management_fail = 0; management_pass = 0; management_skip = 0; management_unsup = 0; optional_fail = 0; optional_pass = 0; optional_skip = 0; optional_unsup = 0; memset(&manditory_tests, 0, sizeof(struct manditory_tests_t)); memset(&management_tests, 0, sizeof(struct management_tests_t)); memset(&optional_tests, 0, sizeof(struct optional_tests_t)); #ifdef TESTING print_detail = 1; print_results = 1; /* print summary of working / non-working functions */ #endif printf("\nStarting HBA API test...\n"); if (print_detail) { printf("HBA API Library version is %d\n", HBA_GetVersion()); } retval = HBA_LoadLibrary(); if(retval != HBA_STATUS_OK) { perror("HBA_LoadLibrary"); print_hbaerror(retval); exit(1); } manditory_tests.loadlibrary.pass++; manditory_pass++; hba_cnt = HBA_GetNumberOfAdapters(); if (print_detail) { printf("Number of HBA's is %d\n", hba_cnt); } if (hba_cnt == 0) { fprintf(stderr, "not enough adapters\n"); exit(1); } manditory_tests.getnumberofadapters.pass++; manditory_pass++; test_wwnn_set = 0; test_wwpn_set = 0; test_dwwpn_set = 0; test_scsiid_set = 0; large_buf_size = sizeof(large_buf); sense_buf_size = sizeof(sense_buf); /* * For each adapter ... */ for (i = 0; i < hba_cnt; i++) { if ((retval = HBA_GetAdapterName(i, namebuf)) != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_GetAdapterName: %d\n", retval); print_hbaerror(retval); manditory_fail++; manditory_tests.getadaptername.fail++; continue; } #if 0 { char *name = "_FGA0:"; if (strcmp(namebuf,name)) { printf("Looking for %s but found %s, goto next adapter.\n", name, namebuf); continue; } } #endif manditory_tests.getadaptername.pass++; manditory_pass++; if (print_detail) { printf("\n********************************************" "\nAdapter number %d is named: \"%s\"\n", i, namebuf); } if ((hba_handle = HBA_OpenAdapter(namebuf)) == 0) { fprintf(stderr, "Failure of HBA_OpenAdapter\n"); perror("HBA_OpenAdapter"); print_hbaerror(retval); manditory_tests.openadapter.fail++; manditory_fail++; continue; } manditory_tests.openadapter.pass++; manditory_pass++; if ((retval = HBA_GetAdapterAttributes(hba_handle, &hba_attrs)) != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_GetAdapterAttributes:%d\n", retval); print_hbaerror(retval); manditory_tests.getadapterattributes.fail++; manditory_fail++; goto close; } manditory_tests.getadapterattributes.pass++; manditory_pass++; if (print_detail) { printf("Adapter Attributes\n"); printf(" Manufacturer: %s\n", hba_attrs.Manufacturer); printf(" SerialNumber: %s\n", hba_attrs.SerialNumber); printf(" Model: %s\n", hba_attrs.Model); printf(" ModelDesc: %s\n", hba_attrs.ModelDescription); printf(" NodeWWN: "); PrintWWN(hba_attrs.NodeWWN.wwn); printf("\n"); printf(" NodeSymName: %s\n", hba_attrs.NodeSymbolicName); printf(" HardwareVersion: %s\n", hba_attrs.HardwareVersion); printf(" DriverVersion: %s\n", hba_attrs.DriverVersion); printf(" OptionROMVersion: %s\n", hba_attrs.OptionROMVersion); printf(" FirmwareVersion: %s\n", hba_attrs.FirmwareVersion); printf(" VendorSpecificID: %d\n", hba_attrs.VendorSpecificID); printf(" NumberOfPorts: %d\n", hba_attrs.NumberOfPorts); printf(" DriverName: %s\n", hba_attrs.DriverName); } if (hba_attrs.NumberOfPorts == 0) { manditory_tests.getadapterportattributes.skip++; manditory_skip++; } for (pi = 0; pi < hba_attrs.NumberOfPorts; pi++) { retval = HBA_GetAdapterPortAttributes(hba_handle, pi, &hba_portattrs); if (retval != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_GetAdapterPortAttributes for pi=%d," "status=%d\n", pi, retval); print_hbaerror(retval); manditory_tests.getadapterportattributes.fail++; manditory_fail++; goto close; } manditory_tests.getadapterportattributes.pass++; manditory_pass++; /* Save a valid WWNN for a later test */ /*------------------------------------*/ if (test_wwnn_set == 0) { test_wwnn_set++; memcpy(&test_wwnn, &hba_attrs.NodeWWN, sizeof(HBA_WWN)); } /* Save a valid WWPN for a later test */ /*------------------------------------*/ if (test_wwpn_set == 0) { test_wwpn_set++; memcpy(&test_wwpn, &hba_portattrs.PortWWN, sizeof(HBA_WWN)); test_wwpn_pi = pi; } if (print_detail) { printf(" PortIndex: %d\n", pi); printf(" Adapter Port Attributes:\n"); printf(" NodeWWN: "); PrintWWN(hba_portattrs.NodeWWN.wwn); printf("\n"); printf(" PortWWN: "); PrintWWN(hba_portattrs.PortWWN.wwn); printf("\n"); printf(" PortFcId: 0x%06lX\n", hba_portattrs.PortFcId); printf(" PortType: %d\n", hba_portattrs.PortType); printf(" PortState: %d\n", hba_portattrs.PortState); #ifndef BRIEF printf(" PortSupportedClassofService:%d\n", hba_portattrs.PortSupportedClassofService); printf(" PortSupportedFc4Types:"); for (j = 0; j < 32; j++) { printf(" %02X", hba_portattrs.PortSupportedFc4Types.bits[j]); } printf("\n"); printf(" PortActiveFc4Types:"); for (j = 0; j < 32; j++) { printf(" %02X", hba_portattrs.PortActiveFc4Types.bits[j]); } printf("\n"); printf(" PortSymbolicName: %s\n", hba_portattrs.PortSymbolicName); printf(" OSDeviceName: %s\n", hba_portattrs.OSDeviceName); printf(" PortSupportedSpeed: %d\n", hba_portattrs.PortSupportedSpeed); printf(" PortSpeed: %d\n", hba_portattrs.PortSpeed); printf(" PortMaxFrameSize: %d\n", hba_portattrs.PortMaxFrameSize); printf(" FabricName: "); PrintWWN(hba_portattrs.FabricName.wwn); printf("\n"); #endif /* ifndef BRIEF */ printf(" NumberofDiscoveredPorts:%d\n", hba_portattrs.NumberofDiscoveredPorts); } #if 0 /* * Test for bug where second call does not return a WWN */ retval = HBA_GetAdapterPortAttributes(hba_handle, pi, &hba_portattrs); if (retval != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_GetAdapterPortAttributes for pi=%d," "status=%d\n", pi, retval); print_hbaerror(retval); exit(0); } printf("Second call to HBA_GetAdapterPortAttrubutes()\n"); printf(" NodeWWN: "); PrintWWN(hba_portattrs.NodeWWN.wwn); printf("\n"); printf(" PortWWN: "); PrintWWN(hba_portattrs.PortWWN.wwn); printf("\n"); #endif retval = HBA_GetPortStatistics(hba_handle, pi, &hba_portstats); if (retval != HBA_STATUS_OK && retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { fprintf(stderr, "Failure of HBA_GetPortStatistics for pi=%d," "status=%d\n", pi, retval); print_hbaerror(retval); manditory_tests.getportstatistics.fail++; manditory_fail++; goto close; } if (retval == HBA_STATUS_ERROR_NOT_SUPPORTED) { printf(" Port Statistics not supported by this HBA\n"); manditory_tests.getportstatistics.fail++; manditory_fail++; } else { manditory_tests.getportstatistics.pass++; manditory_pass++; if (print_detail) { printf(" Adapter Port Statistics\n"); printf(" SecondsSinceLastReset: %lld\n", hba_portstats.SecondsSinceLastReset); printf(" TxFrames: %lld\n", hba_portstats.TxFrames); printf(" TxWords: %lld\n", hba_portstats.TxWords); printf(" RxFrames: %lld\n", hba_portstats.RxFrames); printf(" RxWords: %lld\n", hba_portstats.RxWords); #ifndef BRIEF printf(" LIPCount: %lld\n", hba_portstats.LIPCount); printf(" NOSCount: %lld\n", hba_portstats.NOSCount); printf(" ErrorFrames: %lld\n", hba_portstats.ErrorFrames); printf(" DumpedFrames: %lld\n", hba_portstats.DumpedFrames); #endif printf(" LinkFailureCount: %lld\n", hba_portstats.LinkFailureCount); printf(" LossOfSyncCount: %lld\n", hba_portstats.LossOfSyncCount); printf(" LossOfSignalCount: %lld\n", hba_portstats.LossOfSignalCount); printf(" PrimitiveSeqProtocolErrCount: %lld\n", hba_portstats.PrimitiveSeqProtocolErrCount); printf(" InvalidTxWordCount: %lld\n", hba_portstats.InvalidTxWordCount); printf(" InvalidCRCCount: %lld\n", hba_portstats.InvalidCRCCount); } } if (hba_portattrs.NumberofDiscoveredPorts == 0) { manditory_tests.getdiscoveredportattributes.pass++; manditory_pass++; } for (dpi = 0; dpi < hba_portattrs.NumberofDiscoveredPorts; dpi++) { __int64 node_wwn; __int64 port_wwn; retval = HBA_GetDiscoveredPortAttributes(hba_handle, pi, dpi, &hba_disc_pattrs); if (retval != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_GetDiscoveredPortAttributes\n" "for pi=%d, for dpi=%d, status=%d\n", pi, dpi, retval); print_hbaerror(retval); manditory_tests.getdiscoveredportattributes.fail++; manditory_fail++; goto close; } manditory_tests.getdiscoveredportattributes.pass++; manditory_pass++; /* * Don't send report luns to Well-Known Addresses */ memcpy(&node_wwn, hba_disc_pattrs.NodeWWN.wwn, sizeof(__int64)); memcpy(&port_wwn, hba_disc_pattrs.PortWWN.wwn, sizeof(__int64)); if ( node_wwn && port_wwn && hba_disc_pattrs.PortFcId && hba_disc_pattrs.PortFcId < 0xFFFFF5u) { #ifndef NORPTLUN retval = HBA_SendReportLUNs(hba_handle, hba_disc_pattrs.PortWWN, large_buf, sizeof(large_buf), sense_buf, sizeof(sense_buf)); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { #if 0 optional_fail++; optional_tests.sendreportluns.fail++; printf("HBA_SendReportLUNs failed %d\n", retval); print_hbaerror(retval); #endif } else { optional_tests.sendreportluns.unsup++; optional_unsup++; } } else { optional_tests.sendreportluns.pass++; optional_pass++; if (test_dwwpn_set == 0) { test_dwwpn_set = 1; memcpy (&test_dwwpn, &hba_disc_pattrs.PortWWN, sizeof(HBA_WWN)); test_wwpn_set++; memcpy (&test_wwpn, &hba_portattrs.PortWWN, sizeof(HBA_WWN)); test_wwpn_pi = pi; } if (print_detail) { printf(" Discovered Port Attributes (index=%d)\n", dpi); printf(" NodeWWN: "); PrintWWN( hba_disc_pattrs.NodeWWN.wwn); printf("\n"); printf(" PortWWN: "); PrintWWN(hba_disc_pattrs.PortWWN.wwn); printf("\n"); printf(" PortFcId: 0x%06lX\n", hba_disc_pattrs.PortFcId); printf(" PortType: %d\n", hba_disc_pattrs.PortType); printf(" PortState: %d\n", hba_disc_pattrs.PortState); #ifndef BRIEF printf(" PortSupportedClassofService:%d\n", hba_disc_pattrs.PortSupportedClassofService); printf(" PortSupportedFc4Types:"); for (j = 0; j < 32; j++) { printf(" %02X", hba_disc_pattrs.PortSupportedFc4Types.bits[j]); } printf("\n"); printf(" PortActiveFc4Types:"); for (j = 0; j < 32; j++) { printf(" %02X", hba_disc_pattrs.PortActiveFc4Types.bits[j]); } printf("\n"); printf(" PortSymbolicName: %s\n", hba_disc_pattrs.PortSymbolicName); printf(" OSDeviceName: %s\n", hba_disc_pattrs.OSDeviceName); printf(" PortSupportedSpeed: %d\n", hba_disc_pattrs.PortSupportedSpeed); printf(" PortSpeed: %d\n", hba_disc_pattrs.PortSpeed); printf(" PortMaxFrameSize: %d\n", hba_disc_pattrs.PortMaxFrameSize); printf(" FabricName: "); PrintWWN(hba_disc_pattrs.FabricName.wwn); printf("\n"); #endif printf(" NumberofDiscoveredPorts: %d\n", hba_disc_pattrs.NumberofDiscoveredPorts); } } /* else report luns was successful */ #else if (print_detail) printf("HBA_SendReportLUNs skipped.\n\n"); optional_tests.sendreportluns.skip++; optional_skip++; #endif /* ifndef NORPTLUN */ } } /* number of discovered ports */ } /* number of ports */ #if 0 printf("early exit\n"); exit(0); #endif #ifndef NOMAPPING MAPU.fcp_tmapi.cnt = MAPENTRIES; retval = HBA_GetFcpTargetMapping(hba_handle, &MAPU.fcp_tmap); if (retval != HBA_STATUS_OK) { if (retval == HBA_STATUS_ERROR) { /* No targets returned; */ /* this is not an error. */ } else if (retval == HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getfcptargetmapping.unsup++; optional_unsup++; } else { optional_tests.getfcptargetmapping.fail++; optional_fail++; fprintf(stderr, "failure of HBA_GetFcpTargetMapping, status=%d\n", retval); print_hbaerror(retval); if (retval == HBA_STATUS_ERROR_MORE_DATA) { printf("There are %d targets available but we only provided room for %d.\n" ,MAPU.fcp_tmapi.cnt ,MAPENTRIES ); } } } else { optional_tests.getfcptargetmapping.pass++; optional_pass++; if (print_detail) { printf("\n"); printf("Target Mappings: %d\n", MAPU.fcp_tmap.NumberOfEntries); } for (ti = 0; ti < MAPU.fcp_tmap.NumberOfEntries; ti++) { int max_blocks = 0; __int64 lun = MAPU.fcp_tmap.entry[ti].FcpId.FcpLun; if ((ti == 1) && (test_scsiid_set == 0)) { test_scsiid_set = 1; memcpy(&test_scsiid, &MAPU.fcp_tmap.entry[ti].ScsiId, sizeof(HBA_SCSIID)); test_fcpid_set = 1; memcpy(&test_fcpid, &MAPU.fcp_tmap.entry[ti].FcpId, sizeof(HBA_FCPID)); } if (lun) { retval = HBA_ScsiReadCapacityV2 (hba_handle, hba_portattrs.PortWWN, MAPU.fcp_tmap.entry[ti].FcpId.PortWWN, lun, large_buf, &large_buf_size, &scsi_status, sense_buf, &sense_buf_size); if (retval != HBA_STATUS_OK) { optional_tests.scsireadcapacityv2.fail++; optional_fail++; #ifdef VERBOSE if (scsi_status) { int sense_key = 0xf & sense_buf[2]; /* a sense key of 2 means the unit is not ready on this path */ if (sense_key != 2) { int asc = sense_buf[12]; int ascq = sense_buf[13]; int code = 0x7f & sense_buf[0]; printf("HBS_ScsiReadCapacityV2 SCSI status = %d", scsi_status); if (code = 0x70) { printf(", sense key = 0x%x", sense_key); printf(", asc = 0x%x", asc); printf(", ascq = 0x%x", ascq); } printf("\n"); } } else { fprintf(stderr, "Failure of HBA_ScsiReadCapacityV2:%d\n", retval); print_hbaerror(retval); } #endif } else { char *dst; char *src; optional_tests.scsireadcapacityv2.pass++; optional_pass++; src = (char *)large_buf; dst = (char *)&max_blocks; /* reverse the 4 bytes */ dst[0] = src[3]; dst[1] = src[2]; dst[2] = src[1]; dst[3] = src[0]; /* convert the last block index to max block count */ max_blocks++; } } if (print_detail) { printf("%6d: scsiID: %s, Bus: %u, Target: %u, Lun: %u\n", ti, MAPU.fcp_tmap.entry[ti].ScsiId.OSDeviceName, MAPU.fcp_tmap.entry[ti].ScsiId.ScsiBusNumber, MAPU.fcp_tmap.entry[ti].ScsiId.ScsiTargetNumber, MAPU.fcp_tmap.entry[ti].ScsiId.ScsiOSLun); printf(" FcpId: ID:%06x, NWWN: ",MAPU.fcp_tmap.entry[ti].FcpId.FcId); PrintWWN(MAPU.fcp_tmap.entry[ti].FcpId.NodeWWN.wwn); printf(" PWWN: "); PrintWWN(MAPU.fcp_tmap.entry[ti].FcpId.PortWWN.wwn); printf(" FcpLun:0x%llX\n", lun); if (max_blocks) { printf(" Block count = %d\n", max_blocks); } printf("\n"); } } } /* else get fcp target mapping succeeded */ BINDU.fcp_tbindi.cnt = BINDENTRIES; retval = HBA_GetFcpPersistentBinding(hba_handle, &BINDU.fcp_tbind); if (retval == HBA_STATUS_OK) { optional_tests.getfcppersistentbinding.pass++; optional_pass++; if (print_detail) { printf("Persistant Bindings: %d\n", BINDU.fcp_tbind.NumberOfEntries); for (bi = 0; bi < BINDU.fcp_tbind.NumberOfEntries; bi++) { printf("BindingType:%s\n", (BINDU.fcp_tbind.entry[bi].type == TO_D_ID)? "TO_D_ID" : "TO_WWN"); printf("scsiID: %s, Bus: %u, Target: %u, Lun: %u\n", BINDU.fcp_tbind.entry[bi].ScsiId.OSDeviceName, BINDU.fcp_tbind.entry[bi].ScsiId.ScsiBusNumber, BINDU.fcp_tbind.entry[bi].ScsiId.ScsiTargetNumber, BINDU.fcp_tbind.entry[bi].ScsiId.ScsiOSLun); printf("FcpId: ID:%06x, NWWN: ", BINDU.fcp_tbind.entry[bi].FcpId.FcId); PrintWWN(BINDU.fcp_tbind.entry[bi].FcpId.NodeWWN.wwn); printf(" PWWN: "); PrintWWN(BINDU.fcp_tbind.entry[bi].FcpId.PortWWN.wwn); printf(" FcpLun:0x%llX\n", BINDU.fcp_tbind.entry[bi].FcpId.FcpLun); printf("FcId:%d\n\n", BINDU.fcp_tbind.entry[bi].FcId); } } } else if (retval == HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getfcppersistentbinding.unsup++; optional_unsup++; } else { fprintf(stderr, "failure of HBA_GetFcpPersistantBinding, status=%d\n", retval); print_hbaerror(retval); if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getfcppersistentbinding.fail++; optional_fail++; goto close; } else { optional_tests.getfcppersistentbinding.unsup++; optional_unsup++; } } #endif close: HBA_CloseAdapter(hba_handle); manditory_tests.closeadapter.pass++; manditory_pass++; } /* for (i = 0; i < hba_cnt; i++) */ /* Test OpenAdapterbyWWN */ /*-----------------------*/ if (test_wwnn_set != 0) { HBA_BIND_CAPABILITY bind_cap; HBA_MGMTINFO mgmt_info; HBA_FC4STATISTICS fc4stat; HBA_LIBRARYATTRIBUTES lib_attr; HBA_WWN wwn2; HBA_CALLBACKHANDLE AdapterAddCallback; HBA_CALLBACKHANDLE AdapterCallback; HBA_CALLBACKHANDLE AdapterPortCallback; HBA_CALLBACKHANDLE AdapterPortStatCallback; HBA_PORTSTATISTICS stats = {0}; HBA_CALLBACKHANDLE TargetCallback; HBA_CALLBACKHANDLE LinkCallback; HBA_DEVICESELFDESC deviceselfdesc = {0}; retval = HBA_OpenAdapterByWWN(&hba_handle, test_wwnn); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.openadapterbywwn.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_OpenAdapterByWWN\n"); perror("HBA_OpenAdapterByWWN"); print_hbaerror(retval); goto DoneOpenbyWWN; } else { optional_tests.openadapterbywwn.unsup++; optional_unsup++; } } optional_tests.openadapterbywwn.pass++; optional_pass++; if (test_wwpn_set != 0) { retval = HBA_GetPortAttributesByWWN (hba_handle, test_wwpn, &hba_portattrs); if(retval != HBA_STATUS_OK) { optional_fail++; if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getportattributesbywwn.fail++; fprintf(stderr, "Failure of HBA_GetAdapterPortAttributesByWWN," "status=%d\n", retval); print_hbaerror(retval); goto DoneOpenbyWWN; } else { optional_tests.getportattributesbywwn.unsup++; optional_unsup++; } } optional_pass++; optional_tests.getportattributesbywwn.pass++; } else { /* Make sure that the handle is good */ /*-----------------------------------*/ retval = HBA_GetAdapterAttributes(hba_handle, &hba_attrs); if (retval != HBA_STATUS_OK) { manditory_tests.getadapterattributes.fail++; fprintf(stderr, "Failure of HBA_GetAdapterAttributes:%d\n", retval); print_hbaerror(retval); goto DoneOpenbyWWN; } manditory_tests.getadapterattributes.pass++; } /* Get LUN data */ /*--------------*/ if (test_dwwpn_set != 0) { retval = HBA_ScsiReportLUNsV2 (hba_handle, test_wwpn, test_dwwpn, large_buf, &large_buf_size, &scsi_status, sense_buf, &sense_buf_size); if (retval != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_SCSIReportLUNsV2:%d\n", retval); print_hbaerror(retval); if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.scsireportlunsv2.fail++; optional_fail++; } else { optional_tests.scsireportlunsv2.unsup++; optional_unsup++; } } else { optional_tests.scsireportlunsv2.pass++; optional_pass++; #ifdef VERBOSE printf(" Report LUNS V2 data: "); PrintHexString(large_buf, 40, 50, 0); printf("\n"); #endif } } else { if (print_detail) { printf("HBA_ScsiReportLUNsV2 skipped.\n"); } optional_tests.scsireportlunsv2.skip++; optional_skip++; } if (test_dwwpn_set != 0) { retval = HBA_SendReportLUNs (hba_handle, test_dwwpn, large_buf, sizeof(large_buf), sense_buf, sizeof (sense_buf)); if (retval != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_SendReportLUNs:%d\n", retval); print_hbaerror(retval); if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.sendreportluns.fail++; optional_fail++; } else { optional_tests.sendreportluns.unsup++; optional_unsup++; } } else { optional_tests.sendreportluns.pass++; optional_pass++; #ifdef VERBOSE printf(" Report LUNS data: "); PrintHexString(large_buf, 40, 50, 0); printf("\n"); #endif } } else { if (print_detail) { printf("HBA_SendReportLUNs skipped.\n"); } optional_tests.sendreportluns.skip++; optional_skip++; } /* Get SCSI Inquiry */ /*------------------*/ large_buf_size = 255; if (test_fcpid_set != 0) { retval = HBA_ScsiInquiryV2 (hba_handle, test_wwpn, test_fcpid.PortWWN, test_fcpid.FcpLun, /* LUN */ 0, 0, large_buf, &large_buf_size, &scsi_status, sense_buf, &sense_buf_size); if (retval != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_ScsiInquiryV2:%d\n", retval); print_hbaerror(retval); if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.scsiinquiryv2.fail++; optional_fail++; } else { optional_tests.scsiinquiryv2.unsup++; optional_unsup++; } } else { optional_tests.scsiinquiryv2.pass++; optional_pass++; #ifdef VERBOSE printf(" Inquiry V2 data: "); PrintHexString(large_buf, 255, 50, 0); printf("\n"); #endif } retval = HBA_SendScsiInquiry (hba_handle, test_fcpid.PortWWN, test_fcpid.FcpLun, /* LUN */ 0, 0, large_buf, 255, sense_buf, sizeof (sense_buf)); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.sendscsiinquiry.fail++; fprintf(stderr, "Failure of HBA_SendScsiInquiry:%d\n", retval); print_hbaerror(retval); optional_fail++; } else { optional_tests.sendscsiinquiry.unsup++; optional_unsup++; } } else { optional_tests.sendscsiinquiry.pass++; optional_pass++; #ifdef VERBOSE printf(" Inquiry data: "); PrintHexString(large_buf, 255, 50, 0); printf("\n"); #endif } } else { if (print_detail) { printf("HBA_ScsiInquiryV2, HBA_SendScsiInquiry skipped.\n"); } optional_tests.scsiinquiryv2.skip++; optional_skip++; optional_tests.sendscsiinquiry.skip++; optional_skip++; } /* Get LUN Capacity */ /*------------------*/ if (test_fcpid_set != 0) { /* HBA_ScsiReadCapacityV2 is tested earlier on each disk */ retval = HBA_SendReadCapacity (hba_handle, test_fcpid.PortWWN, test_fcpid.FcpLun, /* LUN */ large_buf, sizeof(large_buf), sense_buf, sizeof (sense_buf)); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.sendreadcapacity.fail++; fprintf(stderr, "Failure of HBA_ScsiReadCapacity:%d\n", retval); print_hbaerror(retval); optional_fail++; } else { optional_tests.sendreadcapacity.unsup++; optional_unsup++; } } else { optional_tests.sendreadcapacity.pass++; optional_pass++; #ifdef VERBOSE printf(" Read Capacity data:"); PrintHexString(large_buf, 20, 72, 0); printf("\n"); #endif } } else { if (print_detail) { printf("HBA_ScsiReadCapacityV2, HBA_ScsiReadCapacity skipped.\n"); } optional_tests.scsireadcapacityv2.skip++; optional_skip++; optional_tests.sendreadcapacity.skip++; optional_skip++; } #ifndef NOSBTARGET sbtmap = malloc(4 + 5 * sizeof(HBA_SBDEVENTRY)); if (sbtmap != NULL) { sbtmap->NumberofEntries = 4; retval = HBA_GetSBTargetMapping(hba_handle, test_wwpn, sbtmap); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getsbtargetmapping.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_GetSBTargetMapping:%d\n", retval); print_hbaerror(retval); } else { optional_tests.getsbtargetmapping.unsup++; optional_unsup++; } } else { optional_tests.getsbtargetmapping.pass++; optional_pass++; } free(sbtmap); } else { optional_tests.getsbtargetmapping.skip++; optional_skip++; } sb_device.OSDeviceName[0] = 0; retval = HBA_GetSBStatistics(hba_handle, &sb_device, &sb_stats); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getsbstatistics.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_Statistics :%d\n", retval); print_hbaerror(retval); } else { optional_tests.getsbstatistics.unsup++; optional_unsup++; } } else { optional_tests.getsbstatistics.pass++; optional_pass++; } retval = HBA_SBDskGetCapacity(deviceselfdesc, &sb_diskcap); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.sbdskgetcapacity.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_SBDskGetCapscity :%d\n", retval); print_hbaerror(retval); } else { optional_tests.sbdskgetcapacity.unsup++; optional_unsup++; } } else { optional_tests.sbdskgetcapacity.pass++; optional_pass++; } #else if (print_detail) { printf("SB functions skipped.\n"); } optional_tests.getsbtargetmapping.skip++; optional_skip++; optional_tests.getsbstatistics.skip++; optional_skip++; optional_tests.sbdskgetcapacity.skip++; optional_skip++; #endif /* Get Wrapper Library Attributes */ /*--------------------------------*/ retval = HBA_GetWrapperLibraryAttributes(&lib_attr); if (retval != HBA_LIBVERSION) { fprintf(stderr, "Failure of HBA_GetWrapperLibraryAttributes:%d\n", retval); print_hbaerror(retval); manditory_tests.getwrapperlibraryattributes.fail++; manditory_fail++; } else { manditory_tests.getwrapperlibraryattributes.pass++; manditory_pass++; if (print_detail) { printf("\n"); printf("LibPath: %s\n",lib_attr.LibPath); printf(" Final: %d, Vendor: %s, Version %s.\n", lib_attr.final, lib_attr.VName, lib_attr.VVersion); printf(" Build Date=%d/%d/%d %d:%02d:%02d\n", lib_attr.build_date.tm_mon, lib_attr.build_date.tm_mday, lib_attr.build_date.tm_year, lib_attr.build_date.tm_hour, lib_attr.build_date.tm_min, lib_attr.build_date.tm_sec); } } /* Get Vendor Libary Attributes */ /*------------------------------*/ for (i = 0; i < hba_cnt; i++) { retval = HBA_GetVendorLibraryAttributes(i, &lib_attr); if (retval != HBA_LIBVERSION) { fprintf(stderr, "Failure of HBA_GetVendorLibraryAttributes:%d\n", retval); print_hbaerror(retval); manditory_tests.getvendorlibraryattributes.fail++; manditory_fail++; } else { manditory_tests.getvendorlibraryattributes.pass++; manditory_pass++; if (print_detail) { printf("\n"); (void) HBA_GetAdapterName(i, namebuf); printf("Adapter %s\n", namebuf); printf("LibPath: %s\n",lib_attr.LibPath); printf(" Final: %d, Vendor: %s, Version %s.\n", lib_attr.final, lib_attr.VName, lib_attr.VVersion); printf(" Build Date=%d/%d/%d %2d:%02d:%02d\n", lib_attr.build_date.tm_mon, lib_attr.build_date.tm_mday, lib_attr.build_date.tm_year, lib_attr.build_date.tm_hour, lib_attr.build_date.tm_min, lib_attr.build_date.tm_sec); } } } /* RefreshAdapterConfiguration */ /*-----------------------------*/ HBA_RefreshAdapterConfiguration(); manditory_tests.refreshadapterconfiguration.pass++; manditory_pass++; #ifndef NOCALLBACK /* Callbacks */ /*-----------*/ retval = HBA_RegisterForAdapterAddEvents (AdapterAddEvent, 0, &AdapterAddCallback); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.registerforadapteraddevents.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_RegisterForAdapterAddEvents:%d\n", retval); print_hbaerror(retval); } else { optional_tests.registerforadapteraddevents.unsup++; optional_unsup++; } } else { optional_tests.registerforadapteraddevents.pass++; optional_pass++; } retval = HBA_RegisterForAdapterEvents (AdapterEvent, 0, hba_handle, &AdapterCallback); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.registerforadapterevents.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_RegisterForAdapterEvents:%d\n", retval); print_hbaerror(retval); } else { optional_tests.registerforadapterevents.unsup++; optional_unsup++; } } else { optional_tests.registerforadapteraddevents.pass++; optional_pass++; } retval = HBA_RegisterForAdapterPortEvents (AdapterPortEvent, 0, hba_handle, test_wwpn, &AdapterPortCallback); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.registerforadapterportevents.fail++; management_fail++; fprintf(stderr, "Failure of HBA_RegisterForAdapterPortEvents:%d\n", retval); print_hbaerror(retval); } else { management_tests.registerforadapterportevents.unsup++; management_unsup++; } } else { management_tests.registerforadapterportevents.pass++; management_pass++; } retval = HBA_RegisterForAdapterPortStatEvents (AdapterPortStatEvent, 0, hba_handle, test_wwpn, stats, 0, /* StatType */ &AdapterPortStatCallback); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.registerforadapterportstatevents.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_RegisterForAdapterPortStatEvents:%d\n", retval); print_hbaerror(retval); } else { optional_tests.registerforadapterportstatevents.unsup++; optional_unsup++; } } else { optional_tests.registerforadapterportstatevents.pass++; optional_pass++; } memset(&wwn2, 0, sizeof(HBA_WWN)); retval = HBA_RegisterForTargetEvents (TargetEvent, 0, hba_handle, test_wwpn, wwn2, &TargetCallback, 0 /* allTargets */ ); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.registerfortargetevents.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_RegisterForTargetEvents:%d\n", retval); print_hbaerror(retval); } else { optional_tests.registerfortargetevents.unsup++; optional_unsup++; } } else { optional_tests.registerfortargetevents.pass++; optional_pass++; } memset(&wwn2, 0, sizeof(HBA_WWN)); retval = HBA_RegisterForLinkEvents (LinkEvent, 0, /* * userData */ 0, /* * pRLIRBuffer */ 0, /* RLIRBufferSize */ hba_handle, &LinkCallback); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.registerforlinkevents.fail++; management_fail++; fprintf(stderr, "Failure of HBA_RegisterForLinkEvents:%d\n", retval); print_hbaerror(retval); } else { management_tests.registerforlinkevents.unsup++; management_unsup++; } } else { management_tests.registerforlinkevents.pass++; management_pass++; } retval = HBA_RemoveCallback(AdapterAddCallback); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.removecallback.fail++; management_fail++; fprintf(stderr, "Failure of HBA_RemoveCallback:%d\n", retval); print_hbaerror(retval); } else { management_tests.removecallback.unsup++; management_unsup++; } } else { management_tests.removecallback.pass++; management_pass++; } /* Get an Event Buffer */ /*---------------------*/ event_count = 4; retval = HBA_GetEventBuffer(hba_handle, event_info, &event_count); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.geteventbuffer.fail++; management_fail++; fprintf(stderr, "Failure of HBA_GetEventBuffer:%d\n", retval); print_hbaerror(retval); } else { management_tests.geteventbuffer.unsup++; management_unsup++; } } else { management_tests.geteventbuffer.pass++; management_pass++; } #else if (print_detail) printf("Callback registration skipped.\n"); optional_tests.registerforadapteraddevents.skip++; optional_skip++; optional_tests.registerforadapterevents.skip++; optional_skip++; management_tests.registerforadapterportevents.skip++; management_skip++; optional_tests.registerforadapterportstatevents.skip++; optional_skip++; optional_tests.registerfortargetevents.skip++; optional_skip++; management_tests.registerforlinkevents.skip++; management_skip++; management_tests.removecallback.skip++; management_skip++; management_tests.geteventbuffer.skip++; management_skip++; #endif /* GET FC4 Stats */ /*---------------*/ retval = HBA_GetFC4Statistics(hba_handle, test_wwpn, 0, &fc4stat); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getfc4statistics.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_GetFC4Statistics:%d\n", retval); print_hbaerror(retval); } else { optional_tests.getfc4statistics.unsup++; optional_unsup++; } } else { optional_tests.getfc4statistics.pass++; optional_pass++; } /* GET FCP Stats */ /*---------------*/ if (test_scsiid_set != 0) { retval = HBA_GetFCPStatistics(hba_handle, &test_scsiid, &fc4stat); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getfcpstatistics.fail++; optional_fail++; fprintf(stderr,"Failure of HBA_GetFCPStatistics:%d\n", retval); print_hbaerror(retval); } else { optional_tests.getfcpstatistics.unsup++; optional_unsup++; } } else { optional_tests.getfcpstatistics.pass++; optional_pass++; } } else { optional_tests.getfcpstatistics.skip++; optional_skip++; } /* Refresh Information */ /*--------------------*/ HBA_RefreshInformation(hba_handle); manditory_tests.refreshinformation.pass++; manditory_pass++; /* Reset Statistics */ /*------------------*/ HBA_ResetStatistics(hba_handle, test_wwpn_pi); manditory_tests.resetstatistics.pass++; manditory_pass++; #ifndef NOMAPPING /* Target Mapping */ /*----------------*/ MAPU.fcp_tmapi.cnt = MAPENTRIES; retval = HBA_GetFcpTargetMapping(hba_handle, &MAPU.fcp_tmap); if (retval != HBA_STATUS_OK) { if (retval == HBA_STATUS_ERROR) { /* no targets returned */ /* this is not an error */ } else if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getfcptargetmapping.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_GetFcpTargetMapping:%d\n", retval); print_hbaerror(retval); if (retval == HBA_STATUS_ERROR_MORE_DATA) { printf("There are %d targets available but we only provided room for %d.\n" ,MAPU.fcp_tmapi.cnt ,MAPENTRIES ); } } else { optional_tests.getfcptargetmapping.unsup++; optional_unsup++; } } else { optional_tests.getfcptargetmapping.pass++; optional_pass++; } MAPU_V2.fcp_tmapi.cnt = MAPENTRIES; retval = HBA_GetFcpTargetMappingV2 (hba_handle, test_dwwpn, &MAPU_V2.fcp_tmap); if (retval != HBA_STATUS_OK) { if (retval == HBA_STATUS_ERROR) { /* no targets returned */ /* this is not an error */ } else if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getfcptargetmappingv2.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_GetFcpTargetMappingV2:%d\n", retval); print_hbaerror(retval); if (retval == HBA_STATUS_ERROR_MORE_DATA) { printf("There are %d targets available but we only provided room for %d.\n" ,MAPU_V2.fcp_tmapi.cnt ,MAPENTRIES ); } } else { optional_tests.getfcptargetmappingv2.unsup++; optional_unsup++; } } else { optional_tests.getfcptargetmappingv2.pass++; optional_pass++; if (print_detail) { printf("\n"); printf("Target MappingsV2: %d\n", MAPU_V2.fcp_tmap.NumberOfEntries); for (ti = 0; ti < MAPU_V2.fcp_tmap.NumberOfEntries; ti++) { printf("%6d: scsiID: %s, Bus: %u, Target: %u, Lun: %u\n", ti, MAPU_V2.fcp_tmap.entry[ti].ScsiId.OSDeviceName, MAPU_V2.fcp_tmap.entry[ti].ScsiId.ScsiBusNumber, MAPU_V2.fcp_tmap.entry[ti].ScsiId.ScsiTargetNumber, MAPU_V2.fcp_tmap.entry[ti].ScsiId.ScsiOSLun); printf(" FcpId: ID:%06x, NWWN: ", MAPU_V2.fcp_tmap.entry[ti].FcpId.FcId); PrintWWN(MAPU_V2.fcp_tmap.entry[ti].FcpId.NodeWWN.wwn); printf(" PWWN: "); PrintWWN(MAPU_V2.fcp_tmap.entry[ti].FcpId.PortWWN.wwn); printf(" FcpLun:0x%llX\n", MAPU_V2.fcp_tmap.entry[ti].FcpId.FcpLun); printf(" LUID = %30s\n", MAPU_V2.fcp_tmap.entry[ti].LUID.buffer); printf("\n"); } } } #else if (print_detail) printf("Target mapping skipped.\n"); optional_tests.getfcptargetmapping.skip++; optional_skip++; optional_tests.getfcptargetmappingv2.skip++; optional_skip++; #endif /* Binding CaPability */ /*--------------------*/ retval = HBA_GetBindingCapability(hba_handle, test_wwpn, &bind_cap); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getbindingcapability.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_GetBindingCapability:%d\n", retval); print_hbaerror(retval); } else { optional_tests.getbindingcapability.unsup++; optional_unsup++; } } else { optional_tests.getbindingcapability.pass++; optional_pass++; } retval = HBA_GetBindingSupport(hba_handle, test_wwpn, &bind_cap); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getbindingsupport.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_GetBindingSupport:%d\n", retval); print_hbaerror(retval); } else { optional_tests.getbindingsupport.unsup++; optional_unsup++; } } else { optional_tests.getbindingsupport.pass++; optional_pass++; } retval = HBA_GetPersistentBindingV2 (hba_handle, test_wwpn, &BINDU_V2.fcp_tbind); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getpersistentbindingv2.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_GetPersistentBindingV2:%d\n", retval); print_hbaerror(retval); } else { optional_tests.getpersistentbindingv2.unsup++; optional_unsup++; } optional_tests.removepersistentbinding.skip++; optional_skip++; optional_tests.setpersistentbindingv2.skip++; optional_skip++; } else { optional_tests.getpersistentbindingv2.pass++; optional_pass++; retval = HBA_RemovePersistentBinding (hba_handle, test_wwpn, &BINDU_V2.fcp_tbind); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.removepersistentbinding.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_RemovePersistentBinding:%d\n", retval); print_hbaerror(retval); } else { optional_tests.removepersistentbinding.unsup++; optional_unsup++; } } else { optional_tests.removepersistentbinding.pass++; optional_pass++; } retval = HBA_SetPersistentBindingV2 (hba_handle, test_wwpn, &BINDU_V2.fcp_tbind); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.setpersistentbindingv2.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_SetPersistentBindingV2:%d\n", retval); print_hbaerror(retval); } else { optional_tests.setpersistentbindingv2.unsup++; optional_unsup++; } } else { optional_tests.setpersistentbindingv2.pass++; optional_pass++; } } retval = HBA_GetFcpPersistentBinding(hba_handle, &BINDU.fcp_tbind); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.getfcppersistentbinding.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_GetFcpPersistentBinding:%d\n", retval); print_hbaerror(retval); } else { optional_tests.getfcppersistentbinding.unsup++; optional_unsup++; } } else { optional_tests.getfcppersistentbinding.pass++; optional_pass++; } retval = HBA_RemoveAllPersistentBindings(hba_handle, test_wwpn); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.removeallpersistentbinding.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_RemoveAllPersistentBindings:%d\n", retval); print_hbaerror(retval); } else { optional_tests.removeallpersistentbinding.unsup++; optional_unsup++; } } else { optional_tests.removeallpersistentbinding.pass++; optional_pass++; } /* RNID Mgmt Info */ /*----------------*/ retval = HBA_GetRNIDMgmtInfo(hba_handle, &mgmt_info); if (retval != HBA_STATUS_OK) { fprintf(stderr, "Failure of HBA_GetRNIDMgmtInfo:%d\n", retval); print_hbaerror(retval); manditory_tests.getrnidmgmtinfo.fail++; manditory_fail++; optional_tests.setrnidmgmtinfo.skip++; optional_skip++; } else { manditory_tests.getrnidmgmtinfo.pass++; manditory_pass++; if (print_detail) { printf("RNID Management Info:\n"); printf(" WWN: "); PrintWWN(mgmt_info.wwn.wwn); printf("\n"); printf(" Unit type = %d\n", mgmt_info.unittype); printf(" PortId = %d\n", mgmt_info.PortId); printf(" Number Of Attached Nodes = %d\n", mgmt_info.NumberOfAttachedNodes); printf(" IPVersion = %d\n", mgmt_info.IPVersion); printf(" UDPPort = %d\n", mgmt_info.UDPPort); printf(" IPAddress: "); PrintHexString(mgmt_info.IPAddress, 16, 0, 0); printf("\n"); printf(" TopologyDiscoveryFlags = %d\n", mgmt_info.TopologyDiscoveryFlags); } retval = HBA_SetRNIDMgmtInfo(hba_handle, &mgmt_info); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { optional_tests.setrnidmgmtinfo.fail++; optional_fail++; fprintf(stderr, "Failure of HBA_SetRNIDMgmtInfo:%d\n", retval); print_hbaerror(retval); } else { optional_tests.setrnidmgmtinfo.unsup++; optional_unsup++; } } else { optional_tests.setrnidmgmtinfo.pass++; optional_pass++; } } /* Send RNID */ /*-----------*/ memset(&wwn2, 0, sizeof(HBA_WWN)); retval = HBA_SendRNIDV2 (hba_handle, test_wwpn, wwn2, 0, 0, large_buf, &large_buf_size); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendrnidv2.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendRNIDV2:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendrnidv2.unsup++; management_unsup++; } } else { management_tests.sendrnidv2.pass++; management_pass++; } retval = HBA_SendRNID (hba_handle, test_wwpn, 0, large_buf, &large_buf_size); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendrnid.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendRNID:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendrnid.unsup++; management_unsup++; } } else { management_tests.sendrnid.pass++; management_pass++; } /* Misc SENDS */ /*------------*/ memset(&wwn2, 0, sizeof(HBA_WWN)); retval = HBA_SendRPL (hba_handle, test_wwpn, wwn2, 0, test_wwpn_pi, large_buf, &large_buf_size); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendrpl.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendRPL:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendrpl.unsup++; management_unsup++; } } else { management_tests.sendrpl.pass++; management_pass++; } memset(&wwn2, 0, sizeof(HBA_WWN)); retval = HBA_SendRPS (hba_handle, test_wwpn, wwn2, 0, wwn2, 0, large_buf, &large_buf_size); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendrps.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendRPS:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendrps.unsup++; management_unsup++; } } else { management_tests.sendrps.pass++; management_pass++; } memset(&wwn2, 0, sizeof(HBA_WWN)); retval = HBA_SendSRL (hba_handle, test_wwpn, wwn2, 0, large_buf, &large_buf_size); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendsrl.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendSRL:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendsrl.unsup++; management_unsup++; } } else { management_tests.sendsrl.pass++; management_pass++; } memset(&wwn2, 0, sizeof(HBA_WWN)); retval = HBA_SendLIRR (hba_handle, test_wwpn, wwn2, 0, 0, large_buf, &large_buf_size); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendlirr.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendLIRR:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendlirr.unsup++; management_unsup++; } } else { management_tests.sendlirr.pass++; management_pass++; } memset(&wwn2, 0, sizeof(HBA_WWN)); retval = HBA_SendRLS (hba_handle, test_wwpn, wwn2, large_buf, &large_buf_size); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendrls.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendRLS:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendrls.unsup++; management_unsup++; } } else { management_tests.sendrls.pass++; management_pass++; } /* Send CTPassThru tests */ /*-----------------------*/ retval = HBA_SendCTPassThruV2 (hba_handle, test_wwpn, 0, 0, 0, 0); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendctpassthruv2.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendCTPassThruV2:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendctpassthruv2.unsup++; management_unsup++; } } else { management_tests.sendctpassthruv2.pass++; management_pass++; } retval = HBA_SendCTPassThru (hba_handle, 0, 0, 0, 0); if (retval != HBA_STATUS_OK) { if (retval != HBA_STATUS_ERROR_NOT_SUPPORTED) { management_tests.sendctpassthru.fail++; management_fail++; fprintf(stderr, "Failure of HBA_SendCTPassThru:%d\n", retval); print_hbaerror(retval); } else { management_tests.sendctpassthru.unsup++; management_unsup++; } } else { management_tests.sendctpassthru.pass++; management_pass++; } /* Leave adapter open, FreeLibrary should close it. */ /*--------------------------------------------------*/ DoneOpenbyWWN: } /* if (test_wwnn_set != 0) test open adapter by wwn */ /* Freeing the library should work */ /*---------------------------------*/ retval = HBA_FreeLibrary(); if (retval != HBA_STATUS_OK) { manditory_tests.freelibrary.fail++; manditory_fail++; fprintf(stderr,"failure of HBA_FreeLibrary, status=%d\n", retval); print_hbaerror(retval); } else { manditory_tests.freelibrary.pass++; manditory_pass++; } /***************************************************************************** * Test Summary *****************************************************************************/ fprintf (stderr, "\nSummary: Manditory pass = %d, fail = %d, skip = %d, unsupported = %d", manditory_pass, manditory_fail, manditory_skip, manditory_unsup); fprintf (stderr, "\n Management pass = %d, fail = %d, skip = %d, unsupported = %d", management_pass, management_fail, management_skip, management_unsup); fprintf (stderr, "\n Optional pass = %d, fail = %d, skip = %d, unsupported = %d\n", optional_pass, optional_fail, optional_skip, optional_unsup); if (optional_tests.scsireadcapacityv2.fail || optional_tests.sendreadcapacity.fail) { printf("\n"); printf("NOTE: ScsiReadCapacity failures may be due a controller a \"feature\".\n"); printf(" For example, the HSG80 will only accept the Read Capacity SCSI \n"); printf(" command on the active controller; examining the sense buffer\n"); printf(" will show a relevant error message, such as \"LUN not ready\".\n"); printf("\n"); } if (print_results) { manditory_results(&manditory_tests); management_results(&management_tests); optional_results(&optional_tests); } printf("HBA API test is complete.\n"); } /* main(int argc, const char * argv[]) */