libg_fc/common/genf.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*LINTLIBRARY*/

/*
 *  This module is part of the Fibre Channel Interface library.
 *
 */

/*
 * I18N message number ranges
 *  This file: 10500 - 10999
 *  Shared common messages: 1 - 1999
 */

/*  Includes    */
#include    <stdlib.h>
#include    <stdio.h>
#include    <sys/file.h>
#include    <sys/types.h>
#include    <sys/stat.h>
#include    <sys/param.h>
#include    <fcntl.h>
#include    <string.h>
#include    <errno.h>
#include    <assert.h>
#include    <unistd.h>
#include    <sys/types.h>
#include    <sys/param.h>
#include    <sys/dklabel.h>
#include    <sys/autoconf.h>
#include    <sys/utsname.h>
#include    <sys/ddi.h>     /* for min */
#include    <ctype.h>       /* for isprint */
#include    <sys/scsi/scsi.h>
#include    <dirent.h>      /* for DIR */
#include    <nl_types.h>
#include    <locale.h>
#include    <thread.h>
#include    <synch.h>
#include    <l_common.h>
#include    <stgcom.h>
#include    <l_error.h>
#include    <g_state.h>
#include    <libdevinfo.h>


/*  Defines     */
#define BYTES_PER_LINE      16  /* # of bytes to dump per line */
#define SCMD_UNKNOWN        0xff

/* Bus strings - for internal use by g_get_path_type() only */
#define PCI_BUS         1
#define SBUS            2
#define FCOE            3

struct str_type {
    char *string;
    uint_t type;
};

static struct str_type ValidBusStrings[] = {
    {"pci@", PCI_BUS},
    {"sbus@", SBUS},
    {"fcoe", FCOE},
    {NULL, 0}
};


/*
 *  Strings below were used before cougar driver(qlc) was proposed.
 *  {"scsi/", FC_PCI_FCA},
 *  {"fibre-channel/", FC_PCI_FCA},
 */
static struct str_type ValidFCAstrings[] = {
    {"SUNW,ifp@", FC4_PCI_FCA | FC4_IFP_XPORT},
    {"SUNW,socal@", FC4_SOCAL_FCA},
    {NULL, 0}
};

static struct str_type ValidXportStrings[] = {
    {"/sf@", FC4_SF_XPORT},
    {"/fp@", FC_GEN_XPORT},
    {NULL, 0}
};

struct _enclDisk {
    char *vid;
    char *pid;
};

/*
 * SENA/SUNWGS type enclosure disk table. This table contains vendor IDs and
 * the non-unique portion of the product identifier sufficient for
 * comparison. This table needs to be updated as new drives are supported
 * in the SENA/SUNWGS type enclosures that do not have a corresponding match
 * in this table. Currently, the v880 and v890 are the only shipping products
 * that utilize the SUNWGS type enclosure. SENA is EOL'd. The risk of new
 * devices being added that do not match an entry in this table is small but it
 * does exist.
 */
static struct _enclDisk enclDiskTbl[] = {
    {"SUN", "SENA"},
    {"SUN", "SUNWGS"},
    {"FUJITSU", "MA"},
    {"HITACHI", "DK"},
    {"HITACHI", "HU"},
    {"SEAGATE", "ST"},
    {NULL, NULL}
};


/* i18n */
nl_catd     l_catd;


/*  Internal Functions  */
static  void    string_dump(char *, uchar_t *, int, int, char msg_string[]);

/*
 * Allocate space for and return a pointer to a string
 * on the stack.  If the string is null, create
 * an empty string.
 * Use g_destroy_data() to free when no longer used.
 */
char *
g_alloc_string(char *s)
{
    char    *ns;

    if (s == (char *)NULL) {
        ns = (char *)g_zalloc(1);
    } else {
        ns = (char *)g_zalloc(strlen(s) + 1);
        if (ns != NULL) {
            (void) strncpy(ns, s, (strlen(s) + 1));
        }
    }
    return (ns);
}


/*
 * This routine is a wrapper for free.
 */
void
g_destroy_data(void *data)
{
    A_DPRINTF("  g_destroy_data: Free\'ed buffer at 0x%x\n",
        data);
    free((void *)data);
}


/*
 * Dump a structure in hexadecimal.
 */
void
g_dump(char *hdr, uchar_t *src, int nbytes, int format)
{
    int i;
    int n;
    char    *p;
    char    s[256];

    assert(format == HEX_ONLY || format == HEX_ASCII);

    (void) strcpy(s, hdr);
    for (p = s; *p; p++) {
        *p = ' ';
    }

    p = hdr;
    while (nbytes > 0) {
        (void) fprintf(stdout, "%s", p);
        p = s;
        n = min(nbytes, BYTES_PER_LINE);
        for (i = 0; i < n; i++) {
            (void) fprintf(stdout, "%02x ", src[i] & 0xff);
        }
        if (format == HEX_ASCII) {
            for (i = BYTES_PER_LINE-n; i > 0; i--) {
                (void) fprintf(stdout, "   ");
            }
            (void) fprintf(stdout, "    ");
            for (i = 0; i < n; i++) {
                (void) fprintf(stdout, "%c",
                    isprint(src[i]) ? src[i] : '.');
            }
        }
        (void) fprintf(stdout, "\n");
        nbytes -= n;
        src += n;
    }
}

/*
 * Internal routine to clean up ../'s in paths.
 * returns 0 if no "../" are left.
 *
 * Wouldn't it be nice if there was a standard system library
 * routine to do this...?
 */
static int
cleanup_dotdot_path(char *path)
{
    char holder[MAXPATHLEN];
    char *dotdot;
    char *previous_slash;

    /* Find the first "/../" in the string */
    dotdot = strstr(path, "/../");
    if (dotdot == NULL) {
        return (0);
    }


    /*
     * If the [0] character is '/' and "../" immediatly
     * follows it, then we can strip the ../
     *
     *  /../../foo/bar == /foo/bar
     *
     */
    if (dotdot == path) {
        strcpy(holder, &path[3]); /* strip "/.." */
        strcpy(path, holder);
        return (1);
    }

    /*
     * Now look for the LAST "/" before the "/../"
     * as this is the parent dir we can get rid of.
     * We do this by temporarily truncating the string
     * at the '/' just before "../" using the dotdot pointer.
     */
    *dotdot = '\0';
    previous_slash = strrchr(path, '/');
    if (previous_slash == NULL) {
        /*
         * hmm, somethings wrong.  path looks something
         * like "foo/../bar/" so we can't really deal with it.
         */
        return (0);
    }
    /*
     * Now truncate the path just after the previous '/'
     * and slam everything after the "../" back on
     */
    *(previous_slash+1) = '\0';
    strcat(path, dotdot+4);
    return (1); /* We may have more "../"s */
}


/*
 * Follow symbolic links from the logical device name to
 * the /devfs physical device name.  To be complete, we
 * handle the case of multiple links.  This function
 * either returns NULL (no links, or some other error),
 * or the physical device name, alloc'ed on the heap.
 *
 * NOTE: If the path is relative, it will be forced into
 * an absolute path by pre-pending the pwd to it.
 */
char *
g_get_physical_name_from_link(char *path)
{
    struct stat stbuf;
    char        source[MAXPATHLEN];
    char        scratch[MAXPATHLEN];
    char        pwd[MAXPATHLEN];
    char        *tmp;
    int         cnt;

    /* return NULL if path is NULL */
    if (path == NULL) {
        return (NULL);
    }

    strcpy(source, path);
    for (;;) {

        /*
         * First make sure the path is absolute.  If not, make it.
         * If it's already an absolute path, we have no need
         * to determine the cwd, so the program should still
         * function within security-by-obscurity directories.
         */
        if (source[0] != '/') {
            tmp = getcwd(pwd, MAXPATHLEN);
            if (tmp == NULL) {
                O_DPRINTF("getcwd() failed - %s\n",
                    strerror(errno));
                return (NULL);
            }
            /*
             * Handle special case of "./foo/bar"
             */
            if (source[0] == '.' && source[1] == '/') {
                strcpy(scratch, source+2);
            } else { /* no "./" so just take everything */
                strcpy(scratch, source);
            }
            strcpy(source, pwd);
            strcat(source, "/");
            strcat(source, scratch);
        }

        /*
         * Clean up any "../"s that are in the path
         */
        while (cleanup_dotdot_path(source));

        /*
         * source is now an absolute path to the link we're
         * concerned with
         *
         * See if there's a real file out there.  If not,
         * we have a dangling link and we ignore it.
         */

        if (stat(source, &stbuf) == -1) {
            O_DPRINTF("stat() failed for %s- %s\n",
                source, strerror(errno));
            return (NULL);
        }
        if (lstat(source, &stbuf) == -1) {
            O_DPRINTF("lstat() failed for - %s\n",
                source, strerror(errno));
            return (NULL);
        }
        /*
         * If the file is not a link, we're done one
         * way or the other.  If there were links,
         * return the full pathname of the resulting
         * file.
         *
         * Note:  All of our temp's are on the stack,
         * so we have to copy the final result to the heap.
         */
        if (!S_ISLNK(stbuf.st_mode)) {
            return (g_alloc_string(source));
        }
        cnt = readlink(source, scratch, sizeof (scratch));
        if (cnt < 0) {
            O_DPRINTF("readlink() failed - %s\n",
                strerror(errno));
            return (NULL);
        }
        /*
         * scratch is on the heap, and for some reason readlink
         * doesn't always terminate things properly so we have
         * to make certain we're properly terminated
         */
        scratch[cnt] = '\0';

        /*
         * Now check to see if the link is relative.  If so,
         * then we have to append it to the directory
         * which the source was in. (This is non trivial)
         */
        if (scratch[0] != '/') {
            tmp = strrchr(source, '/');
            if (tmp == NULL) { /* Whoa!  Something's hosed! */
                O_DPRINTF("Internal error... corrupt path.\n");
                return (NULL);
            }
            /* Now strip off just the directory path */
            *(tmp+1) = '\0'; /* Keeping the last '/' */
            /* and append the new link */
            strcat(source, scratch);
            /*
             * Note:  At this point, source should have "../"s
             * but we'll clean it up in the next pass through
             * the loop.
             */
        } else {
            /* It's an absolute link so no worries */
            strcpy(source, scratch);
        }
    }
    /* Never reach here */
}

/*
 * Function for getting physical pathnames
 *
 * This function can handle 3 different inputs.
 *
 * 1) Inputs of the form cN
 *  This requires the program  to search the /dev/rdsk
 *  directory for a device that is conected to the
 *  controller with number 'N' and then getting
 *  the physical pathname of the controller.
 *  The format of the controller pathname is
 *  /devices/.../.../SUNW,soc@x,x/SUNW,pln@xxxx,xxxxxxxx:ctlr
 *  The physical pathname is returned.
 *
 * 2) Inputs of the form /dev/rdsk/cNtNdNsN
 *  These are identified by being a link
 *  The physical path they are linked to is returned.
 *
 * 3) Inputs of the form /devices/...
 *  These are actual physical names.
 *  They are not converted.
 */
char *
g_get_physical_name(char *path)
{
    struct stat stbuf;
    char        s[MAXPATHLEN];
    char        namebuf[MAXPATHLEN];
    char        savedir[MAXPATHLEN];
    char        *result = NULL;
    DIR     *dirp;
    struct dirent   *entp;
    char        *dev_name, *char_ptr;
    struct stat sb;
    int     found_flag = 0;
    int     status = 0;
    int     i;

    /* return invalid path if path NULL */
    if (path == NULL) {
        return (NULL);
    }

    (void) strcpy(s, path);
    /*
     * See if the form is cN
     * Must handle scenaro where there is a file cN in this directory
     * Bug ID: 1184633
     *
     * We could be in the /dev/rdsk directory and the file could be of
     * the form cNdNsN (See man disks).
     */
    status = stat(s, &stbuf);
    if (((status == -1) && (errno == ENOENT)) ||
        ((s[0] == 'c') && ((int)strlen(s) > 1) && ((int)strlen(s) < 5))) {
        /*
         * Further qualify cN entry
         */
        if ((s[0] != 'c') || ((int)strlen(s) <= 1) ||
        ((int)strlen(s) >= 5)) {
            goto exit;
        }
        for (i = 1; i < (int)strlen(s); i++) {
            if ((s[i] < '0') || (s[i] > '9')) {
                goto exit;
            }
        }
        /*
         * path does not point to a file or file is of form cN
         */
        P_DPRINTF("  g_get_physical_name: "
            "Found entry of the form cN n=%s len=%d\n",
            &s[1], strlen(s));

        dev_name = g_zalloc(sizeof ("/dev/rdsk"));
        sprintf((char *)dev_name, "/dev/rdsk");

        if ((dirp = opendir(dev_name)) == NULL) {
            g_destroy_data(dev_name);
            goto exit;
        }

        while ((entp = readdir(dirp)) != NULL) {
            if (strcmp(entp->d_name, ".") == 0 ||
            strcmp(entp->d_name, "..") == 0)
            continue;

            if (entp->d_name[0] != 'c')
            /*
             * Silently Ignore for now any names
             * not stating with c
             */
            continue;

            sprintf(namebuf, "%s/%s", dev_name, entp->d_name);

            if ((lstat(namebuf, &sb)) < 0) {
                L_WARNINGS(MSGSTR(55,
                    "Warning: Cannot stat %s\n"),
                    namebuf);
            continue;
            }

            if (!S_ISLNK(sb.st_mode)) {
                L_WARNINGS(MSGSTR(56,
                    "Warning: %s is not a symbolic link\n"),
                    namebuf);
            continue;
            }

            if (strstr(entp->d_name, s) != NULL) {
            /*
             * found link to device in /devices
             *
             * Further qualify to be sure I have
             * not found entry of the form c10
             * when I am searching for c1
             */
            if (atoi(&s[1]) == atoi(&entp->d_name[1])) {
                P_DPRINTF("  g_get_physical_name: "
                "Found entry in /dev/rdsk matching %s: %s\n",
                s, entp->d_name);
                found_flag = 1;
                break;
            }
            }
        }
        closedir(dirp);
        g_destroy_data(dev_name);

        if (found_flag) {
            result = g_get_physical_name_from_link(namebuf);
            if (result == NULL) {
            goto exit;
            }
            /*
             * Convert from device name to controller name
             */
            char_ptr = strrchr(result, '/');
            *char_ptr = '\0';   /* Terminate sting  */
            (void) strcat(result, CTLR_POSTFIX);
        }
        goto exit;
    }
    if (status == -1)
        goto exit;

    if (lstat(s, &stbuf) == -1) {
            L_WARNINGS(MSGSTR(134,
                "%s: lstat() failed - %s\n"),
                s, strerror(errno));
        goto exit;
    }
    /*
     */
    if (!S_ISLNK(stbuf.st_mode)) {
        /*
         * Path is not a linked file so must be
         * a physical path
         */
        if (S_ISCHR(stbuf.st_mode) || S_ISDIR(stbuf.st_mode)) {
            /* Make sure a full path as that is required. */
            if (strstr(s, "/devices")) {
                result = g_alloc_string(s);
            } else {
                if (getcwd(savedir,
                    sizeof (savedir)) == NULL) {
                    return (NULL);
                }
                /*
                 * Check for this format:
                 * ./ssd@0,1:g,raw
                 */
                if (s[0] == '.') {
                    strcat(savedir, &s[1]);
                } else {
                    strcat(savedir, "/");
                    strcat(savedir, s);
                }
                result = g_alloc_string(savedir);
            }
        }
    } else {
        /*
         * Entry is linked file
         * so follow link to physical name
         */
        result = g_get_physical_name_from_link(path);
    }

exit:
    return (result);
}

/*
 *  Function to open a device
 */
int
g_object_open(char *path, int flag)
{
int fd = -1, retry = 0;
    if (getenv("_LUX_O_DEBUG") != NULL) {
        (void) printf("  Object_open:%s ", path);
        if (flag & O_WRONLY) {
            (void) printf("O_WRONLY,");
        } else if (flag & O_RDWR) {
            (void) printf("O_RDWR,");
        } else {
            (void) printf("O_RDONLY,");
        }
        if (flag & O_NDELAY) {
            (void) printf("O_NDELAY,");
        }
        if (flag & O_APPEND) {
            (void) printf("O_APPEND,");
        }
        if (flag & O_DSYNC) {
            (void) printf("O_DSYNC,");
        }
        if (flag & O_RSYNC) {
            (void) printf("O_RSYNC,");
        }
        if (flag & O_SYNC) {
            (void) printf("O_SYNC,");
        }
        if (flag & O_NOCTTY) {
            (void) printf("O_NOCTTY,");
        }
        if (flag & O_CREAT) {
            (void) printf("O_CREAT,");
        }
        if (flag & O_EXCL) {
            (void) printf("O_EXCL,");
        }
        if (flag & O_TRUNC) {
            (void) printf("O_TRUNC,");
        }
        (void) printf("\n");
    }

    /* Open retries introduced due to bugid 4473337 */
    errno   = 0;
    fd  = open(path, flag);
    while (fd < 0 && retry++ < RETRY_OBJECT_OPEN && (
            errno == EBUSY || errno == EAGAIN)) {
        O_DPRINTF("  Object_open: Retried:%d %d %s\n",
            retry, errno, path);
        (void) usleep(WAIT_OBJECT_OPEN);
        fd = open(path, flag);
    }
    if (fd < 0) {
        O_DPRINTF("  Object_open: Open failed:%s\n", path);
    }
    return (fd);
}


/*
 * Return a pointer to a string telling us the name of the command.
 */
char *
g_scsi_find_command_name(int cmd)
{
/*
 * Names of commands.  Must have SCMD_UNKNOWN at end of list.
 */
struct scsi_command_name {
    int command;
    char    *name;
} scsi_command_names[29];

register struct scsi_command_name *c;

    scsi_command_names[0].command = SCMD_TEST_UNIT_READY;
    scsi_command_names[0].name = MSGSTR(61, "Test Unit Ready");

    scsi_command_names[1].command = SCMD_FORMAT;
    scsi_command_names[1].name = MSGSTR(110, "Format");

    scsi_command_names[2].command = SCMD_REASSIGN_BLOCK;
    scsi_command_names[2].name = MSGSTR(77, "Reassign Block");

    scsi_command_names[3].command = SCMD_READ;
    scsi_command_names[3].name = MSGSTR(27, "Read");

    scsi_command_names[4].command = SCMD_WRITE;
    scsi_command_names[4].name = MSGSTR(54, "Write");

    scsi_command_names[5].command = SCMD_READ_G1;
    scsi_command_names[5].name = MSGSTR(79, "Read(10 Byte)");

    scsi_command_names[6].command = SCMD_WRITE_G1;
    scsi_command_names[6].name = MSGSTR(51, "Write(10 Byte)");

    scsi_command_names[7].command = SCMD_MODE_SELECT;
    scsi_command_names[7].name = MSGSTR(97, "Mode Select");

    scsi_command_names[8].command = SCMD_MODE_SENSE;
    scsi_command_names[8].name = MSGSTR(95, "Mode Sense");

    scsi_command_names[9].command = SCMD_REASSIGN_BLOCK;
    scsi_command_names[9].name = MSGSTR(77, "Reassign Block");

    scsi_command_names[10].command = SCMD_REQUEST_SENSE;
    scsi_command_names[10].name = MSGSTR(74, "Request Sense");

    scsi_command_names[11].command = SCMD_READ_DEFECT_LIST;
    scsi_command_names[11].name = MSGSTR(80, "Read Defect List");

    scsi_command_names[12].command = SCMD_INQUIRY;
    scsi_command_names[12].name = MSGSTR(102, "Inquiry");

    scsi_command_names[13].command = SCMD_WRITE_BUFFER;
    scsi_command_names[13].name = MSGSTR(53, "Write Buffer");

    scsi_command_names[14].command = SCMD_READ_BUFFER;
    scsi_command_names[14].name = MSGSTR(82, "Read Buffer");

    scsi_command_names[15].command = SCMD_START_STOP;
    scsi_command_names[15].name = MSGSTR(67, "Start/Stop");

    scsi_command_names[16].command = SCMD_RESERVE;
    scsi_command_names[16].name = MSGSTR(72, "Reserve");

    scsi_command_names[17].command = SCMD_RELEASE;
    scsi_command_names[17].name = MSGSTR(75, "Release");

    scsi_command_names[18].command = SCMD_MODE_SENSE_G1;
    scsi_command_names[18].name = MSGSTR(94, "Mode Sense(10 Byte)");

    scsi_command_names[19].command = SCMD_MODE_SELECT_G1;
    scsi_command_names[19].name = MSGSTR(96, "Mode Select(10 Byte)");

    scsi_command_names[20].command = SCMD_READ_CAPACITY;
    scsi_command_names[20].name = MSGSTR(81, "Read Capacity");

    scsi_command_names[21].command = SCMD_SYNC_CACHE;
    scsi_command_names[21].name = MSGSTR(64, "Synchronize Cache");

    scsi_command_names[22].command = SCMD_READ_DEFECT_LIST;
    scsi_command_names[22].name = MSGSTR(80, "Read Defect List");

    scsi_command_names[23].command = SCMD_GDIAG;
    scsi_command_names[23].name = MSGSTR(108, "Get Diagnostic");

    scsi_command_names[24].command = SCMD_SDIAG;
    scsi_command_names[24].name = MSGSTR(69, "Set Diagnostic");

    scsi_command_names[25].command = SCMD_PERS_RESERV_IN;
    scsi_command_names[25].name = MSGSTR(10500, "Persistent Reserve In");

    scsi_command_names[26].command = SCMD_PERS_RESERV_OUT;
    scsi_command_names[26].name = MSGSTR(10501, "Persistent Reserve out");

    scsi_command_names[27].command = SCMD_LOG_SENSE;
    scsi_command_names[27].name = MSGSTR(10502, "Log Sense");

    scsi_command_names[28].command = SCMD_UNKNOWN;
    scsi_command_names[28].name = MSGSTR(25, "Unknown");


    for (c = scsi_command_names; c->command != SCMD_UNKNOWN; c++)
        if (c->command == cmd)
            break;
    return (c->name);
}


/*
 *  Function to create error message containing
 *  scsi request sense information
 */

void
g_scsi_printerr(struct uscsi_cmd *ucmd, struct scsi_extended_sense *rq,
        int rqlen, char msg_string[], char *err_string)
{
    int     blkno;

    switch (rq->es_key) {
    case KEY_NO_SENSE:
        (void) sprintf(msg_string, MSGSTR(91, "No sense error"));
        break;
    case KEY_RECOVERABLE_ERROR:
        (void) sprintf(msg_string, MSGSTR(76, "Recoverable error"));
        break;
    case KEY_NOT_READY:
        (void) sprintf(msg_string,
            MSGSTR(10503,
            "Device Not ready."
            " Error: Random Retry Failed: %s\n."),
            err_string);
        break;
    case KEY_MEDIUM_ERROR:
        (void) sprintf(msg_string, MSGSTR(99, "Medium error"));
        break;
    case KEY_HARDWARE_ERROR:
        (void) sprintf(msg_string, MSGSTR(106, "Hardware error"));
        break;
    case KEY_ILLEGAL_REQUEST:
        (void) sprintf(msg_string, MSGSTR(103, "Illegal request"));
        break;
    case KEY_UNIT_ATTENTION:
        (void) sprintf(msg_string,
            MSGSTR(10504,
            "Unit attention."
            "Error: Random Retry Failed.\n"));
        break;
    case KEY_WRITE_PROTECT:
        (void) sprintf(msg_string, MSGSTR(52, "Write protect error"));
        break;
    case KEY_BLANK_CHECK:
        (void) sprintf(msg_string, MSGSTR(131, "Blank check error"));
        break;
    case KEY_VENDOR_UNIQUE:
        (void) sprintf(msg_string, MSGSTR(58, "Vendor unique error"));
        break;
    case KEY_COPY_ABORTED:
        (void) sprintf(msg_string, MSGSTR(123, "Copy aborted error"));
        break;
    case KEY_ABORTED_COMMAND:
        (void) sprintf(msg_string,
            MSGSTR(10505,
            "Aborted command."
            " Error: Random Retry Failed.\n"));
        break;
    case KEY_EQUAL:
        (void) sprintf(msg_string, MSGSTR(117, "Equal error"));
        break;
    case KEY_VOLUME_OVERFLOW:
        (void) sprintf(msg_string, MSGSTR(57, "Volume overflow"));
        break;
    case KEY_MISCOMPARE:
        (void) sprintf(msg_string, MSGSTR(98, "Miscompare error"));
        break;
    case KEY_RESERVED:
        (void) sprintf(msg_string, MSGSTR(10506,
            "Reserved value found"));
        break;
    default:
        (void) sprintf(msg_string, MSGSTR(59, "Unknown error"));
        break;
    }

    (void) sprintf(&msg_string[strlen(msg_string)],
        MSGSTR(10507, " during: %s"),
        g_scsi_find_command_name(ucmd->uscsi_cdb[0]));

    if (rq->es_valid) {
        blkno = (rq->es_info_1 << 24) | (rq->es_info_2 << 16) |
            (rq->es_info_3 << 8) | rq->es_info_4;
        (void) sprintf(&msg_string[strlen(msg_string)],
            MSGSTR(49, ": block %d (0x%x)"), blkno, blkno);
    }

    (void) sprintf(&msg_string[strlen(msg_string)], "\n");

    if (rq->es_add_len >= 6) {
        (void) sprintf(&msg_string[strlen(msg_string)],
        MSGSTR(132, "  Additional sense: 0x%x   ASC Qualifier: 0x%x\n"),
            rq->es_add_code, rq->es_qual_code);
            /*
             * rq->es_add_info[ADD_SENSE_CODE],
             * rq->es_add_info[ADD_SENSE_QUAL_CODE]);
             */
    }
    if (rq->es_key == KEY_ILLEGAL_REQUEST) {
        string_dump(MSGSTR(47, " cmd:   "), (uchar_t *)ucmd,
            sizeof (struct uscsi_cmd), HEX_ONLY, msg_string);
        string_dump(MSGSTR(48, " cdb:   "),
            (uchar_t *)ucmd->uscsi_cdb,
            ucmd->uscsi_cdblen, HEX_ONLY, msg_string);
    }
    string_dump(MSGSTR(43, " sense:  "),
        (uchar_t *)rq, 8 + rq->es_add_len, HEX_ONLY,
        msg_string);
    rqlen = rqlen;  /* not used */
}


/*
 *      Special string dump for error message
 */
static  void
string_dump(char *hdr, uchar_t *src, int nbytes, int format, char msg_string[])
{
    int i;
    int n;
    char    *p;
    char    s[256];

    assert(format == HEX_ONLY || format == HEX_ASCII);

    (void) strcpy(s, hdr);
    for (p = s; *p; p++) {
        *p = ' ';
    }

    p = hdr;
    while (nbytes > 0) {
        (void) sprintf(&msg_string[strlen(msg_string)],
            "%s", p);
        p = s;
        n = min(nbytes, BYTES_PER_LINE);
        for (i = 0; i < n; i++) {
            (void) sprintf(&msg_string[strlen(msg_string)],
                "%02x ",
                src[i] & 0xff);
        }
        if (format == HEX_ASCII) {
            for (i = BYTES_PER_LINE-n; i > 0; i--) {
                (void) sprintf(&msg_string[strlen(msg_string)],
                    "   ");
            }
            (void) sprintf(&msg_string[strlen(msg_string)],
                "    ");
            for (i = 0; i < n; i++) {
                (void) sprintf(&msg_string[strlen(msg_string)],
                    "%c",
                    isprint(src[i]) ? src[i] : '.');
            }
        }
        (void) sprintf(&msg_string[strlen(msg_string)], "\n");
        nbytes -= n;
        src += n;
    }
}


/*
 * This routine is a wrapper for malloc.  It allocates pre-zeroed space,
 * and checks the return value so the caller doesn't have to.
 */
void *
g_zalloc(int count)
{
    void    *ptr;

    ptr = (void *) calloc(1, (unsigned)count);
    A_DPRINTF("  g_zalloc: Allocated 0x%x bytes "
            "at 0x%x\n", count, ptr);

    return (ptr);
}

/*
 * Open up the i18n catalog.
 * Returns:
 *  0 = O.K.
 * -1 = Failed (Will revert to default strings)
 */
int
g_i18n_catopen(void)
{
    static int fileopen = 0;
    static mutex_t mp;

    if (setlocale(LC_ALL, "") == NULL) {
        (void) fprintf(stderr,
        "Cannot operate in the locale requested. "
        "Continuing in the default C locale\n");
    }
    if (mutex_lock(&mp) != 0) {
        return (-1);
    }
    if (!fileopen) {
        l_catd = catopen("a5k_g_fc_i18n_cat", NL_CAT_LOCALE);
        if (l_catd == (nl_catd)-1) {
            (void) mutex_unlock(&mp);
            return (-1);
        }
        fileopen = 1;
    }
    (void) mutex_unlock(&mp);
    return (0);
}

/* Macro used by g_get_path_type() */
#define GetMatch(s_ptr) \
    for (found = 0, search_arr_ptr = s_ptr; \
        search_arr_ptr->string != NULL; \
            search_arr_ptr++) {\
        if (strstr(path_ptr, search_arr_ptr->string) != NULL) {\
            found = 1;\
            break;\
        }\
    }

/*
 * Input  : A NULL terminated string
 *          This string is checked to be an absolute device path
 * Output :
 *  The FCA type and Xport type if found in the path on success
 *  0 on Failure
 *
 * Examples of valid device strings :
 *
 * Non Fabric FC driver :
 * /devices/io-unit@f,e0200000/sbi@0,0/SUNW,socal@1,0/sf@1,0:ctlr
 * /devices/io-unit@f,e2200000/sbi@0,0/SUNW,socal@3,0/sf@0,0/ssd@20,0:c,raw
 * /devices/sbus@1f,0/SUNW,socal@0,0/sf@0,0:devctl
 * /devices/sbus@1f,0/SUNW,socal@2,0/sf@1,0/ssd@w2200002037110cbf,0:b,raw
 * /devices/pci@1f,4000/SUNW,ifp@4:devctl
 * /devices/pci@1f,4000/SUNW,ifp@2/ssd@w2100002037049ba0,0:c,raw
 * /devices/pci@6,4000/pci@2/SUNW,ifp@5/ssd@w210000203708b44f,0:c,raw
 *
 * Fabric FC driver (fp) :
 *  - offical device path for Qlogic 2202 with proper FCODE
 *    as of 12/99.
 * /devices/pci@1f,2000/pci@1/SUNW,qlc@5/fp@0,0:devctl
 * /devices/pci@e,2000/pci@2/SUNW,qlc@4/fp@0,0:devctl
 *
 */
uint_t
g_get_path_type(char *path)
{
    uint_t path_type = 0;
    int i = 0, pathcnt = 1;
    char *path_ptr = path;
    struct str_type *search_arr_ptr; /* updated by GetMatch macro */
    char found;          /* Updated by GetMatch marco */
    char        drvr_path1[MAXPATHLEN];
    mp_pathlist_t   pathlist;
    int     p_on = 0, p_st = 0;

    /* Path passed must be an absolute device path */
    if (strncmp(path_ptr, DEV_PREFIX, DEV_PREFIX_LEN) ||
                (strlen(path_ptr) == DEV_PREFIX_LEN)) {
        return (0); /* Invalid path */
    }

    /* if mpxio device, need to convert from vhci to phci */
    if (strstr(path, SCSI_VHCI)) {
        (void) strcpy(drvr_path1, path);
        if (g_get_pathlist(drvr_path1, &pathlist)) {
            return (0);
        }
        pathcnt = pathlist.path_count;
        p_on = p_st = 0;
        for (i = 0; i < pathcnt; i++) {
            if (pathlist.path_info[i].path_state < MAXPATHSTATE) {
                if (pathlist.path_info[i].path_state ==
                    MDI_PATHINFO_STATE_ONLINE) {
                    p_on = i;
                    break;
                } else if (pathlist.path_info[i].path_state ==
                    MDI_PATHINFO_STATE_STANDBY) {
                    p_st = i;
                }
            }
        }
        if (pathlist.path_info[p_on].path_state ==
            MDI_PATHINFO_STATE_ONLINE) {
            /* on_line path */
            (void) strcpy(drvr_path1,
                pathlist.path_info[p_on].path_hba);
        } else {
            /* standby or path0 */
            (void) strcpy(drvr_path1,
                pathlist.path_info[p_st].path_hba);
        }
        free(pathlist.path_info);
        path_ptr = drvr_path1;
    }

    GetMatch(ValidBusStrings);
    if (found == 0) {
        /* No valid bus string - so not a valid path */
        return (0);
    }

    GetMatch(ValidFCAstrings);  /* Check for a valid FCA string */
    if (found != 0) {
        path_type |= search_arr_ptr->type;
    }

    /*
     * continue to check xport even without valid FCA string.
     * This is to support 3rd party FCA vendor on Leadville stack.
     */
    GetMatch(ValidXportStrings);    /* Check for a valid transport str */
    if (found == 0) {
        return (path_type);
    } else {
        /*
         * if leadville tranport is detected and fca is not set yet,
         * set fca flag to generic FC_FCA_MASK.
         */
        if ((search_arr_ptr->type == FC_GEN_XPORT) &&
            (!(path_type & FC_FCA_MASK))) {
            path_type |= FC_FCA_MASK;
        }
    }
    path_type |= search_arr_ptr->type;

    /*
     * A quick sanity check to make sure that we dont have
     * a combination that is not possible
     */
    if (((path_type & (FC4_FCA_MASK | FC_XPORT_MASK)) ==
            path_type) ||
        ((path_type & (FC_FCA_MASK | FC4_XPORT_MASK)) ==
            path_type)) {
        path_type = 0;
    }

    return (path_type);
}


/*
 * g_get_port_path(char *, portlist_t *)
 * Purpose: Find all port nexus paths for a particular driver
 * Input:   portdrvr
 *      set to name of driver for which to find the paths
 * Output:  portlist
 *      allocated structure to hold paths found
 *      user must call g_free_portlist(portlist_t *) to
 *      free allocated memory
 */
int
g_get_port_path(char *portdrvr, portlist_t *portlist)
{
    di_node_t root;
    di_node_t node;
    di_minor_t minor_node;
    char hbapathfound[MAXPATHLEN];
    char *tmppath;
    struct stat buf;

    /* return invalid argument if *portdrvr or *portlist is NULL */
    if ((portdrvr == NULL) || (portlist == NULL)) {
        return (L_INVALID_ARG);
    }

    /* Create a snapshot of the kernel device tree */
    root = di_init("/", DINFOCPYALL);
    if (root == DI_NODE_NIL) {
        return (L_DEV_SNAPSHOT_FAILED);
    }

    /* point to first node which matches portdrvr */
    node = di_drv_first_node(portdrvr, root);
    if (node == DI_NODE_NIL) {
        /*
         * Could not find driver node
         */
        (void) di_fini(root);
        if (errno == EINVAL)
            return (L_PORT_DRIVER_NOT_FOUND);
        else
            return (L_PHYS_PATH_NOT_FOUND);
    }

    while (node) {
        /* point to first minor node which matches node */
        minor_node = di_minor_next(node, DI_MINOR_NIL);

        /* if we have a minor node use it */
        while (minor_node) {
            /*
             * Is this a devctl or pseudo node?
             * If not, skip it.
             * Soc+ HBA port device paths such as:
             *  /devices/sbus@2,0/SUNW,socal@d,10000:0
             * are pseudo nodes as of S9 so we need to
             * include those as well.
             */
            if (di_minor_nodetype(minor_node) &&
                (strcmp(di_minor_nodetype(minor_node),
                    DDI_NT_NEXUS) &&
                strcmp(di_minor_nodetype(minor_node),
                    DDI_PSEUDO))) {
                minor_node = di_minor_next(node, minor_node);
                continue;
            }
            /*
             * Prepend '/devices' to path
             * Note: The path returned from di_devfs_path
             * does NOT begin with '/devices'.
             * '/devices' is considered a mount point
             */
            strcpy(hbapathfound, "/devices");
            tmppath = di_devfs_path(node);
            strcat(hbapathfound, tmppath);
            (void) free(tmppath);
            strcat(hbapathfound, ":");
            strcat(hbapathfound, di_minor_name(minor_node));
            /*
             * Verify that the path is validly constructed
             */
            if ((stat(hbapathfound, (struct stat *)&buf)) < 0) {
                (void) di_fini(root);
                return (L_STAT_ERROR);
            }
            /* allocate memory and copy constructed path */
            if ((portlist->hbacnt > MAX_HBA_PORT - 1) ||
                ((portlist->physpath[portlist->hbacnt] =
                (char *)malloc(MAXPATHLEN)) == NULL)) {
                (void) di_fini(root);
                return (L_MALLOC_FAILED);
            }
            strcpy(portlist->physpath[portlist->hbacnt],
                hbapathfound);
            portlist->hbacnt++;
            minor_node = di_minor_next(node, minor_node);
        }
        node = di_drv_next_node(node);
    }
    /*
     * Destroy the snapshot and return
     */
    (void) di_fini(root);
    return (0);
}

/*
 * Free the allocated portlist structure
 */
void
g_free_portlist(portlist_t *portlist)
{
    int x = 0;

    /* return if portlist is NULL */
    if (portlist == NULL) {
        return;
    }

    for (x = 0; x < portlist->hbacnt; x++) {
        if (portlist->physpath[x] != NULL) {
            free(portlist->physpath[x]);
        }
    }
}

/*
 * Check VID/PID against enclosure disk table
 */
boolean_t
g_enclDiskChk(char *vid, char *pid)
{
    int i;
    for (i = 0; enclDiskTbl[i].vid; i++) {
        if ((strncmp(vid, enclDiskTbl[i].vid,
            strlen(enclDiskTbl[i].vid)) == 0) &&
            (strncmp(pid, enclDiskTbl[i].pid,
            strlen(enclDiskTbl[i].pid)) == 0)) {
            return (B_TRUE);
        }
    }
    return (B_FALSE);
}