usr/src/cmd/luxadm/fchba.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26
  27
  28 #include        <hbaapi.h>
  29 #include        <stdio.h>
  30 #include        <unistd.h>
  31 #include        <stdlib.h>
  32 #include        <sys/param.h>
  33 #include        <sys/types.h>
  34 #include        <sys/stat.h>
  35 #include        <string.h>
  36 #include        <strings.h>
  37 #include        <ctype.h>
  38 #include        <sys/scsi/generic/sense.h>
  39 #include        <sys/scsi/generic/mode.h>
  40 #include        <sys/scsi/generic/inquiry.h>
  41 #include        <errno.h>
  42 #include        <libdevice.h>
  43 #include        <config_admin.h>
  44 #include        <sys/byteorder.h>
  45 #include        <sys/fibre-channel/fcio.h>
  46 #include        "common.h"
  47 #include        "sun_fc_version.h"
  48
  49 #define DEFAULT_LUN_COUNT       1024
  50 #define LUN_SIZE                8
  51 #define LUN_HEADER_SIZE         8
  52 #define DEFAULT_LUN_LENGTH      DEFAULT_LUN_COUNT   *   \
  53                                 LUN_SIZE            +   \
  54                                 LUN_HEADER_SIZE
  55 struct lun_val {
  56         uchar_t val[8];
  57 };
  58 struct rep_luns_rsp {
  59         uint32_t    length;
  60         uint32_t    rsrvd;
  61         struct lun_val  lun[1];
  62 };
  63
  64 /* Extracted from the old scsi.h file */
  65 struct  capacity_data_struct {
  66         uint_t  last_block_addr;
  67         uint_t  block_size;
  68 };
  69
  70
  71 /* Structure to handle the inq. page 0x80 serial number */
  72 struct page80 {
  73         uchar_t inq_dtype;
  74         uchar_t inq_page_code;
  75         uchar_t reserved;
  76         uchar_t inq_page_len;
  77         uchar_t inq_serial[251];
  78 };
  79
  80 extern char             *dtype[];
  81 extern int              Options;
  82 extern const int        OPTION_P;
  83
  84 int skip_hba(int i);
  85 int find_supported_inq_page(HBA_HANDLE handle, HBA_WWN hwwn, HBA_WWN pwwn,
  86     uint64_t lun, int page_num);
  87 /*
  88  * The routines within this file operate against the T11
  89  * HBA API interface.  In some cases, proprietary Sun driver
  90  * interface are also called to add additional information
  91  * above what the standard library supports.
  92  */
  93
  94 uint64_t
  95 wwnConversion(uchar_t *wwn) {
  96         uint64_t tmp;
  97         (void) memcpy(&tmp, wwn, sizeof (uint64_t));
  98         return (ntohll(tmp));
  99 }
 100
 101 void printStatus(HBA_STATUS status) {
 102         switch (status) {
 103         case HBA_STATUS_OK:
 104             printf(MSGSTR(2410, "OK"));
 105             return;
 106         case HBA_STATUS_ERROR:
 107             printf(MSGSTR(2411, "ERROR"));
 108             return;
 109         case HBA_STATUS_ERROR_NOT_SUPPORTED:
 110             printf(MSGSTR(2412, "NOT SUPPORTED"));
 111             return;
 112         case HBA_STATUS_ERROR_INVALID_HANDLE:
 113             printf(MSGSTR(2413, "INVALID HANDLE"));
 114             return;
 115         case HBA_STATUS_ERROR_ARG:
 116             printf(MSGSTR(2414, "ERROR ARG"));
 117             return;
 118         case HBA_STATUS_ERROR_ILLEGAL_WWN:
 119             printf(MSGSTR(2415, "ILLEGAL WWN"));
 120             return;
 121         case HBA_STATUS_ERROR_ILLEGAL_INDEX:
 122             printf(MSGSTR(2416, "ILLEGAL INDEX"));
 123             return;
 124         case HBA_STATUS_ERROR_MORE_DATA:
 125             printf(MSGSTR(2417, "MORE DATA"));
 126             return;
 127         case HBA_STATUS_ERROR_STALE_DATA:
 128             printf(MSGSTR(2418, "STALE DATA"));
 129             return;
 130         case HBA_STATUS_SCSI_CHECK_CONDITION:
 131             printf(MSGSTR(2419, "SCSI CHECK CONDITION"));
 132             return;
 133         case HBA_STATUS_ERROR_BUSY:
 134             printf(MSGSTR(2420, "BUSY"));
 135             return;
 136         case HBA_STATUS_ERROR_TRY_AGAIN:
 137             printf(MSGSTR(2421, "TRY AGAIN"));
 138             return;
 139         case HBA_STATUS_ERROR_UNAVAILABLE:
 140             printf(MSGSTR(2422, "UNAVAILABLE"));
 141             return;
 142         default:
 143             printf(MSGSTR(2423, "UNKNOWN ERROR TYPE %d"), status);
 144             return;
 145             }
 146 }
 147
 148 uint32_t
 149 getNumberOfAdapters() {
 150         uint32_t count = HBA_GetNumberOfAdapters();
 151         if (count == 0) {
 152                 fprintf(stderr, MSGSTR(2405,
 153                         "\nERROR: No Fibre Channel Adapters found.\n"));
 154         }
 155         return (count);
 156 }
 157
 158 #define MAX_RETRIES     10
 159
 160 /*
 161  * Returns non-zero on failure (aka, HBA_STATUS_ERROR_*
 162  * Will handle retries if applicable.
 163  */
 164 int
 165 getAdapterAttrs(HBA_HANDLE handle, char *name, HBA_ADAPTERATTRIBUTES *attrs) {
 166         int count = 0;
 167         HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */
 168
 169         /* Loop as long as we have a retryable error */
 170         while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
 171                 status == HBA_STATUS_ERROR_BUSY) && count++ < MAX_RETRIES) {
 172                 status = HBA_GetAdapterAttributes(handle, attrs);
 173                 if (status == HBA_STATUS_OK) {
 174                         break;
 175                 }
 176                 (void) sleep(1);
 177         }
 178         if (status != HBA_STATUS_OK) {
 179                 /* We encountered a non-retryable error */
 180                 fprintf(stderr, MSGSTR(2501,
 181                 "\nERROR: Unable to retrieve adapter port details (%s)"),
 182                 name);
 183                 printStatus(status);
 184                 fprintf(stderr, "\n");
 185         }
 186         return (status);
 187 }
 188
 189 /*
 190  * Returns non-zero on failure (aka, HBA_STATUS_ERROR_*
 191  * Will handle retries if applicable.
 192  */
 193 int
 194 getAdapterPortAttrs(HBA_HANDLE handle, char *name, int portIndex,
 195             HBA_PORTATTRIBUTES *attrs) {
 196         int count = 0;
 197         HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */
 198
 199         /* Loop as long as we have a retryable error */
 200         while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
 201                 status == HBA_STATUS_ERROR_BUSY) && count++ < MAX_RETRIES) {
 202                 status = HBA_GetAdapterPortAttributes(handle, portIndex, attrs);
 203                 if (status == HBA_STATUS_OK) {
 204                         break;
 205                 }
 206
 207                 /* The odds of this occuring are very slim, but possible. */
 208                 if (status == HBA_STATUS_ERROR_STALE_DATA) {
 209                         /*
 210                          * If we hit a stale data scenario,
 211                          * we'll just tell the user to try again.
 212                          */
 213                         status = HBA_STATUS_ERROR_TRY_AGAIN;
 214                         break;
 215                 }
 216                 sleep(1);
 217         }
 218         if (status != HBA_STATUS_OK) {
 219                 /* We encountered a non-retryable error */
 220                 fprintf(stderr, MSGSTR(2501,
 221                 "\nERROR: Unable to retrieve adapter port details (%s)"),
 222                 name);
 223                 printStatus(status);
 224                 fprintf(stderr, "\n");
 225         }
 226         return (status);
 227 }
 228
 229 /*
 230  * Returns non-zero on failure (aka, HBA_STATUS_ERROR_*
 231  * Will handle retries if applicable.
 232  */
 233 int
 234 getDiscPortAttrs(HBA_HANDLE handle, char *name, int portIndex, int discIndex,
 235             HBA_PORTATTRIBUTES *attrs) {
 236         int count = 0;
 237         HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */
 238
 239         /* Loop as long as we have a retryable error */
 240         while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
 241                 status == HBA_STATUS_ERROR_BUSY) && count++ < MAX_RETRIES) {
 242                 status = HBA_GetDiscoveredPortAttributes(handle, portIndex,
 243                                 discIndex, attrs);
 244                 if (status == HBA_STATUS_OK) {
 245                         break;
 246                 }
 247
 248                 /* The odds of this occuring are very slim, but possible. */
 249                 if (status == HBA_STATUS_ERROR_STALE_DATA) {
 250                         /*
 251                          * If we hit a stale data scenario, we'll just tell the
 252                          * user to try again.
 253                          */
 254                         status = HBA_STATUS_ERROR_TRY_AGAIN;
 255                         break;
 256                 }
 257                 sleep(1);
 258         }
 259         if (status != HBA_STATUS_OK) {
 260                 /* We encountered a non-retryable error */
 261                 fprintf(stderr, MSGSTR(2504,
 262                 "\nERROR: Unable to retrieve target port details (%s)"),
 263                 name);
 264                 printStatus(status);
 265                 fprintf(stderr, "\n");
 266         }
 267         return (status);
 268 }
 269
 270
 271 /*ARGSUSED*/
 272 int
 273 fchba_display_port(int verbose)
 274 {
 275         int retval = 0;
 276         HBA_HANDLE handle;
 277         HBA_ADAPTERATTRIBUTES hbaAttrs;
 278         HBA_PORTATTRIBUTES portAttrs;
 279         HBA_STATUS status;
 280         int count, adapterIndex, portIndex;
 281         char name[256];
 282         char *physical = NULL;
 283         char path[MAXPATHLEN];
 284
 285         if ((retval = loadLibrary())) {
 286             return (retval);
 287         }
 288
 289         count = getNumberOfAdapters();
 290
 291         for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
 292             if (skip_hba(adapterIndex)) {
 293                 continue;
 294             }
 295             status = HBA_GetAdapterName(adapterIndex, (char *)&name);
 296             if (status != HBA_STATUS_OK) {
 297                 /* Just skip it, maybe it was DR'd */
 298                 continue;
 299             }
 300             handle = HBA_OpenAdapter(name);
 301             if (handle == 0) {
 302                 /* Just skip it, maybe it was DR'd */
 303                 continue;
 304             }
 305
 306             if (getAdapterAttrs(handle, name, &hbaAttrs)) {
 307                 /* This should never happen, we'll just skip the adapter */
 308                 HBA_CloseAdapter(handle);
 309                 continue;
 310             }
 311
 312             for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
 313                     portIndex++) {
 314                 if (getAdapterPortAttrs(handle, name, portIndex,
 315                         &portAttrs)) {
 316                     continue;
 317                 }
 318                 physical = get_slash_devices_from_osDevName(
 319                                 portAttrs.OSDeviceName,
 320                                 STANDARD_DEVNAME_HANDLING);
 321                 if (physical) {
 322                         char *tmp = strstr(physical, ":fc");
 323                         if (tmp) {
 324                                 *tmp = '\0';
 325                                 (void) snprintf(path, MAXPATHLEN, "%s:devctl",
 326                                         physical);
 327                         } else {
 328                                 (void) snprintf(path, MAXPATHLEN, "%s",
 329                                         physical);
 330                         }
 331                         free(physical);
 332                         physical = NULL;
 333                         (void) printf("%-65s  ", path);
 334                 } else {
 335                         (void) printf("%-65s  ", portAttrs.OSDeviceName);
 336                 }
 337                 if (portAttrs.NumberofDiscoveredPorts > 0) {
 338                     printf(MSGSTR(2233, "CONNECTED\n"));
 339                 } else {
 340                     printf(MSGSTR(2234, "NOT CONNECTED\n"));
 341                 }
 342             }
 343         }
 344         (void) HBA_FreeLibrary();
 345         return (retval);
 346 }
 347
 348 /*
 349  * Internal routines/structure to deal with a path list
 350  * so we can ensure uniqueness
 351  */
 352 struct path_entry {
 353         char path[MAXPATHLEN];
 354         HBA_UINT8 wwn[8];
 355         uchar_t dtype;
 356         struct path_entry *next;
 357 };
 358 void add_path(struct path_entry *head, struct path_entry *cur) {
 359         struct path_entry *tmp;
 360         for (tmp = head; tmp->next != NULL; tmp = tmp->next) { }
 361                 tmp->next = cur;
 362 }
 363 struct path_entry *is_duplicate_path(struct path_entry *head, char *path) {
 364         struct path_entry *tmp;
 365         for (tmp = head; tmp != NULL; tmp = tmp->next) {
 366                 if (strncmp(tmp->path, path, sizeof (tmp->path)) == 0) {
 367                         return (tmp);
 368                 }
 369         }
 370         return (NULL);
 371 }
 372 void free_path_list(struct path_entry *head) {
 373         struct path_entry *tmp;
 374         struct path_entry *tmp2;
 375         for (tmp = head; tmp != NULL; ) {
 376                 tmp2 = tmp->next;
 377                 free(tmp);
 378                 tmp = tmp2;
 379         }
 380 }
 381
 382
 383 int
 384 is_wwn(char *arg) {
 385         int i;
 386         if (strlen(arg) == 16) {
 387                 for (i = 0; i < 16; i++) {
 388                         if (!isxdigit(arg[i])) {
 389                                 return (0);
 390                         }
 391                 }
 392                 return (1);
 393         }
 394         return (0);
 395 }
 396
 397 int
 398 is_path(char *arg) {
 399         struct stat buf;
 400         if (stat(arg, &buf)) {
 401                 return (0);
 402         }
 403         return (1);
 404 }
 405
 406 /* We take a wild guess for our first get target mappings call */
 407 #define MAP_GUESS       50
 408
 409 HBA_STATUS
 410 fetch_mappings(HBA_HANDLE handle, HBA_WWN pwwn, HBA_FCPTARGETMAPPINGV2 **map) {
 411         int loop = 0;
 412         int count = 0;
 413         HBA_STATUS status = HBA_STATUS_ERROR_TRY_AGAIN; /* force first pass */
 414         *map = (HBA_FCPTARGETMAPPINGV2 *) calloc(1,
 415                 (sizeof (HBA_FCPSCSIENTRYV2)* (MAP_GUESS-1)) +
 416                 sizeof (HBA_FCPTARGETMAPPINGV2));
 417
 418         /* Loop as long as we have a retryable error */
 419         while ((status == HBA_STATUS_ERROR_TRY_AGAIN ||
 420                 status == HBA_STATUS_ERROR_BUSY ||
 421                 status == HBA_STATUS_ERROR_MORE_DATA) && loop++ < MAX_RETRIES) {
 422             status = HBA_GetFcpTargetMappingV2(handle, pwwn, *map);
 423             if (status == HBA_STATUS_OK) {
 424                 break;
 425             } else if (status == HBA_STATUS_ERROR_MORE_DATA) {
 426                 count = (*map)->NumberOfEntries;
 427                 free(*map);
 428                 *map = (HBA_FCPTARGETMAPPINGV2 *) calloc(1,
 429                     (sizeof (HBA_FCPSCSIENTRYV2)* (count-1)) +
 430                     sizeof (HBA_FCPTARGETMAPPINGV2));
 431                 (*map)->NumberOfEntries = count;
 432                 continue;
 433             }
 434             sleep(1);
 435         }
 436         if (status != HBA_STATUS_OK) {
 437             /* We encountered a non-retryable error */
 438             fprintf(stderr, MSGSTR(2502,
 439                     "\nERROR: Unable to retrieve SCSI device paths "
 440                     "(HBA Port WWN %016llx)"),
 441                     wwnConversion(pwwn.wwn));
 442             printStatus(status);
 443             fprintf(stderr, "\n");
 444         }
 445         return (status);
 446 }
 447
 448 /*
 449  * Returns the index of the first match, or -1 if no match
 450  */
 451 int
 452 match_mappings(char *compare, HBA_FCPTARGETMAPPINGV2 *map) {
 453         int             mapIndex;
 454         char    *physical = NULL;
 455         char    *tmp;
 456         int             wwnCompare = 0;
 457         uint64_t        wwn;
 458
 459         if (map == NULL || compare == NULL) {
 460             return (-1);
 461         }
 462
 463         if (is_wwn(compare)) {
 464             wwnCompare = 1;
 465             (void) sscanf(compare, "%016llx", &wwn);
 466         } else {
 467             /* Convert the paths to phsyical paths */
 468             physical = get_slash_devices_from_osDevName(compare,
 469                         STANDARD_DEVNAME_HANDLING);
 470         }
 471
 472         for (mapIndex = 0; mapIndex < map->NumberOfEntries; mapIndex ++) {
 473             if (wwnCompare) {
 474                 if (wwn == wwnConversion(
 475                         map->entry[mapIndex].FcpId.NodeWWN.wwn) ||
 476                         wwn == wwnConversion(
 477                         map->entry[mapIndex].FcpId.PortWWN.wwn)) {
 478                     return (mapIndex);
 479                 }
 480             } else {
 481                 if (physical != NULL) {
 482                     tmp = get_slash_devices_from_osDevName(
 483                         map->entry[mapIndex].ScsiId.OSDeviceName,
 484                         STANDARD_DEVNAME_HANDLING);
 485                     if ((tmp != NULL) &&
 486                         strncmp(physical, tmp, MAXPATHLEN) == 0) {
 487                         free(physical);
 488                         return (mapIndex);
 489                     }
 490                 }
 491             }
 492         }
 493         if (physical) {
 494             free(physical);
 495         }
 496         return (-1);
 497 }
 498
 499
 500 /*
 501  * returns non-zero on failure (aka HBA_STATUS_ERROR_*
 502  */
 503 int
 504 loadLibrary() {
 505         int status = HBA_LoadLibrary();
 506         if (status != HBA_STATUS_OK) {
 507                 fprintf(stderr, MSGSTR(2505,
 508                         "ERROR: Unable to load HBA API library: "));
 509                 printStatus(status);
 510                 fprintf(stderr, "\n");
 511         }
 512         return (status);
 513 }
 514
 515 int
 516 fchba_non_encl_probe() {
 517         HBA_HANDLE handle;
 518         HBA_ADAPTERATTRIBUTES hbaAttrs;
 519         HBA_PORTATTRIBUTES portAttrs;
 520         HBA_FCPTARGETMAPPINGV2    *map;
 521         HBA_STATUS status;
 522         int count, adapterIndex, portIndex, mapIndex;
 523         char name[256];
 524         struct path_entry *head = NULL;
 525         uint64_t        lun = 0;
 526         L_inquiry       inq;
 527         struct scsi_extended_sense sense;
 528         HBA_UINT8       scsiStatus;
 529         uint32_t        inquirySize = sizeof (inq), senseSize = sizeof (sense);
 530
 531         if (loadLibrary()) {
 532             return (-1);
 533         }
 534
 535         count = getNumberOfAdapters();
 536
 537         /* Loop over all HBAs */
 538         for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
 539             if (skip_hba(adapterIndex)) {
 540                 continue;
 541             }
 542             status = HBA_GetAdapterName(adapterIndex, (char *)&name);
 543             if (status != HBA_STATUS_OK) {
 544                 /* May have been DR'd */
 545                 continue;
 546             }
 547             handle = HBA_OpenAdapter(name);
 548             if (handle == 0) {
 549                 /* May have been DR'd */
 550                 continue;
 551             }
 552
 553             if (getAdapterAttrs(handle, name, &hbaAttrs)) {
 554                 /* Should not happen, just skip it */
 555                 HBA_CloseAdapter(handle);
 556                 continue;
 557             }
 558
 559
 560             /* Loop over all HBA Ports */
 561             for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
 562                     portIndex++) {
 563                 if (getAdapterPortAttrs(handle, name, portIndex,
 564                         &portAttrs)) {
 565                     continue;
 566                 }
 567
 568                 if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
 569                     continue;
 570                 }
 571
 572                 /* Loop over all target Mapping entries */
 573                 for (mapIndex = 0; mapIndex < map->NumberOfEntries;
 574                     mapIndex ++) {
 575                         struct path_entry *tmpPath = NULL;
 576                         int doInquiry = 0;
 577                         if (!head) {
 578                         head = (struct path_entry *)calloc(1,
 579                                 sizeof (struct path_entry));
 580                         tmpPath = head;
 581                         strncpy(head->path,
 582                             map->entry[mapIndex].ScsiId.OSDeviceName,
 583                             sizeof (map->entry[mapIndex].ScsiId.OSDeviceName));
 584                         (void) memcpy(tmpPath->wwn,
 585                             map->entry[mapIndex].FcpId.NodeWWN.wwn,
 586                             sizeof (HBA_UINT8) * 8);
 587                         doInquiry = 1;
 588                         } else if (tmpPath = is_duplicate_path(head,
 589                                 map->entry[mapIndex].ScsiId.OSDeviceName)) {
 590                                 if (tmpPath->dtype != 0x1f) {
 591                                         doInquiry = 0;
 592                                 } else {
 593                                         doInquiry = 1;
 594                                 }
 595                         } else {
 596                         tmpPath = (struct path_entry *)
 597                                 calloc(1, sizeof (struct path_entry));
 598                         strncpy(tmpPath->path,
 599                             map->entry[mapIndex].ScsiId.OSDeviceName,
 600                             sizeof (map->entry[mapIndex].ScsiId.OSDeviceName));
 601                         (void) memcpy(tmpPath->wwn,
 602                             map->entry[mapIndex].FcpId.NodeWWN.wwn,
 603                             sizeof (HBA_UINT8) * 8);
 604                         add_path(head, tmpPath);
 605                         doInquiry = 1;
 606                         }
 607
 608                         if (doInquiry) {
 609                                 lun = map->entry[mapIndex].FcpId.FcpLun;
 610                                 memset(&inq, 0, sizeof (inq));
 611                                 memset(&sense, 0, sizeof (sense));
 612                                 status = HBA_ScsiInquiryV2(handle,
 613                                     portAttrs.PortWWN,
 614                                     map->entry[mapIndex].FcpId.PortWWN,
 615                                     lun, 0, 0,
 616                                     &inq, &inquirySize,
 617                                     &scsiStatus,
 618                                     &sense, &senseSize);
 619                                 if (status != HBA_STATUS_OK) {
 620                                         inq.inq_dtype = 0x1f;
 621                                 }
 622                                 tmpPath->dtype = inq.inq_dtype;
 623                         }
 624                 }
 625         }
 626         }
 627         if (head) {
 628                 struct path_entry *tmp;
 629                 printf(MSGSTR(2098, "\nFound Fibre Channel device(s):\n"));
 630                 for (tmp = head; tmp != NULL; tmp = tmp->next) {
 631                         printf("  ");
 632                         printf(MSGSTR(90, "Node WWN:"));
 633                         printf("%016llx  ", wwnConversion(tmp->wwn));
 634                         fprintf(stdout, MSGSTR(35, "Device Type:"));
 635                         (void) fflush(stdout);
 636
 637                         if ((tmp->dtype & DTYPE_MASK) < 0x10) {
 638                                 fprintf(stdout, "%s",
 639                                     dtype[tmp->dtype & DTYPE_MASK]);
 640                         } else if ((tmp->dtype & DTYPE_MASK) < 0x1f) {
 641                                 fprintf(stdout, MSGSTR(2406,
 642                                     "Reserved"));
 643                         } else {
 644                                 fprintf(stdout, MSGSTR(2407,
 645                                     "Unknown"));
 646                         }
 647
 648                         printf("\n    ");
 649                         printf(MSGSTR(31, "Logical Path:%s"), tmp->path);
 650                         printf("\n");
 651
 652                 /* We probably shouldn't be using a g_fc interface here */
 653                         if (Options & OPTION_P) {
 654                                 char *phys_path =
 655                                 get_slash_devices_from_osDevName(
 656                                     tmp->path,
 657                                     STANDARD_DEVNAME_HANDLING);
 658                                 if (phys_path != NULL) {
 659                                 fprintf(stdout, "    ");
 660                                 fprintf(stdout, MSGSTR(5, "Physical Path:"));
 661                                 fprintf(stdout, "\n     %s\n", phys_path);
 662                                 free(phys_path);
 663                                 }
 664                         }
 665                 }
 666                 free_path_list(head);
 667         }
 668         HBA_FreeLibrary();
 669         return (0);
 670 }
 671
 672
 673 int
 674 fchba_inquiry(char **argv)
 675 {
 676         int             path_index = 0, found = 0;
 677         uint64_t        wwn;
 678         uint64_t        lun = 0;
 679         HBA_HANDLE handle;
 680         HBA_ADAPTERATTRIBUTES hbaAttrs;
 681         HBA_PORTATTRIBUTES portAttrs;
 682         HBA_FCPTARGETMAPPINGV2    *map;
 683         HBA_STATUS status;
 684         int count, adapterIndex, portIndex, mapIndex;
 685         char name[256];
 686         L_inquiry       inq;
 687         struct page80   serial;
 688         uint32_t        serialSize = sizeof (serial);
 689         struct scsi_extended_sense sense;
 690         HBA_UINT8       scsiStatus;
 691         uint32_t        inquirySize = sizeof (inq), senseSize = sizeof (sense);
 692         boolean_t       goodPath = B_FALSE;
 693         int             matched = 0, wwnCompare = 0;
 694         char            *tmp, *physical = NULL;
 695         int             ret = 0;
 696
 697         if (loadLibrary()) {
 698             return (-1);
 699         }
 700         for (path_index = 0; argv[path_index] != NULL; path_index++) {
 701             goodPath = B_FALSE;
 702             found = 0;
 703
 704             if (is_wwn(argv[path_index])) {
 705                 (void) sscanf(argv[path_index], "%016llx", &wwn);
 706                 wwnCompare = 1;
 707             } else if (!is_path(argv[path_index])) {
 708                 fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
 709                         argv[path_index]);
 710                 fprintf(stderr, "\n");
 711                 ret = -1;
 712                 continue;
 713             }
 714             if (!wwnCompare) {
 715                 /* Convert the paths to phsyical paths */
 716                 physical = get_slash_devices_from_osDevName(argv[path_index],
 717                         STANDARD_DEVNAME_HANDLING);
 718                 if (!physical) {
 719                     fprintf(stderr, MSGSTR(112,
 720                         "Error: Invalid pathname (%s)"),
 721                         argv[path_index]);
 722                     fprintf(stderr, "\n");
 723                     ret = -1;
 724                     continue;
 725                 }
 726             }
 727
 728             count = getNumberOfAdapters();
 729
 730             /* Loop over all HBAs */
 731             for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
 732                 if (skip_hba(adapterIndex)) {
 733                     continue;
 734                 }
 735                 status = HBA_GetAdapterName(adapterIndex, (char *)&name);
 736                 if (status != HBA_STATUS_OK) {
 737                     /* May have been DR'd */
 738                     continue;
 739                 }
 740                 handle = HBA_OpenAdapter(name);
 741                 if (handle == 0) {
 742                     /* May have been DR'd */
 743                     continue;
 744                 }
 745
 746                 if (getAdapterAttrs(handle, name, &hbaAttrs)) {
 747                     /* Should never happen */
 748                     HBA_CloseAdapter(handle);
 749                     continue;
 750                 }
 751
 752
 753                 /* Loop over all HBA Ports */
 754                 for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
 755                         portIndex++) {
 756                     if (getAdapterPortAttrs(handle, name, portIndex,
 757                             &portAttrs)) {
 758                         continue;
 759                     }
 760
 761                     if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
 762                         continue;
 763                     }
 764
 765                     for (mapIndex = 0; mapIndex < map->NumberOfEntries;
 766                             mapIndex ++) {
 767                         matched = 0;
 768                         if (wwnCompare) {
 769                             if (wwn == wwnConversion(
 770                                     map->entry[mapIndex].FcpId.NodeWWN.wwn) ||
 771                                     wwn == wwnConversion(
 772                                     map->entry[mapIndex].FcpId.PortWWN.wwn)) {
 773                                 lun = map->entry[mapIndex].FcpId.FcpLun;
 774                                 matched = 1;
 775                             }
 776                         } else {
 777                             tmp = get_slash_devices_from_osDevName(
 778                                     map->entry[mapIndex].ScsiId.OSDeviceName,
 779                                     STANDARD_DEVNAME_HANDLING);
 780                             if ((tmp != NULL) && (strncmp(physical, tmp,
 781                                     MAXPATHLEN) == 0)) {
 782                                 lun = map->entry[mapIndex].FcpId.FcpLun;
 783                                 matched = 1;
 784                                 free(tmp);
 785                             }
 786                         }
 787
 788                         if (matched) {
 789                             memset(&inq, 0, sizeof (inq));
 790                             memset(&sense, 0, sizeof (sense));
 791                             status = HBA_ScsiInquiryV2(handle,
 792                                 portAttrs.PortWWN,
 793                                 map->entry[mapIndex].FcpId.PortWWN,
 794                                 lun, 0, 0,
 795                                 &inq, &inquirySize,
 796                                 &scsiStatus,
 797                                 &sense, &senseSize);
 798                             if (status == HBA_STATUS_OK) {
 799                                 goodPath = B_TRUE;
 800                                 /*
 801                                  * Call the inquiry cmd on page 0x80 only if
 802                                  * the vendor supports page 0x80
 803                                  */
 804                                 memset(&serial, 0, sizeof (serial));
 805                                 if ((find_supported_inq_page(handle,
 806                                             portAttrs.PortWWN,
 807                                             map->entry[mapIndex].FcpId.PortWWN,
 808                                             lun, 0x80))) {
 809                                         status = HBA_ScsiInquiryV2(handle,
 810                                             portAttrs.PortWWN,
 811                                             map->entry[mapIndex].FcpId.PortWWN,
 812                                             lun, 1, 0x80,
 813                                             &serial, &serialSize,
 814                                             &scsiStatus,
 815                                             &sense, &senseSize);
 816                                         if (status != HBA_STATUS_OK) {
 817                                                 strncpy(
 818                                                     (char *)serial.inq_serial,
 819                                                     "Unavailable",
 820                                                     sizeof (serial.inq_serial));
 821                                         }
 822                                 } else {
 823                                         strncpy((char *)serial.inq_serial,
 824                                             "Unsupported",
 825                                             sizeof (serial.inq_serial));
 826                                 }
 827                                 /*
 828                                  * we are adding serial number information
 829                                  * from 0x80.  If length is less than 39,
 830                                  * then we want to increase length to 52 to
 831                                  * reflect the fact that we have serial number
 832                                  * information
 833                                  */
 834                                 if (inq.inq_len < 39) {
 835                                         inq.inq_len = 52;
 836                                 }
 837                                 print_inq_data(argv[path_index],
 838                                     map->entry[mapIndex].ScsiId.OSDeviceName,
 839                                     inq, serial.inq_serial,
 840                                     sizeof (serial.inq_serial));
 841                                 if (! wwnCompare) {
 842                                         found = 1;
 843                                         break;
 844                                 }
 845                             } else {
 846                                 fprintf(stderr, MSGSTR(2430,
 847                                 "Error: I/O failure communicating with %s  "),
 848                                 map->entry[mapIndex].ScsiId.OSDeviceName);
 849                                 printStatus(status);
 850                                 fprintf(stderr, "\n");
 851                             }
 852                         }
 853                     }
 854                     if (found == 1) {
 855                             break;
 856                     }
 857                 }
 858                 if (found == 1) {
 859                         break;
 860                 }
 861             }
 862
 863             if (physical) {
 864                 free(physical);
 865             }
 866
 867             if (!goodPath) {
 868                 fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
 869                         argv[path_index]);
 870                 fprintf(stderr, "\n");
 871                 ret = -1;
 872             }
 873         }
 874         return (ret);
 875 }
 876
 877
 878
 879 int
 880 fchba_dump_map(char **argv)
 881 {
 882         int             path_index = 0;
 883         uint64_t        wwn;
 884         uint64_t        lun = 0;
 885         HBA_HANDLE handle;
 886         HBA_ADAPTERATTRIBUTES hbaAttrs;
 887         HBA_PORTATTRIBUTES portAttrs;
 888         HBA_PORTATTRIBUTES discPortAttrs;
 889         HBA_FCPTARGETMAPPINGV2    *map;
 890         HBA_STATUS status;
 891         int count, adapterIndex, portIndex, mapIndex, discIndex;
 892         char name[256], *physical, *comp_phys;
 893         L_inquiry       inq;
 894         struct scsi_extended_sense sense;
 895         HBA_UINT8       scsiStatus;
 896         int             matched;
 897         int             done;
 898         uint32_t        inquirySize = sizeof (inq), senseSize = sizeof (sense);
 899         boolean_t       goodPath = B_FALSE;
 900         int             ret = 0;
 901         uint32_t        responseSize = DEFAULT_LUN_LENGTH;
 902         uchar_t         raw_luns[DEFAULT_LUN_LENGTH];
 903         struct rep_luns_rsp     *lun_resp;
 904
 905
 906         if (loadLibrary()) {
 907             return (-1);
 908         }
 909         for (path_index = 0; argv[path_index] != NULL; path_index++) {
 910             goodPath = B_FALSE;
 911
 912             if (is_wwn(argv[path_index])) {
 913                 (void) sscanf(argv[path_index], "%016llx", &wwn);
 914             } else if (!is_path(argv[path_index])) {
 915                 fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
 916                         argv[path_index]);
 917                 fprintf(stderr, "\n");
 918                 ret = -1;
 919                 continue;
 920             }
 921
 922             count = getNumberOfAdapters();
 923
 924             done = 0;
 925             /* Loop over all HBAs */
 926             for (adapterIndex = 0; adapterIndex < count && !done;
 927                     adapterIndex ++) {
 928                 if (skip_hba(adapterIndex)) {
 929                     continue;
 930                 }
 931                 status = HBA_GetAdapterName(adapterIndex, (char *)&name);
 932                 if (status != HBA_STATUS_OK) {
 933                     /* May have been DR'd */
 934                     continue;
 935                 }
 936                 handle = HBA_OpenAdapter(name);
 937                 if (handle == 0) {
 938                     /* May have been DR'd */
 939                     continue;
 940                 }
 941
 942                 if (getAdapterAttrs(handle, name, &hbaAttrs)) {
 943                     /* Should never happen */
 944                     HBA_CloseAdapter(handle);
 945                     continue;
 946                 }
 947
 948
 949                 /* Loop over all HBA Ports */
 950                 for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts && !done;
 951                         portIndex++) {
 952                     if (getAdapterPortAttrs(handle, name, portIndex,
 953                             &portAttrs)) {
 954                         continue;
 955                     }
 956
 957
 958                     matched = 0;
 959                     if (is_wwn(argv[path_index])) {
 960                         if (wwn == wwnConversion(
 961                                 portAttrs.NodeWWN.wwn) ||
 962                                 wwn == wwnConversion(
 963                                 portAttrs.PortWWN.wwn)) {
 964                             matched = 1;
 965                         }
 966                     } else {
 967                         if (is_path(argv[path_index]) &&
 968                             ((physical = get_slash_devices_from_osDevName(
 969                                 argv[path_index],
 970                                 STANDARD_DEVNAME_HANDLING)) != NULL) &&
 971                             ((comp_phys = get_slash_devices_from_osDevName(
 972                                 portAttrs.OSDeviceName,
 973                                 STANDARD_DEVNAME_HANDLING)) != NULL)) {
 974                             char *tmp = strstr(physical, ":devctl");
 975                             if (tmp) {
 976                                 *tmp = '\0';
 977                             } else {
 978                                 tmp = strstr(physical, ":fc");
 979                                 if (tmp) {
 980                                         *tmp = '\0';
 981                                 }
 982                             }
 983                             if (strstr(comp_phys, physical)) {
 984                                 matched = 1;
 985                             }
 986                         }
 987                         if (physical) {
 988                             free(physical);
 989                             physical = NULL;
 990                         }
 991                         if (comp_phys) {
 992                             free(comp_phys);
 993                             comp_phys = NULL;
 994                         }
 995                     }
 996
 997                     if (!fetch_mappings(handle, portAttrs.PortWWN, &map)) {
 998                         mapIndex = match_mappings(argv[path_index], map);
 999                         if (mapIndex >= 0) {
1000                             matched = 1;
1001                         }
1002                     } else {
1003                         continue;
1004                     }
1005
1006                     if (matched) {
1007                         goodPath = B_TRUE;
1008                         printf(MSGSTR(2095,
1009                                 "Pos  Port_ID Hard_Addr Port WWN"
1010                                 "         Node WWN         Type\n"));
1011                         for (discIndex = 0;
1012                                 discIndex < portAttrs.NumberofDiscoveredPorts;
1013                                 discIndex++) {
1014                             if (getDiscPortAttrs(handle, name, portIndex,
1015                                     discIndex, &discPortAttrs)) {
1016                                 /* Move on to the next target */
1017                                 continue;
1018                             }
1019
1020                             printf("%-4d %-6x  %-6x   %016llx %016llx",
1021                                     discIndex,
1022                                     discPortAttrs.PortFcId, 0,
1023                                     wwnConversion(discPortAttrs.PortWWN.wwn),
1024                                     wwnConversion(discPortAttrs.NodeWWN.wwn));
1025
1026                                 /*
1027                                  * devices are not all required to respond to
1028                                  * Scsi Inquiry calls sent to LUN 0.  We must
1029                                  * fisrt issue a ReportLUN and then send the
1030                                  * SCSI Inquiry call to the first LUN Returned
1031                                  * from the ReportLUN call
1032                                  */
1033                             memset(&sense, 0, sizeof (sense));
1034                             status = HBA_ScsiReportLUNsV2(handle,
1035                                 portAttrs.PortWWN,
1036                                 discPortAttrs.PortWWN,
1037                                 (void *)raw_luns, &responseSize, &scsiStatus,
1038                                 (void *)&sense, &senseSize);
1039                             if (status == HBA_STATUS_OK) {
1040                                     lun_resp =
1041                                         (struct rep_luns_rsp *)
1042                                         (unsigned long)raw_luns;
1043                                     lun = ntohll(
1044                                         wwnConversion(lun_resp->lun[0].val));
1045                             } else {
1046                                 /*
1047                                  * in case we are unable to retrieve report
1048                                  * LUN data, we will blindly try sending the
1049                                  * INQUIRY to lun 0.
1050                                  */
1051                                 lun = 0;
1052                             }
1053                             memset(&sense, 0, sizeof (sense));
1054                             status = HBA_ScsiInquiryV2(handle,
1055                                     portAttrs.PortWWN,
1056                                     discPortAttrs.PortWWN,
1057                                     lun, 0, 0,
1058                                     &inq, &inquirySize,
1059                                     &scsiStatus,
1060                                     &sense, &senseSize);
1061                             if (status != HBA_STATUS_OK) {
1062                                 inq.inq_dtype = 0x1f;
1063                             }
1064                             print_fabric_dtype_prop(portAttrs.PortWWN.wwn,
1065                                 map->entry[mapIndex].FcpId.PortWWN.wwn,
1066                                 inq.inq_dtype);
1067                         }
1068                         /* Now dump this HBA's stats */
1069                         printf("%-4d %-6x  %-6x   %016llx %016llx",
1070                             discIndex,
1071                             portAttrs.PortFcId, 0,
1072                             wwnConversion(portAttrs.PortWWN.wwn),
1073                             wwnConversion(portAttrs.NodeWWN.wwn));
1074                         print_fabric_dtype_prop(portAttrs.PortWWN.wwn,
1075                             portAttrs.PortWWN.wwn, 0x1f);
1076                         done = 1;
1077                     }
1078                 }
1079             }
1080             if (!goodPath) {
1081                 fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
1082                         argv[path_index]);
1083                 fprintf(stderr, "\n");
1084                 ret = -1;
1085             }
1086         }
1087         return (ret);
1088 }
1089
1090 int
1091 fchba_display_link_status(char **argv)
1092 {
1093         int             path_index = 0;
1094         uint64_t        wwn;
1095         HBA_HANDLE handle;
1096         HBA_ADAPTERATTRIBUTES hbaAttrs;
1097         HBA_PORTATTRIBUTES portAttrs;
1098         HBA_PORTATTRIBUTES discPortAttrs;
1099         HBA_FCPTARGETMAPPINGV2    *map;
1100         HBA_STATUS status;
1101         int count, adapterIndex, portIndex, discIndex;
1102         char name[256], *physical, *comp_phys;
1103         int             matched;
1104         struct fc_rls_acc_params        rls;
1105         uint32_t        rls_size = sizeof (rls);
1106         boolean_t       goodPath = B_FALSE;
1107         int             ret = 0;
1108
1109         if (loadLibrary()) {
1110             return (-1);
1111         }
1112         for (path_index = 0; argv[path_index] != NULL; path_index++) {
1113             goodPath = B_FALSE;
1114
1115             if (is_wwn(argv[path_index])) {
1116                 (void) sscanf(argv[path_index], "%016llx", &wwn);
1117             } else if (!is_path(argv[path_index])) {
1118                 fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
1119                         argv[path_index]);
1120                 fprintf(stderr, "\n");
1121                 ret = -1;
1122                 continue;
1123             }
1124
1125             count = getNumberOfAdapters();
1126
1127             /* Loop over all HBAs */
1128             for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
1129                 if (skip_hba(adapterIndex)) {
1130                     continue;
1131                 }
1132                 status = HBA_GetAdapterName(adapterIndex, (char *)&name);
1133                 if (status != HBA_STATUS_OK) {
1134                     /* May have been DR'd */
1135                     continue;
1136                 }
1137                 handle = HBA_OpenAdapter(name);
1138                 if (handle == 0) {
1139                     /* May have been DR'd */
1140                     continue;
1141                 }
1142
1143                 if (getAdapterAttrs(handle, name, &hbaAttrs)) {
1144                     /* Should never happen */
1145                     HBA_CloseAdapter(handle);
1146                     continue;
1147                 }
1148
1149
1150                 /* Loop over all HBA Ports */
1151                 for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
1152                         portIndex++) {
1153                     if (getAdapterPortAttrs(handle, name, portIndex,
1154                             &portAttrs)) {
1155                         continue;
1156                     }
1157
1158                     matched = 0;
1159                     if (is_wwn(argv[path_index])) {
1160                         if (wwn == wwnConversion(
1161                                 portAttrs.NodeWWN.wwn) ||
1162                                 wwn == wwnConversion(
1163                                 portAttrs.PortWWN.wwn)) {
1164                             matched = 1;
1165                         }
1166                     } else {
1167                         if (is_path(argv[path_index]) &&
1168                             ((physical = get_slash_devices_from_osDevName(
1169                                 argv[path_index],
1170                                 STANDARD_DEVNAME_HANDLING)) != NULL) &&
1171                             ((comp_phys = get_slash_devices_from_osDevName(
1172                                 portAttrs.OSDeviceName,
1173                                 STANDARD_DEVNAME_HANDLING)) != NULL)) {
1174                             char *tmp = strstr(physical, ":devctl");
1175                             if (tmp) {
1176                                 *tmp = '\0';
1177                             } else {
1178                                 tmp = strstr(physical, ":fc");
1179                                 if (tmp) {
1180                                         *tmp = '\0';
1181                                 }
1182                             }
1183                             if (strstr(comp_phys, physical)) {
1184                                 matched = 1;
1185                             }
1186                         }
1187                         if (physical) {
1188                             free(physical);
1189                             physical = NULL;
1190                         }
1191                         if (comp_phys) {
1192                             free(comp_phys);
1193                             comp_phys = NULL;
1194                         }
1195                     }
1196
1197                     if (!matched) {
1198                         if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
1199                             continue;
1200                         }
1201                     }
1202
1203                     if (matched || match_mappings(argv[path_index], map) >= 0) {
1204                         goodPath = B_TRUE;
1205                         fprintf(stdout,
1206                                 MSGSTR(2007, "\nLink Error Status "
1207                                 "information for loop:%s\n"), argv[path_index]);
1208                         fprintf(stdout, MSGSTR(2008, "al_pa   lnk fail "
1209                                 "   sync loss   signal loss   sequence err"
1210                                 "   invalid word   CRC\n"));
1211
1212                         for (discIndex = 0;
1213                                 discIndex < portAttrs.NumberofDiscoveredPorts;
1214                                 discIndex++) {
1215
1216
1217                             if (getDiscPortAttrs(handle, name, portIndex,
1218                                     discIndex, &discPortAttrs)) {
1219                                 continue;
1220                             }
1221
1222                             status = HBA_SendRLS(handle, portAttrs.PortWWN,
1223                                         discPortAttrs.PortWWN,
1224                                         &rls, &rls_size);
1225                             if (status != HBA_STATUS_OK) {
1226                                 memset(&rls, 0xff, sizeof (rls));
1227                             }
1228
1229                             if ((rls.rls_link_fail == 0xffffffff) &&
1230                                 (rls.rls_sync_loss == 0xffffffff) &&
1231                                 (rls.rls_sig_loss == 0xffffffff) &&
1232                                 (rls.rls_prim_seq_err == 0xffffffff) &&
1233                                 (rls.rls_invalid_word == 0xffffffff) &&
1234                                 (rls.rls_invalid_crc == 0xffffffff)) {
1235                                     fprintf(stdout,
1236                                         "%x\t%-12d%-12d%-14d%-15d%-15d%-12d\n",
1237                                             discPortAttrs.PortFcId,
1238                                             rls.rls_link_fail,
1239                                             rls.rls_sync_loss,
1240                                             rls.rls_sig_loss,
1241                                             rls.rls_prim_seq_err,
1242                                             rls.rls_invalid_word,
1243                                             rls.rls_invalid_crc);
1244                             } else {
1245                                     fprintf(stdout,
1246                                         "%x\t%-12u%-12u%-14u%-15u%-15u%-12u\n",
1247                                             discPortAttrs.PortFcId,
1248                                             rls.rls_link_fail,
1249                                             rls.rls_sync_loss,
1250                                             rls.rls_sig_loss,
1251                                             rls.rls_prim_seq_err,
1252                                             rls.rls_invalid_word,
1253                                             rls.rls_invalid_crc);
1254                             }
1255
1256
1257                         }
1258                         /* Now dump this HBA's stats */
1259                         status = HBA_SendRLS(handle, portAttrs.PortWWN,
1260                                 portAttrs.PortWWN,
1261                                 &rls, &rls_size);
1262                         if (status != HBA_STATUS_OK) {
1263                             memset(&rls, 0xff, sizeof (rls));
1264                         }
1265
1266                         if ((rls.rls_link_fail == 0xffffffff) &&
1267                                 (rls.rls_sync_loss == 0xffffffff) &&
1268                                 (rls.rls_sig_loss == 0xffffffff) &&
1269                                 (rls.rls_prim_seq_err == 0xffffffff) &&
1270                                 (rls.rls_invalid_word == 0xffffffff) &&
1271                                 (rls.rls_invalid_crc == 0xffffffff)) {
1272                             fprintf(stdout,
1273                                     "%x\t%-12d%-12d%-14d%-15d%-15d%-12d\n",
1274                                     portAttrs.PortFcId,
1275                                     rls.rls_link_fail,
1276                                     rls.rls_sync_loss,
1277                                     rls.rls_sig_loss,
1278                                     rls.rls_prim_seq_err,
1279                                     rls.rls_invalid_word,
1280                                     rls.rls_invalid_crc);
1281                         } else {
1282                             fprintf(stdout,
1283                                     "%x\t%-12u%-12u%-14u%-15u%-15u%-12u\n",
1284                                     portAttrs.PortFcId,
1285                                     rls.rls_link_fail,
1286                                     rls.rls_sync_loss,
1287                                     rls.rls_sig_loss,
1288                                     rls.rls_prim_seq_err,
1289                                     rls.rls_invalid_word,
1290                                     rls.rls_invalid_crc);
1291                         }
1292                     }
1293                 }
1294             }
1295             if (!goodPath) {
1296                 fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
1297                         argv[path_index]);
1298                 fprintf(stderr, "\n");
1299                 ret = -1;
1300             }
1301         }
1302         (void) fprintf(stdout,
1303                 MSGSTR(2009, "NOTE: These LESB counts are not"
1304                 " cleared by a reset, only power cycles.\n"
1305                 "These counts must be compared"
1306                 " to previously read counts.\n"));
1307         return (ret);
1308 }
1309
1310 typedef struct _PathInformation {
1311         char    pathClass[MAXPATHLEN];
1312         char    pathState[MAXPATHLEN];
1313         int32_t pathInfoState;
1314         int32_t pathInfoExternalState;
1315 } PathInformation;
1316
1317 struct lun_tracking {
1318         HBA_FCPSCSIENTRYV2  map;
1319         HBA_WWN hba_pwwn;
1320         char    hba_path[MAXPATHLEN];
1321         PathInformation info;
1322
1323         /* Points to another lun_tracking instance with the same map->LUID */
1324         struct lun_tracking     *next_path;
1325
1326         /* Points to next lun_tracking with a different map->LUID */
1327         struct lun_tracking *next_lun;
1328 };
1329
1330
1331 static const char VHCI_COMPONENT[] = "scsi_vhci";
1332 static void
1333 scsi_vhci_details(struct lun_tracking *lun)
1334 {
1335         HBA_FCPSCSIENTRYV2 entry = lun->map;
1336         int             retval = 0;
1337         int             pathcnt, i, count, found = 0;
1338         char            temppath[MAXPATHLEN];
1339         char            buf[MAXPATHLEN];
1340         char    *path_state[5];
1341
1342         char    *phys_path = get_slash_devices_from_osDevName(
1343                                 entry.ScsiId.OSDeviceName,
1344                                 STANDARD_DEVNAME_HANDLING);
1345         char    *devPath = NULL;
1346         char    *trailingCruft = NULL;
1347         char    devaddr[MAXPATHLEN];
1348         sv_iocdata_t    ioc;
1349         int     prop_buf_size = SV_PROP_MAX_BUF_SIZE;
1350         char    *path_class_val = NULL;
1351         char    client_path[MAXPATHLEN];
1352         char    phci_path[MAXPATHLEN];
1353
1354         /* Only proceed if we are an mpxio path */
1355         if (phys_path == NULL || strstr(phys_path, VHCI_COMPONENT) == NULL) {
1356             return;
1357         }
1358
1359         path_state[0] = MSGSTR(2400, "INIT");
1360         path_state[1] = MSGSTR(2401, "ONLINE");
1361         path_state[2] = MSGSTR(2402, "STANDBY");
1362         path_state[3] = MSGSTR(2403, "FAULT");
1363         path_state[4] = MSGSTR(2404, "OFFLINE");
1364
1365         sprintf(devaddr, "%016llx,%x", wwnConversion(
1366                 entry.FcpId.PortWWN.wwn),
1367                 entry.ScsiId.ScsiOSLun);
1368
1369         /* First get the controller path */
1370         sprintf(temppath, "/dev/cfg/c%d", entry.ScsiId.ScsiBusNumber);
1371         if ((count = readlink(temppath, buf, sizeof (buf)))) {
1372             buf[count] = '\0';
1373             /* Now skip over the leading "../.." */
1374             devPath = strstr(buf, "/devices/");
1375             if (devPath == NULL) {
1376                 strcpy(lun->info.pathClass, "Unavailable");
1377                 strcpy(lun->info.pathState, "Unavailable");
1378                 free(phys_path);
1379                 return;
1380             }
1381
1382             /* Now chop off the trailing ":xxx" portion if present */
1383             trailingCruft = strrchr(buf, ':');
1384             if (trailingCruft) {
1385                 trailingCruft[0] = '\0';
1386             }
1387         } else {
1388             strcpy(lun->info.pathClass, "Unavailable");
1389             strcpy(lun->info.pathState, "Unavailable");
1390             free(phys_path);
1391             return;
1392         }
1393
1394         ioc.client = client_path;
1395         ioc.phci = phci_path;
1396
1397         retval = get_scsi_vhci_pathinfo(phys_path, &ioc, &pathcnt);
1398         if (retval != 0) {
1399             print_errString(retval, NULL);
1400             exit(-1);
1401         }
1402
1403         for (i = 0; i < pathcnt; i++) {
1404             nvlist_t *nvl;
1405             if (strstr(devPath, ioc.ret_buf[i].device.ret_phci)) {
1406                 /* This could break someday if MPxIO changes devaddr */
1407                 if (strstr(ioc.ret_buf[i].ret_addr, devaddr)) {
1408                     retval = nvlist_unpack(ioc.ret_buf[i].ret_prop.buf,
1409                         prop_buf_size, &nvl, 0);
1410                     if (retval != 0) {
1411                         strcpy(lun->info.pathClass,
1412                             "UNKNOWN PROB");
1413                     } else {
1414                         strcpy(lun->info.pathState,
1415                             path_state[ioc.ret_buf[i].ret_state]);
1416                         lun->info.pathInfoState = ioc.ret_buf[i].ret_state;
1417                         lun->info.pathInfoExternalState =
1418                             ioc.ret_buf[i].ret_ext_state;
1419                         if (nvlist_lookup_string(nvl, "path-class",
1420                                 &path_class_val) == 0) {
1421                             strcpy(lun->info.pathClass, path_class_val);
1422                         } else {
1423                             strcpy(lun->info.pathClass, "UNKNOWN");
1424                         }
1425                     }
1426                     nvlist_free(nvl);
1427                     found++;
1428                     break;
1429                 }
1430             }
1431
1432         }
1433
1434         if (!found) {
1435             strcpy(lun->info.pathClass, "Unavailable");
1436             strcpy(lun->info.pathState, "Unavailable");
1437         }
1438         free(phys_path);
1439
1440         /* free everything we alloced */
1441         for (i = 0; i < ioc.buf_elem; i++) {
1442                 free(ioc.ret_buf[i].ret_prop.buf);
1443                 free(ioc.ret_buf[i].ret_prop.ret_buf_size);
1444         }
1445         free(ioc.ret_buf);
1446
1447 }
1448
1449 /* Utility routine to add new entries to the list (ignores dups) */
1450 static void
1451 add_lun_path(struct lun_tracking *head, HBA_FCPSCSIENTRYV2  *map,
1452             HBA_WWN pwwn, char *path)
1453 {
1454         struct lun_tracking *tmp = NULL, *cmp = NULL;
1455
1456         for (tmp = head; tmp != NULL; tmp = tmp->next_lun) {
1457             if (memcmp(&tmp->map.LUID, &map->LUID,
1458                     sizeof (HBA_LUID)) == 0) {
1459
1460                 /* Ensure this isn't a duplicate */
1461                 for (cmp = tmp; cmp->next_path != NULL;
1462                             cmp = cmp->next_path) {
1463                     if (memcmp(&cmp->map, map, sizeof (cmp->map)) == 0) {
1464                         return;
1465                     }
1466                 }
1467                 if (memcmp(&cmp->map, map, sizeof (cmp->map)) == 0) {
1468                     return;
1469                 }
1470
1471                 /* We have a new entry to add */
1472                 cmp->next_path = (struct lun_tracking *)calloc(1,
1473                     sizeof (struct lun_tracking));
1474                 cmp = cmp->next_path;
1475                 (void) memcpy(&cmp->map, map,
1476                     sizeof (cmp->map));
1477                 (void) memcpy(&cmp->hba_pwwn, &pwwn,
1478                         sizeof (cmp->hba_pwwn));
1479                 (void) snprintf(cmp->hba_path, MAXPATHLEN,
1480                     path);
1481                 scsi_vhci_details(cmp);
1482                 return;
1483             }
1484         }
1485         /* Append a new LUN at the end of the list */
1486         for (tmp = head; tmp->next_lun != NULL; tmp = tmp->next_lun) {}
1487         tmp->next_lun = (struct lun_tracking *)calloc(1,
1488                 sizeof (struct lun_tracking));
1489         tmp = tmp->next_lun;
1490         (void) memcpy(&tmp->map, map,
1491                 sizeof (tmp->map));
1492         (void) memcpy(&tmp->hba_pwwn, &pwwn,
1493                 sizeof (tmp->hba_pwwn));
1494         (void) snprintf(tmp->hba_path, MAXPATHLEN,
1495                 path);
1496         scsi_vhci_details(tmp);
1497 }
1498
1499 /*ARGSUSED*/
1500 int
1501 fchba_display_config(char **argv, int option_t_input, int argc)
1502 {
1503         int             path_index = 0;
1504         uint64_t        wwn;
1505         uint64_t        lun = 0;
1506         HBA_HANDLE handle;
1507         HBA_ADAPTERATTRIBUTES hbaAttrs;
1508         HBA_PORTATTRIBUTES portAttrs;
1509         HBA_FCPTARGETMAPPINGV2    *map;
1510         HBA_STATUS status;
1511         int count, adapterIndex, portIndex;
1512         char name[256];
1513         L_inquiry       inq;
1514         struct scsi_extended_sense sense;
1515         struct page80   serial;
1516         HBA_UINT8       scsiStatus;
1517         uint32_t        inquirySize = sizeof (inq), senseSize = sizeof (sense);
1518         uint32_t        serialSize = sizeof (serial);
1519         struct mode_page        *pg_hdr;
1520         uchar_t         *pg_buf;
1521         float           lunMbytes;
1522         struct capacity_data_struct cap_data;
1523         uint32_t            cap_data_size = sizeof (cap_data);
1524         struct mode_header_g1   *mode_header_ptr;
1525         int             offset;
1526         char *phys_path = NULL;
1527         int             mpxio = 0;
1528         int             wwnCompare = 0;
1529         char        *physical = NULL;
1530         struct lun_tracking     *head = NULL;
1531         boolean_t       goodPath = B_FALSE;
1532         int             ret = 0;
1533
1534
1535
1536         if ((status = loadLibrary())) {
1537             return (-1);
1538         }
1539         for (path_index = 0; argv[path_index] != NULL; path_index++) {
1540             goodPath = B_FALSE;
1541
1542             if (is_wwn(argv[path_index])) {
1543                 (void) sscanf(argv[path_index], "%016llx", &wwn);
1544                 wwnCompare = 1;
1545             } else if (!is_path(argv[path_index])) {
1546                 fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
1547                         argv[path_index]);
1548                 fprintf(stderr, "\n");
1549                 ret = -1;
1550                 continue;
1551             }
1552             if (!wwnCompare) {
1553                 /* Convert the paths to phsyical paths */
1554                 physical = get_slash_devices_from_osDevName(argv[path_index],
1555                         STANDARD_DEVNAME_HANDLING);
1556                 if (!physical) {
1557                     fprintf(stderr, MSGSTR(112,
1558                         "Error: Invalid pathname (%s)"),
1559                         argv[path_index]);
1560                     fprintf(stderr, "\n");
1561                     ret = -1;
1562                     continue;
1563                 }
1564             }
1565
1566             count = getNumberOfAdapters();
1567
1568
1569                 /*
1570                  * We have to loop twice to ensure we don't miss any
1571                  * extra paths for other targets in a multi-target device
1572                  */
1573
1574             /* First check WWN/path comparisons */
1575             for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
1576                 if (skip_hba(adapterIndex)) {
1577                     continue;
1578                 }
1579                 status = HBA_GetAdapterName(adapterIndex, (char *)&name);
1580                 if (status != HBA_STATUS_OK) {
1581                     /* May have been DR'd */
1582                     continue;
1583                 }
1584                 handle = HBA_OpenAdapter(name);
1585                 if (handle == 0) {
1586                     /* May have been DR'd */
1587                     continue;
1588                 }
1589                 if (getAdapterAttrs(handle, name, &hbaAttrs)) {
1590                     /* Should never happen */
1591                     HBA_CloseAdapter(handle);
1592                     continue;
1593                 }
1594
1595                 /* Loop over all HBA Ports */
1596                 for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
1597                         portIndex++) {
1598                     int     matched = 0;
1599                     int     mapIndex;
1600                     char            *tmp;
1601                     if (getAdapterPortAttrs(handle, name, portIndex,
1602                             &portAttrs)) {
1603                         continue;
1604                     }
1605
1606                     if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
1607                         continue;
1608                     }
1609
1610
1611
1612                     for (mapIndex = 0; mapIndex < map->NumberOfEntries;
1613                             mapIndex ++) {
1614                         matched = 0;
1615                         if (wwnCompare) {
1616                             if (wwn == wwnConversion(
1617                                     map->entry[mapIndex].FcpId.NodeWWN.wwn) ||
1618                                     wwn == wwnConversion(
1619                                     map->entry[mapIndex].FcpId.PortWWN.wwn)) {
1620                                 matched = 1;
1621                             }
1622                         } else {
1623                             tmp = get_slash_devices_from_osDevName(
1624                                     map->entry[mapIndex].ScsiId.OSDeviceName,
1625                                     STANDARD_DEVNAME_HANDLING);
1626                             if ((tmp != NULL) && (strncmp(physical, tmp,
1627                                     MAXPATHLEN) == 0)) {
1628                                 matched = 1;
1629                                 free(tmp);
1630                             }
1631                         }
1632                         if (matched && head == NULL) {
1633                             goodPath = B_TRUE;
1634                             head  = (struct lun_tracking *)calloc(1,
1635                                     sizeof (struct lun_tracking));
1636                             (void) memcpy(&head->map, &map->entry[mapIndex],
1637                                     sizeof (head->map));
1638                             (void) memcpy(&head->hba_pwwn, &portAttrs.PortWWN,
1639                                     sizeof (head->hba_pwwn));
1640                             (void) snprintf(head->hba_path, MAXPATHLEN,
1641                                 portAttrs.OSDeviceName);
1642                             scsi_vhci_details(head);
1643                         } else if (matched) {
1644                             goodPath = B_TRUE;
1645                             add_lun_path(head, &map->entry[mapIndex],
1646                                 portAttrs.PortWWN, portAttrs.OSDeviceName);
1647                         }
1648                     }
1649                 }
1650             }
1651
1652             if (physical) {
1653                 free(physical);
1654             }
1655
1656             /* Now do it again and look for matching LUIDs (aka GUIDs) */
1657             for (adapterIndex = 0; adapterIndex < count; adapterIndex ++) {
1658                 if (skip_hba(adapterIndex)) {
1659                     continue;
1660                 }
1661                 status = HBA_GetAdapterName(adapterIndex, (char *)&name);
1662                 if (status != HBA_STATUS_OK) {
1663                     /* May have been DR'd */
1664                     continue;
1665                 }
1666                 handle = HBA_OpenAdapter(name);
1667                 if (handle == 0) {
1668                     /* May have been DR'd */
1669                     continue;
1670                 }
1671
1672                 if (getAdapterAttrs(handle, name, &hbaAttrs)) {
1673                     /* Should never happen */
1674                     HBA_CloseAdapter(handle);
1675                     continue;
1676                 }
1677
1678
1679                 /* Loop over all HBA Ports */
1680                 for (portIndex = 0; portIndex < hbaAttrs.NumberOfPorts;
1681                         portIndex++) {
1682                     int     matched = 0;
1683                     int     mapIndex;
1684                     if (getAdapterPortAttrs(handle, name, portIndex,
1685                             &portAttrs)) {
1686                         continue;
1687                     }
1688
1689                     if (fetch_mappings(handle, portAttrs.PortWWN, &map)) {
1690                         continue;
1691                     }
1692
1693
1694                     for (mapIndex = 0; mapIndex < map->NumberOfEntries;
1695                             mapIndex ++) {
1696                         struct lun_tracking *outer;
1697                         matched = 0;
1698                         for (outer = head; outer != NULL;
1699                                     outer = outer->next_lun) {
1700                             struct lun_tracking *inner;
1701                             for (inner = outer; inner != NULL;
1702                                     inner = inner->next_path) {
1703                                 if (memcmp(&inner->map.LUID,
1704                                         &map->entry[mapIndex].LUID,
1705                                         sizeof (HBA_LUID)) == 0) {
1706                                     matched = 1;
1707                                     break;
1708                                 }
1709                             }
1710                             if (matched) {
1711                                 break;
1712                             }
1713                         }
1714                         if (matched && head == NULL) {
1715                             goodPath = B_TRUE;
1716                             head  = (struct lun_tracking *)calloc(1,
1717                                     sizeof (struct lun_tracking));
1718                             (void) memcpy(&head->map, &map->entry[mapIndex],
1719                                     sizeof (head->map));
1720                             (void) memcpy(&head->hba_pwwn, &portAttrs.PortWWN,
1721                                     sizeof (head->hba_pwwn));
1722                             (void) snprintf(head->hba_path, MAXPATHLEN,
1723                                 portAttrs.OSDeviceName);
1724                             scsi_vhci_details(head);
1725                         } else if (matched) {
1726                             goodPath = B_TRUE;
1727                             add_lun_path(head, &map->entry[mapIndex],
1728                                 portAttrs.PortWWN, portAttrs.OSDeviceName);
1729                         }
1730                     }
1731                 }
1732             }
1733             if (!goodPath) {
1734                 fprintf(stderr, MSGSTR(112, "Error: Invalid pathname (%s)"),
1735                         argv[path_index]);
1736                 fprintf(stderr, "\n");
1737                 ret = -1;
1738                 /* Just bomb out instead of going on */
1739                 return (ret);
1740             }
1741         }
1742
1743         /* Now display all the LUNs that we found that matched */
1744         {
1745             struct lun_tracking *first_time;
1746             struct lun_tracking *tmp_path;
1747             for (first_time = head; first_time != NULL;
1748                     first_time = first_time->next_lun) {
1749                 struct lun_tracking *path;
1750                 phys_path = get_slash_devices_from_osDevName(
1751                     first_time->map.ScsiId.OSDeviceName,
1752                     STANDARD_DEVNAME_HANDLING);
1753                 /* Change behavior if this is an MPxIO device */
1754                 if (phys_path != NULL) {
1755                     if (strstr(phys_path, VHCI_COMPONENT) != NULL) {
1756                         mpxio = 1;
1757                     }
1758                 }
1759
1760                 for (tmp_path = first_time; tmp_path != NULL;
1761                         tmp_path = tmp_path->next_path) {
1762                         if (mpxio && (strncmp(tmp_path->info.pathState,
1763                             "ONLINE", strlen(tmp_path->info.pathState)))) {
1764                                 /* continue to next online path */
1765                                 continue;
1766                         }
1767                         status = HBA_OpenAdapterByWWN(&handle,
1768                             tmp_path->hba_pwwn);
1769                         if (status != HBA_STATUS_OK) {
1770                                 fprintf(stderr, MSGSTR(2431,
1771                                     "Error: Failed to get handle for %s  "),
1772                                     tmp_path->hba_path);
1773                                 printStatus(status);
1774                                 fprintf(stderr, "\n");
1775                                 /* continue to next path */
1776                                 continue;
1777                         }
1778
1779                         lun = tmp_path->map.FcpId.FcpLun;
1780                         memset(&inq, 0, sizeof (inq));
1781                         memset(&sense, 0, sizeof (sense));
1782
1783                         status = HBA_ScsiInquiryV2(handle,
1784                                 tmp_path->hba_pwwn,
1785                                 tmp_path->map.FcpId.PortWWN,
1786                                 lun, 0, 0,
1787                                 &inq, &inquirySize,
1788                                 &scsiStatus,
1789                                 &sense, &senseSize);
1790
1791                         if (status == HBA_STATUS_OK) {
1792                                 break;
1793                         }
1794                         HBA_CloseAdapter(handle);
1795                 }
1796
1797                 if (tmp_path == NULL) {
1798                         fprintf(stderr, MSGSTR(2430,
1799                             "Error: I/O failure communicating with %s  "),
1800                             first_time->map.ScsiId.OSDeviceName);
1801                         printStatus(status);
1802                         fprintf(stderr, "\n");
1803                         continue;
1804                 }
1805
1806                 switch ((inq.inq_dtype & DTYPE_MASK)) {
1807                 case DTYPE_DIRECT:
1808                     fprintf(stdout, MSGSTR(121,
1809                             "DEVICE PROPERTIES for disk: %s\n"),
1810                             first_time->map.ScsiId.OSDeviceName);
1811                     break;
1812                 case DTYPE_SEQUENTIAL: /* Tape */
1813                     fprintf(stdout, MSGSTR(2249,
1814                             "DEVICE PROPERTIES for tape: %s\n"),
1815                             first_time->map.ScsiId.OSDeviceName);
1816                     break;
1817                 default:
1818                     fprintf(stdout, MSGSTR(2250,
1819                             "DEVICE PROPERTIES for: %s\n"),
1820                             first_time->map.ScsiId.OSDeviceName);
1821                     break;
1822                 }
1823                 fprintf(stdout, "  ");
1824                 fprintf(stdout, MSGSTR(3, "Vendor:"));
1825                 fprintf(stdout, "\t\t");
1826                 print_chars(inq.inq_vid, sizeof (inq.inq_vid), 0);
1827                 fprintf(stdout, MSGSTR(2115, "\n  Product ID:\t\t"));
1828                 print_chars(inq.inq_pid, sizeof (inq.inq_pid), 0);
1829
1830                 fprintf(stdout, "\n  ");
1831                 fprintf(stdout, MSGSTR(2119, "Revision:"));
1832                 fprintf(stdout, "\t\t");
1833                 print_chars(inq.inq_revision, sizeof (inq.inq_revision), 0);
1834
1835                 fprintf(stdout, "\n  ");
1836                 fprintf(stdout, MSGSTR(17, "Serial Num:"));
1837                 fprintf(stdout, "\t\t");
1838                 (void) fflush(stdout);
1839                 /*
1840                  * Call the inquiry cmd on page 0x80 only if the vendor
1841                  * supports page 0x80.
1842                  */
1843                 if ((find_supported_inq_page(handle, first_time->hba_pwwn,
1844                     first_time->map.FcpId.PortWWN, lun, 0x80))) {
1845                         memset(&serial, 0, sizeof (serial));
1846                         status = HBA_ScsiInquiryV2(handle,
1847                             first_time->hba_pwwn,
1848                             first_time->map.FcpId.PortWWN,
1849                             lun, 1, 0x80,
1850                             &serial, &serialSize,
1851                             &scsiStatus,
1852                             &sense, &senseSize);
1853                         if (status == HBA_STATUS_OK) {
1854                                 print_chars(serial.inq_serial,
1855                                     sizeof (serial.inq_serial), 0);
1856                         } else {
1857                                 fprintf(stdout, MSGSTR(2506, "Unsupported"));
1858                         }
1859                 } else {
1860                         fprintf(stdout, MSGSTR(2506, "Unsupported"));
1861                 }
1862                 HBA_CloseAdapter(handle);
1863                 if ((inq.inq_dtype & DTYPE_MASK) == DTYPE_DIRECT) {
1864                 /* Read capacity wont work on standby paths, so try till OK */
1865                     for (tmp_path = first_time; tmp_path != NULL;
1866                         tmp_path = tmp_path->next_path) {
1867                         if (mpxio && (strncmp(tmp_path->info.pathState,
1868                             "ONLINE", strlen(tmp_path->info.pathState)))) {
1869                             /* continue to next online path */
1870                             continue;
1871                         }
1872                         status = HBA_OpenAdapterByWWN(&handle,
1873                                                 tmp_path->hba_pwwn);
1874                         if (status != HBA_STATUS_OK) {
1875                             /* continue to next path */
1876                             continue;
1877                         }
1878
1879                         status = HBA_ScsiReadCapacityV2(handle,
1880                             tmp_path->hba_pwwn,
1881                             tmp_path->map.FcpId.PortWWN,
1882                             tmp_path->map.FcpId.FcpLun,
1883                             &cap_data, &cap_data_size,
1884                             &scsiStatus,
1885                             &sense, &senseSize);
1886                         if (status == HBA_STATUS_OK) {
1887                             break;
1888                         } else if (status == HBA_STATUS_SCSI_CHECK_CONDITION &&
1889                             sense.es_key == KEY_UNIT_ATTENTION) {
1890                         /*
1891                          * retry for check-condition state when unit attention
1892                          * condition has been established
1893                          */
1894                             status =  HBA_ScsiReadCapacityV2(handle,
1895                                 tmp_path->hba_pwwn,
1896                                 tmp_path->map.FcpId.PortWWN,
1897                                 tmp_path->map.FcpId.FcpLun,
1898                                 &cap_data, &cap_data_size,
1899                                 &scsiStatus,
1900                                 &sense, &senseSize);
1901                             if (status == HBA_STATUS_OK) {
1902                                 break;
1903                             }
1904                         }
1905                         HBA_CloseAdapter(handle);
1906                     }
1907                 }
1908                 if (handle != HBA_HANDLE_INVALID) {
1909                         HBA_CloseAdapter(handle);
1910                 }
1911                 if (status != HBA_STATUS_OK) {
1912                     /* Make sure we don't display garbage */
1913                     cap_data.block_size = 0;
1914                     cap_data.last_block_addr = 0;
1915                 }
1916
1917                 if (cap_data.block_size > 0 &&
1918                         cap_data.last_block_addr > 0) {
1919                     lunMbytes = ntohl(cap_data.last_block_addr) + 1;
1920                     lunMbytes *= ntohl(cap_data.block_size);
1921                     lunMbytes /= (float)(1024*1024);
1922                     fprintf(stdout, "\n  ");
1923                     fprintf(stdout, MSGSTR(60,
1924                             "Unformatted capacity:\t%6.3f MBytes"), lunMbytes);
1925                 }
1926                 fprintf(stdout, "\n");
1927
1928                 /*
1929                  * get mode page information for FC device.
1930                  * do not do mode sense if this is a tape device.
1931                  * mode sense will rewind the tape
1932                  */
1933                 if ((inq.inq_dtype & DTYPE_MASK) != DTYPE_SEQUENTIAL) {
1934                     if (get_mode_page(first_time->map.ScsiId.OSDeviceName,
1935                         &pg_buf) == 0) {
1936                         mode_header_ptr = (struct mode_header_g1 *)
1937                                 (void *)pg_buf;
1938                         offset = sizeof (struct mode_header_g1) +
1939                             ntohs(mode_header_ptr->bdesc_length);
1940                         pg_hdr = (struct mode_page *)&pg_buf[offset];
1941
1942                         while (offset < (ntohs(mode_header_ptr->length) +
1943                             sizeof (mode_header_ptr->length))) {
1944                             if (pg_hdr->code == MODEPAGE_CACHING) {
1945                                 struct  mode_caching    *pg8_buf;
1946                                 pg8_buf = (struct mode_caching *)
1947                                     (void *)pg_hdr;
1948                                 if (pg8_buf->wce) {
1949                                     fprintf(stdout, MSGSTR(2122,
1950                                         "  Write Cache:\t\t"
1951                                         "Enabled\n"));
1952                                 }
1953                                 if (pg8_buf->rcd == 0) {
1954                                     fprintf(stdout, MSGSTR(2123,
1955                                         "  Read Cache:\t\t"
1956                                         "Enabled\n"));
1957                                     fprintf(stdout, MSGSTR(2509,
1958                                         "    Minimum prefetch:\t0x%x\n"
1959                                         "    Maximum prefetch:\t0x%x\n"),
1960                                         pg8_buf->min_prefetch,
1961                                         pg8_buf->max_prefetch);
1962                                 }
1963                                 break;
1964                             }
1965                             offset += pg_hdr->length +
1966                                 sizeof (struct mode_page);
1967                             pg_hdr = (struct mode_page *)&pg_buf[offset];
1968                         }
1969                     }
1970                 }
1971
1972                 fprintf(stdout, "  %s\t\t", MSGSTR(35, "Device Type:"));
1973                 if ((inq.inq_dtype & DTYPE_MASK) < 0x10) {
1974                         fprintf(stdout, "%s\n",
1975                             dtype[inq.inq_dtype & DTYPE_MASK]);
1976                 } else if ((inq.inq_dtype & DTYPE_MASK) < 0x1f) {
1977                         fprintf(stdout, MSGSTR(2432, "Reserved"));
1978                 } else {
1979                         /* dtype of 0x1f is returned */
1980                         fprintf(stdout, MSGSTR(2433, "Unknown"));
1981                 }
1982
1983                 fprintf(stdout, MSGSTR(2128, "  Path(s):\n"));
1984                 fprintf(stdout, "\n");
1985                 fprintf(stdout, "  %s\n",
1986                     first_time->map.ScsiId.OSDeviceName);
1987                 if (phys_path != NULL) {
1988                     fprintf(stdout, "  %s\n", phys_path);
1989                 }
1990
1991                 /* Now display all paths to this LUN */
1992                 for (path = first_time; path != NULL;
1993                     path = path->next_path) {
1994                     /* Display the controller information */
1995                     fprintf(stdout, MSGSTR(2303, "   Controller      \t%s\n"),
1996                             path->hba_path);
1997
1998                     fprintf(stdout, MSGSTR(2507,
1999                             "    Device Address\t\t%016llx,%x\n"),
2000                             wwnConversion(
2001                             path->map.FcpId.PortWWN.wwn),
2002                             path->map.ScsiId.ScsiOSLun);
2003
2004                     fprintf(stdout, MSGSTR(2508,
2005                             "    Host controller port WWN\t%016llx\n"),
2006                             wwnConversion(path->hba_pwwn.wwn));
2007
2008                     if (mpxio) {
2009                         fprintf(stdout, MSGSTR(2305,
2010                                 "    Class\t\t\t%s\n"), path->info.pathClass);
2011                         fprintf(stdout, MSGSTR(2306,
2012                                 "    State\t\t\t%s\n"), path->info.pathState);
2013                     }
2014                     if (phys_path != NULL) {
2015                         free(phys_path);
2016                         phys_path = NULL;
2017                     }
2018                 }
2019                 printf("\n");
2020             }
2021         }
2022         return (ret);
2023 }
2024
2025 /*
2026  * handle expert-mode hotplug commands
2027  *
2028  * return 0 iff all is okay
2029  */
2030 int
2031 fchba_hotplug_e(int todo, char **argv, int verbose_flag, int force_flag)
2032 {
2033 char            *path_phys = NULL;
2034 int             exit_code;
2035 devctl_hdl_t    dcp;
2036
2037         if (todo != DEV_ONLINE &&
2038             todo != DEV_OFFLINE) {
2039             fprintf(stderr, "%s\n", strerror(ENOTSUP));
2040             return (-1);
2041         }
2042
2043         /* Convert the paths to phsyical paths */
2044         path_phys = get_slash_devices_from_osDevName(argv[0],
2045                 NOT_IGNORE_DANGLING_LINK);
2046         if (!path_phys) {
2047             fprintf(stderr, MSGSTR(112,
2048                 "Error: Invalid pathname (%s)"),
2049                 argv[0]);
2050             fprintf(stderr, "\n");
2051             return (-1);
2052         }
2053         if (verbose_flag) {
2054                 (void) fprintf(stdout,
2055                                 MSGSTR(5516,
2056                                 "phys path = \"%s\"\n"),
2057                                 path_phys);
2058         }
2059         /* acquire rights to hack on device */
2060         if ((dcp = devctl_device_acquire(path_phys,
2061                 force_flag ? 0 : DC_EXCL)) == NULL) {
2062
2063                 (void) fprintf(stderr, MSGSTR(5517,
2064                     "Error: can't acquire \"%s\": %s\n"),
2065                     path_phys, strerror(errno));
2066                 return (1);
2067         }
2068
2069         switch (todo) {
2070         case DEV_ONLINE:
2071                 exit_code = devctl_device_online(dcp);
2072                 break;
2073         case DEV_OFFLINE:
2074                 exit_code = devctl_device_offline(dcp);
2075                 break;
2076         }
2077
2078         if (exit_code != 0) {
2079                 perror(MSGSTR(5518, "devctl"));
2080         }
2081
2082         /* all done now -- release device */
2083         devctl_release(dcp);
2084
2085         if (path_phys) {
2086             free(path_phys);
2087         }
2088
2089         return (exit_code);
2090 }
2091
2092 /*
2093  * Returns non zero if we should use FC-HBA.
2094  * For x86, luxadm uses FC-HBA.
2095  */
2096 int
2097 use_fchba()
2098 {
2099
2100 #ifdef __x86
2101         return (1);
2102 #else
2103         return (0);
2104 #endif
2105
2106 }
2107
2108 /*
2109  * Returns non-zero if we should skip the HBA at index "i"
2110  */
2111 int
2112 skip_hba(int i) {
2113         HBA_LIBRARYATTRIBUTES lib_attrs;
2114         (void) HBA_GetVendorLibraryAttributes(i, &lib_attrs);
2115         if (strncmp(lib_attrs.VName, VSL_NAME,
2116                 sizeof (lib_attrs.VName)) == 0) {
2117             return (0);
2118         }
2119         return (1);
2120 }
2121
2122 /*
2123  * Function to determine if the given page is supported by vendor.
2124  */
2125 int
2126 find_supported_inq_page(HBA_HANDLE handle, HBA_WWN hwwn, HBA_WWN pwwn,
2127     uint64_t lun, int page_num)
2128 {
2129         struct  scsi_extended_sense     sense;
2130         L_inquiry00                     inq00;
2131         uchar_t                         *data;
2132         HBA_STATUS                      status = HBA_STATUS_ERROR;
2133         int                             index;
2134         HBA_UINT8                       scsiStatus;
2135         uint32_t                        inqSize = sizeof (inq00);
2136         uint32_t                        senseSize = sizeof (sense);
2137
2138         status = HBA_ScsiInquiryV2(handle, hwwn, pwwn, lun, 1, 0x00,
2139             &inq00, &inqSize, &scsiStatus, &sense, &senseSize);
2140
2141         if (status == HBA_STATUS_OK) {
2142                 data = (uchar_t *)&inq00;
2143                 for (index = 4; (index <= inq00.len+3)&&
2144                     (data[index] <= page_num); index ++) {
2145                         if (data[index] == page_num) {
2146                                 return (1);
2147                         }
2148                 }
2149         }
2150         return (0);
2151 }