liba5k/common/diag.c

	diag.c revision fcf3ce441efd61da9bb2884968af01cb7c1452cc
/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*LINTLIBRARY*/


/*
 *  This module is part of the photon library
 */

/*
 * I18N message number ranges
 *  This file: 8000 - 8499
 *  Shared common messages: 1 - 1999
 */

/*  Includes    */
#include    <stdlib.h>
#include    <stdio.h>
#include    <sys/file.h>
#include    <sys/types.h>
#include    <sys/param.h>
#include    <fcntl.h>
#include    <unistd.h>
#include    <errno.h>
#include    <string.h>
#include    <sys/scsi/scsi.h>
#include    <nl_types.h>
#include    <strings.h>
#include    <sys/ddi.h> /* for max */
#include    <l_common.h>
#include    <stgcom.h>
#include    <l_error.h>
#include    <a_state.h>
#include    <a5k.h>


/*  Defines     */
#define VERBPRINT   if (verbose) (void) printf


/*
 * take all paths supplied by dl offline.
 *
 * RETURNS:
 *  0 = No error.
 *  *bsy_res_flag_p: 1 = The device is "busy".
 *
 * In pre-2.6 we just return success
 */
static int
d_offline_drive(struct dlist *dl, int *bsy_res_flag_p, int verbose)
{
char            dev_path1[MAXPATHLEN];
devctl_hdl_t        devhdl;


    /* for each path attempt to take it offline */
    for (; dl != NULL; dl = dl->next) {

        /* save a copy of the pathname */
        (void) strcpy(dev_path1, dl->dev_path);

        /* attempt to acquire the device */
        if ((devhdl = devctl_device_acquire(dev_path1,
            DC_EXCL)) == NULL) {
            if (errno != EBUSY) {
                return (L_ACQUIRE_FAIL);
            }
        }

        /* attempt to offline the drive */
        if (devctl_device_offline(devhdl) != 0) {
            *bsy_res_flag_p = 1;
            (void) devctl_release(devhdl);
            return (0);
        }

        E_DPRINTF("  d_offline_drive: Offline succeeded:/n    "
            "%s\n", dev_path1);
        /* offline succeeded -- release handle acquired above */
        (void) devctl_release(devhdl);
    }
    return (0);
}


/*
 * Check to see if any of the disks that are attached
 * to the selected port on this backplane are reserved or busy.
 *
 * INPUTS:
 * RETURNS:
 *  0 = No error.
 *  *bsy_res_flag_p: 1 = The device is "busy".
 */

int
l_check_busy_reserv_bp(char *ses_path, int front_flag,
    int port_a_flag, int *bsy_res_flag_p, int verbose)
{
int err, i;
L_state     *l_state = NULL;
struct dlist    *p_list;

    if ((l_state = (L_state *)calloc(1, sizeof (L_state))) == NULL) {
        return (L_MALLOC_FAILED);
    }

    if (err = l_get_status(ses_path, l_state, verbose)) {
        (void) l_free_lstate(&l_state);
        return (err);
    }
    for (i = 0; i < (int)l_state->total_num_drv/2; i++) {
        if ((front_flag &&
    (l_state->drv_front[i].g_disk_state.d_state_flags[port_a_flag] &
            L_RESERVED)) || (!front_flag &&
    (l_state->drv_rear[i].g_disk_state.d_state_flags[port_a_flag] &
            L_RESERVED))) {
            *bsy_res_flag_p = 1;
            (void) l_free_lstate(&l_state);
            return (0);
        }
    }

    for (i = 0; i < (int)l_state->total_num_drv/2; i++) {
        /* Get list of all paths to the requested port. */
        if (front_flag) {
            if (port_a_flag) {
                if ((err = g_get_port_multipath(
                l_state->drv_front[i].g_disk_state.port_a_wwn_s,
                    &p_list, verbose)) != 0) {
                    (void) l_free_lstate(&l_state);
                    return (err);
                }
            } else {
                if ((err = g_get_port_multipath(
                l_state->drv_front[i].g_disk_state.port_b_wwn_s,
                    &p_list, verbose)) != 0) {
                    (void) l_free_lstate(&l_state);
                    return (err);
                }
            }
        } else {
            if (port_a_flag) {
                if ((err = g_get_port_multipath(
                l_state->drv_rear[i].g_disk_state.port_a_wwn_s,
                    &p_list, verbose)) != 0) {
                    (void) l_free_lstate(&l_state);
                    return (err);
                }
            } else {
                if ((err = g_get_port_multipath(
                l_state->drv_rear[i].g_disk_state.port_b_wwn_s,
                    &p_list, verbose)) != 0) {
                    (void) l_free_lstate(&l_state);
                    return (err);
                }
            }
        }
        if (err = d_offline_drive(p_list,
            bsy_res_flag_p, verbose)) {
            (void) g_free_multipath(p_list);
            (void) l_free_lstate(&l_state);
            return (err);
        }
        (void) g_free_multipath(p_list);
    }
    (void) l_free_lstate(&l_state);
    return (0);
}


/*
 * Request the enclosure services controller (IB)
 * to set the LRC (Loop Redundancy Circuit) to the
 * bypassed/enabled state for the backplane specified by
 * the a and f flag and the enclosure or pathname.
 */
int
l_bp_bypass_enable(char *ses_path, int bypass_flag, int port_a_flag,
    int front_flag, int force_flag, int verbose)
{

int     fd, i;
int     nobj = 0;
ses_objarg  obj;
ses_object  *all_objp = NULL, *all_objp_save = NULL;
int     found = 0;
Bp_elem_st  *bp;
char        msg[MAXPATHLEN];
int     bsy_res_flag = 0;
int     err;

    if (ses_path == NULL) {
        return (L_NO_SES_PATH);
    }

    /*
     * Check for reservation and busy for all disks on this
     * backplane.
     */

    if (!force_flag && bypass_flag) {
        if (err = l_check_busy_reserv_bp(ses_path,
            front_flag, port_a_flag, &bsy_res_flag, verbose)) {
            return (err);
        }
        if (bsy_res_flag) {
                return (L_BP_BUSY_RESERVED);
        }
    }


    if ((fd = g_object_open(ses_path, O_NDELAY | O_RDWR)) == -1) {
        return (errno);
    }

    if (ioctl(fd, SESIOC_GETNOBJ, (caddr_t)&nobj) < 0) {
        (void) close(fd);
        return (errno);
    }
    if (nobj == 0) {
        (void) close(fd);
        return (L_IB_NO_ELEM_FOUND);
    }

    E_DPRINTF("  l_ib_bypass_bp: Number of SES objects: 0x%x\n",
        nobj);

    /* alloc some memory for the objmap */
    if ((all_objp = g_zalloc((nobj + 1) * sizeof (ses_object))) == NULL) {
        (void) close(fd);
        return (errno);
    }

    all_objp_save = all_objp;

    if (ioctl(fd, SESIOC_GETOBJMAP, (caddr_t)all_objp) < 0) {
        (void) close(fd);
        (void) g_destroy_data(all_objp_save);
        return (errno);
    }

    for (i = 0; i < nobj; i++, all_objp++) {
            E_DPRINTF("  ID 0x%x\t Element type 0x%x\n",
            all_objp->obj_id, all_objp->elem_type);
        if (all_objp->elem_type == ELM_TYP_BP) {
            found++;
            break;
        }
    }

    if (found == 0) {
        (void) close(fd);
        (void) g_destroy_data(all_objp_save);
        return (L_NO_BP_ELEM_FOUND);
    }

    /*
     * We found the backplane element.
     */


    if (verbose) {
        /* Get the status for backplane #0 */
        obj.obj_id = all_objp->obj_id;
        if (ioctl(fd, SESIOC_GETOBJSTAT, (caddr_t)&obj) < 0) {
            (void) close(fd);
            (void) g_destroy_data(all_objp_save);
            return (errno);
        }
        (void) fprintf(stdout, MSGSTR(8000,
            "  Front backplane status: "));
        bp = (struct  bp_element_status *)&obj.cstat[0];
        l_element_msg_string(bp->code, msg);
        (void) fprintf(stdout, "%s\n", msg);
        if (bp->byp_a_enabled || bp->en_bypass_a) {
            (void) fprintf(stdout, "    ");
            (void) fprintf(stdout,
            MSGSTR(130, "Bypass A enabled"));
            (void) fprintf(stdout, ".\n");
        }
        if (bp->byp_b_enabled || bp->en_bypass_b) {
            (void) fprintf(stdout, "    ");
            (void) fprintf(stdout,
            MSGSTR(129, "Bypass B enabled"));
            (void) fprintf(stdout, ".\n");
        }

        all_objp++;
        obj.obj_id = all_objp->obj_id;
        all_objp--;
        if (ioctl(fd, SESIOC_GETOBJSTAT, (caddr_t)&obj) < 0) {
            (void) close(fd);
            (void) g_destroy_data(all_objp_save);
            return (errno);
        }
        (void) fprintf(stdout, MSGSTR(8001,
            "  Rear backplane status: "));
        bp = (struct  bp_element_status *)&obj.cstat[0];
        l_element_msg_string(bp->code, msg);
        (void) fprintf(stdout, "%s\n", msg);
        if (bp->byp_a_enabled || bp->en_bypass_a) {
            (void) fprintf(stdout, "    ");
            (void) fprintf(stdout,
            MSGSTR(130, "Bypass A enabled"));
            (void) fprintf(stdout, ".\n");
        }
        if (bp->byp_b_enabled || bp->en_bypass_b) {
            (void) fprintf(stdout, "    ");
            (void) fprintf(stdout,
            MSGSTR(129, "Bypass B enabled"));
            (void) fprintf(stdout, ".\n");
        }
    }

    /* Get the current status */
    if (!front_flag) {
        all_objp++;
    }
    obj.obj_id = all_objp->obj_id;
    if (ioctl(fd, SESIOC_GETOBJSTAT, (caddr_t)&obj) < 0) {
        (void) close(fd);
        (void) g_destroy_data(all_objp_save);
        return (errno);
    }
    /* Do the requested action. */
    bp = (struct  bp_element_status *)&obj.cstat[0];
    bp->select = 1;
    bp->code = 0;
    if (port_a_flag) {
        bp->en_bypass_a = bypass_flag;
    } else {
        bp->en_bypass_b = bypass_flag;
    }
    if (getenv("_LUX_E_DEBUG") != NULL) {
        (void) printf("  Sending this structure to ID 0x%x"
            " of type 0x%x\n",
            obj.obj_id, all_objp->elem_type);
        for (i = 0; i < 4; i++) {
            (void) printf("    Byte %d  0x%x\n", i,
            obj.cstat[i]);
        }
    }

    if (ioctl(fd, SESIOC_SETOBJSTAT, (caddr_t)&obj) < 0) {
        (void) close(fd);
        (void) g_destroy_data(all_objp_save);
        return (errno);
    }

    (void) g_destroy_data(all_objp_save);
    (void) close(fd);

    return (0);
}


/*
 * This function will request the enclosure services
 * controller (IB) to set the LRC (Loop Redundancy Circuit) to the
 * bypassed/enabled state for the device specified by the
 * enclosure,dev or pathname and the port specified by the a
 * flag.
 */

int
l_dev_bypass_enable(struct path_struct *path_struct, int bypass_flag,
    int force_flag, int port_a_flag, int verbose)
{
gfc_map_t       map;
char            ses_path[MAXPATHLEN];
uchar_t         *page_buf;
int             err, fd, front_index, rear_index, offset;
int         pathcnt = 1;
unsigned short      page_len;
struct  device_element  *elem;
L_state         *l_state = NULL;
struct device_element   status;
int         bsy_flag = 0, i, f_flag;
struct dlist        *p_list;
char            temppath[MAXPATHLEN];
mp_pathlist_t       pathlist;
int         p_pw = 0, p_on = 0, p_st = 0;
L_inquiry       inq;

    if (path_struct == NULL) {
        return (L_INVALID_PATH_FORMAT);
    }

    if ((l_state = (L_state *)calloc(1, sizeof (L_state))) == NULL) {
        return (L_MALLOC_FAILED);
    }
    map.dev_addr = (gfc_port_dev_info_t *)NULL;
    (void) strcpy(temppath, path_struct->p_physical_path);
    if ((strstr(path_struct->p_physical_path, SCSI_VHCI) != NULL) &&
        (!g_get_pathlist(temppath, &pathlist))) {
            pathcnt = pathlist.path_count;
            p_pw = p_on = p_st = 0;
            for (i = 0; i < pathcnt; i++) {
                if (pathlist.path_info[i].path_state <
                    MAXPATHSTATE) {
                    if (strstr(pathlist.path_info[i].
                        path_addr,
                        path_struct->argv) != NULL) {
                        p_pw = i;
                        break;
                    }
                    if (pathlist.path_info[i].path_state ==
                        MDI_PATHINFO_STATE_ONLINE) {
                        p_on = i;
                    }
                    if (pathlist.path_info[i].path_state ==
                        MDI_PATHINFO_STATE_STANDBY) {
                        p_st = i;
                    }
                }
            }
            if (strstr(pathlist.path_info[p_pw].path_addr,
                path_struct->argv) != NULL) {
                /* matching input pwwn */
                (void) strcpy(temppath,
                    pathlist.path_info[p_pw].path_hba);
            } else if (pathlist.path_info[p_on].path_state ==
                MDI_PATHINFO_STATE_ONLINE) {
                /* on_line path */
                (void) strcpy(temppath,
                    pathlist.path_info[p_on].path_hba);
            } else {
                /* standby or path0 */
                (void) strcpy(temppath,
                    pathlist.path_info[p_st].path_hba);
            }
            free(pathlist.path_info);
            (void) strcat(temppath, FC_CTLR);
    }

    /*
     * Need to get a valid location, front/rear & slot.
     *
     * The path_struct will return a valid slot
     * and the IB path or a disk path.
     */

    if (!path_struct->ib_path_flag) {
        if (err = g_get_dev_map(temppath, &map, verbose)) {
            (void) l_free_lstate(&l_state);
            return (err);
        }
        if (err = l_get_ses_path(path_struct->p_physical_path,
            ses_path, &map, verbose)) {
            (void) l_free_lstate(&l_state);
            free((void *)map.dev_addr);
            return (err);
        }
    } else {
        (void) strcpy(ses_path, path_struct->p_physical_path);
    }
    if (!path_struct->slot_valid) {
        if ((map.dev_addr == (gfc_port_dev_info_t *)NULL) &&
            ((err = g_get_dev_map(temppath,
                        &map, verbose)) != 0)) {
            (void) l_free_lstate(&l_state);
            return (err);
        }
        if ((err = l_get_ses_path(path_struct->p_physical_path,
            ses_path, &map, verbose)) != 0) {
            (void) l_free_lstate(&l_state);
            free((void *)map.dev_addr);
            return (err);
        }
        if ((err = l_get_status(ses_path, l_state, verbose)) != 0) {
            (void) l_free_lstate(&l_state);
            free((void *)map.dev_addr);
            return (err);
        }

        /* We are passing the disks path */
        if ((err = l_get_slot(path_struct, l_state, verbose)) != 0) {
            (void) l_free_lstate(&l_state);
            free((void *)map.dev_addr);
            return (err);
        }
    }

    if (map.dev_addr != (gfc_port_dev_info_t *)NULL) {
        free((void *)map.dev_addr);
    }

    if ((page_buf = (uchar_t *)malloc(MAX_REC_DIAG_LENGTH)) == NULL) {
        (void) l_free_lstate(&l_state);
        return (errno);
    }

    if ((fd = g_object_open(ses_path, O_NDELAY | O_RDWR)) == -1) {
        (void) g_destroy_data(page_buf);
        (void) l_free_lstate(&l_state);
        return (errno);
    }

    if (err = l_get_envsen_page(fd, page_buf, MAX_REC_DIAG_LENGTH,
                L_PAGE_2, verbose)) {
        (void) close(fd);
        (void) g_destroy_data(page_buf);
        (void) l_free_lstate(&l_state);
        return (err);
    }

    page_len = (page_buf[2] << 8 | page_buf[3]) + HEADER_LEN;

    /* Get index to the disk we are interested in */
    if (err = l_get_status(ses_path, l_state, verbose)) {
        (void) close(fd);
        (void) g_destroy_data(page_buf);
        (void) l_free_lstate(&l_state);
        return (err);
    }
    /*
     * Now that we have the status check to see if
     * busy or reserved, if bypassing.
     */
    if ((!(force_flag | path_struct->ib_path_flag)) &&
                        bypass_flag) {
        i = path_struct->slot;
        f_flag = path_struct->f_flag;

        /*
         * Check for reservation and busy
         */
        if ((f_flag &&
        (l_state->drv_front[i].g_disk_state.d_state_flags[port_a_flag] &
            L_RESERVED)) || (!f_flag &&
        (l_state->drv_rear[i].g_disk_state.d_state_flags[port_a_flag] &
            L_RESERVED))) {
            (void) close(fd);
            (void) g_destroy_data(page_buf);
            (void) l_free_lstate(&l_state);
            return (L_BP_RESERVED);
        }
        if (f_flag) {
            if (port_a_flag) {
                if ((err = g_get_port_multipath(
                l_state->drv_front[i].g_disk_state.port_a_wwn_s,
                    &p_list, verbose)) != 0) {
                    (void) close(fd);
                    (void) g_destroy_data(page_buf);
                    (void) l_free_lstate(&l_state);
                    return (err);
                }
            } else {
                if ((err = g_get_port_multipath(
                l_state->drv_front[i].g_disk_state.port_b_wwn_s,
                    &p_list, verbose)) != 0) {
                    (void) close(fd);
                    (void) g_destroy_data(page_buf);
                    (void) l_free_lstate(&l_state);
                    return (err);
                }
            }
        } else {
            if (port_a_flag) {
                if ((err = g_get_port_multipath(
                l_state->drv_rear[i].g_disk_state.port_a_wwn_s,
                    &p_list, verbose)) != 0) {
                    (void) close(fd);
                    (void) g_destroy_data(page_buf);
                    (void) l_free_lstate(&l_state);
                    return (err);
                }
            } else {
                if ((err = g_get_port_multipath(
                l_state->drv_rear[i].g_disk_state.port_b_wwn_s,
                    &p_list, verbose)) != 0) {
                    (void) close(fd);
                    (void) g_destroy_data(page_buf);
                    (void) l_free_lstate(&l_state);
                    return (err);
                }
            }
        }
        if (err = d_offline_drive(p_list,
            &bsy_flag, verbose)) {
            (void) g_free_multipath(p_list);
            (void) close(fd);
            (void) g_destroy_data(page_buf);
            (void) l_free_lstate(&l_state);
            return (err);
        }
        (void) g_free_multipath(p_list);
        if (bsy_flag) {
            (void) close(fd);
            (void) g_destroy_data(page_buf);
            (void) l_free_lstate(&l_state);
            return (L_BP_BUSY);
        }
    }

    if (err = l_get_disk_element_index(l_state, &front_index,
        &rear_index)) {
        (void) close(fd);
        (void) g_destroy_data(page_buf);
        (void) l_free_lstate(&l_state);
        return (err);
    }

    if (g_get_inquiry(ses_path, &inq)) {
        return (L_SCSI_ERROR);
    }

    /* Skip global element */
    front_index++;
    if ((strncmp((char *)&inq.inq_pid[0], DAK_OFF_NAME,
                        strlen(DAK_OFF_NAME)) == 0) ||
            (strncmp((char *)&inq.inq_pid[0], DAK_PROD_STR,
                        strlen(DAK_PROD_STR)) == 0)) {
        rear_index += (MAX_DRIVES_DAK/2) + 1;
    } else {
        rear_index++;
    }

    if (path_struct->f_flag) {
        offset = (8 + (front_index + path_struct->slot)*4);
    } else {
        offset = (8 + (rear_index + path_struct->slot)*4);
    }

    elem = (struct device_element *)(page_buf + offset);
    /*
     * now do requested action.
     */
    bcopy((const void *)elem, (void *)&status,
        sizeof (struct device_element));    /* save status */
    bzero(elem, sizeof (struct device_element));
    elem->select = 1;
    elem->dev_off = status.dev_off;
    elem->en_bypass_a = status.en_bypass_a;
    elem->en_bypass_b = status.en_bypass_b;

    /* Do requested action */
    if (port_a_flag) {
        elem->en_bypass_a = bypass_flag;
    } else {
        elem->en_bypass_b = bypass_flag;
    }

    if (getenv("_LUX_E_DEBUG") != NULL) {
        g_dump("  l_dev_bypass_enable: Updating LRC circuit state:\n"
        "    Device Status Element ",
        (uchar_t *)elem, sizeof (struct device_element),
        HEX_ONLY);
        (void) fprintf(stdout, "    for device at location:"
            " enclosure:%s slot:%d %s\n",
            l_state->ib_tbl.enclosure_name,
            path_struct->slot,
            path_struct->f_flag ? "front" : "rear");
    }
    if (err = g_scsi_send_diag_cmd(fd,
        (uchar_t *)page_buf, page_len)) {
        (void) close(fd);
        (void) g_destroy_data(page_buf);
        (void) l_free_lstate(&l_state);
        return (err);
    }

    (void) close(fd);
    (void) g_destroy_data(page_buf);
    (void) l_free_lstate(&l_state);
    return (0);
}


/*
 * Issue a Loop Port enable Primitive sequence
 * to the device specified by the pathname.
 */
int
d_p_enable(char *path, int verbose)
/*ARGSUSED*/
{

    return (0);
}

/*
 * Issue a Loop Port Bypass Primitive sequence
 * to the device specified by the pathname. This requests the
 * device to set its L_Port into the bypass mode.
 */
int
d_p_bypass(char *path, int verbose)
/*ARGSUSED*/
{

    return (0);
}