/*
 * 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.
 */


#include "FCHBANPIVPort.h"
#include <Exceptions.h>
#include <Trace.h>
#include <sun_fc.h>
#include <iostream>
#include <iomanip>
#include <sys/types.h>
#include <sys/mkdev.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stropts.h>
#include <dirent.h>
#include <sys/fibre-channel/fc.h>
#include <sys/fibre-channel/fcio.h>
#include <sys/fibre-channel/ulp/fcp_util.h>
#include <sys/fibre-channel/ulp/fcsm.h>
#include <sys/fibre-channel/impl/fc_error.h>
#include <sys/fibre-channel/fc_appif.h>
#include <sys/scsi/generic/commands.h>
#include <sys/scsi/impl/commands.h>
#include <sys/scsi/impl/sense.h>
#include <sys/scsi/generic/inquiry.h>
#include <sys/scsi/generic/status.h>
#include <errno.h>

using namespace std;

const int FCHBANPIVPort::MAX_FCIO_MSG_LEN = 256;

FCHBANPIVPort::FCHBANPIVPort(string thePath) : HBANPIVPort() {
        Trace log("FCHBANPIVPort::FCHBANPIVPort");
        log.debug("Initializing HBA NPIV port %s", thePath.c_str());

        try {
                path = lookupControllerPath(thePath);
        } catch (...) {
                log.debug("Unable to lookup controller path and number for %s",
                    thePath.c_str());
                path = "/devices";
                path += thePath;
                path += ":fc";
        }

        uint64_t tmp;
        HBA_NPIVATTRIBUTES attrs = getPortAttributes(tmp);
        memcpy(&tmp, &attrs.PortWWN, 8);
        portWWN = ntohll(tmp);
        memcpy(&tmp, &attrs.NodeWWN, 8);
        nodeWWN = ntohll(tmp);
}


HBA_NPIVATTRIBUTES FCHBANPIVPort::getPortAttributes(uint64_t &stateChange) {
        Trace log("FCHBANPIVPort::getPortAttributes");

        HBA_NPIVATTRIBUTES attributes;
        fcio_t fcio;
        fc_hba_npiv_attributes_t attrs;

        memset(&fcio, 0, sizeof (fcio));
        memset(&attributes, 0, sizeof (attributes));
        fcio.fcio_cmd = FCIO_GET_NPIV_ATTRIBUTES;
        fcio.fcio_olen = sizeof (attrs);
        fcio.fcio_xfer = FCIO_XFER_READ;
        fcio.fcio_obuf = (caddr_t)&attrs;
        fp_ioctl(getPath(), FCIO_CMD, &fcio);

        stateChange = attrs.lastChange;
        memcpy(&attributes.NodeWWN, &attrs.NodeWWN, 8);
        memcpy(&attributes.PortWWN, &attrs.PortWWN, 8);

        return (attributes);
}


void FCHBANPIVPort::fp_ioctl(string path, int cmd, fcio_t *fcio) {
        Trace log("FCHBANPIVPort::fp_ioctl");

        char fcioErrorString[MAX_FCIO_MSG_LEN] = "";
        int fd = HBA::_open(path, O_NDELAY | O_RDONLY);

        try {
                int times = 0;
                HBA::_ioctl(fd, cmd, (uchar_t *)fcio);
                while (fcio->fcio_errno == FC_STATEC_BUSY) {
                        (void) sleep(2);
                        HBA::_ioctl(fd, cmd, (uchar_t *)fcio);
                        if (times++ > 20) {
                                break;
                        }
                }
                close(fd);
                if (fcio->fcio_errno) {
                        throw IOError("IOCTL transport failure");
                }
        } catch (...) {
                close(fd);
                transportError(fcio->fcio_errno, fcioErrorString);
                log.genericIOError("NPIV Port ioctl (0x%x) failed. Transport: \"%s\"", cmd,
                    fcioErrorString);
                switch (fcio->fcio_errno) {
                case FC_BADWWN:
                        throw IllegalWWNException();
                case FC_BADPORT:
                        throw IllegalWWNException();
                case FC_OUTOFBOUNDS:
                        throw IllegalIndexException();
                case FC_PBUSY:
                case FC_FBUSY:
                case FC_TRAN_BUSY:
                case FC_STATEC_BUSY:
                case FC_DEVICE_BUSY:
                        throw BusyException();
                case FC_SUCCESS:
                default:
                        throw;
                }
        }
}


/*
 * Interpret the error code in the fcio_t structure
 *
 * message must be at least MAX_FCIO_MSG_LEN in length.
 */
void
FCHBANPIVPort::transportError(uint32_t fcio_errno, char *message) {
        Trace log("transportError");

        string fcioErrorString;
        if (message == NULL) {
                log.internalError("NULL routine argument");
                return;
        }
        switch (fcio_errno) {
        case (uint32_t)FC_FAILURE:
                fcioErrorString = "general failure";
                break;
        case (uint32_t)FC_FAILURE_SILENT:
                fcioErrorString = "general failure but fail silently";
                break;
        case FC_SUCCESS:
                fcioErrorString = "successful completion";
                break;
        case FC_CAP_ERROR:
                fcioErrorString = "FCA capability error";
                break;
        case FC_CAP_FOUND:
                fcioErrorString = "FCA capability unsettable";
                break;
        case FC_CAP_SETTABLE:
                fcioErrorString = "FCA capability settable";
                break;
        case FC_UNBOUND:
                fcioErrorString = "unbound stuff";
                break;
        case FC_NOMEM:
                fcioErrorString = "allocation error";
                break;
        case FC_BADPACKET:
                fcioErrorString = "invalid packet specified/supplied";
                break;
        case FC_OFFLINE:
                fcioErrorString = "I/O resource unavailable";
                break;
        case FC_OLDPORT:
                fcioErrorString = "operation on non-loop port";
                break;
        case FC_NO_MAP:
                fcioErrorString = "requested map unavailable";
                break;
        case FC_TRANSPORT_ERROR:
                fcioErrorString = "unable to transport I/O";
                break;
        case FC_ELS_FREJECT:
                fcioErrorString = "ELS rejected by a Fabric";
                break;
        case FC_ELS_PREJECT:
                fcioErrorString = "ELS rejected by an N_port";
                break;
        case FC_ELS_BAD:
                fcioErrorString = "ELS rejected by FCA/fctl";
                break;
        case FC_ELS_MALFORMED:
                fcioErrorString = "poorly formed ELS request";
                break;
        case FC_TOOMANY:
                fcioErrorString = "resource request too large";
                break;
        case FC_UB_BADTOKEN:
                fcioErrorString = "invalid unsolicited buffer token";
                break;
        case FC_UB_ERROR:
                fcioErrorString = "invalid unsol buf request";
                break;
        case FC_UB_BUSY:
                fcioErrorString = "buffer already in use";
                break;
        case FC_BADULP:
                fcioErrorString = "Unknown ulp";
                break;
        case FC_BADTYPE:
                fcioErrorString = "ULP not registered to handle this FC4 type";
                break;
        case FC_UNCLAIMED:
                fcioErrorString = "request or data not claimed";
                break;
        case FC_ULP_SAMEMODULE:
                fcioErrorString = "module already in use";
                break;
        case FC_ULP_SAMETYPE:
                fcioErrorString = "FC4 module already in use";
                break;
        case FC_ABORTED:
                fcioErrorString = "request aborted";
                break;
        case FC_ABORT_FAILED:
                fcioErrorString = "abort request failed";
                break;
        case FC_BADEXCHANGE:
                fcioErrorString = "exchange doesn\325t exist";
                break;
        case FC_BADWWN:
                fcioErrorString = "WWN not recognized";
                break;
        case FC_BADDEV:
                fcioErrorString = "device unrecognized";
                break;
        case FC_BADCMD:
                fcioErrorString = "invalid command issued";
                break;
        case FC_BADOBJECT:
                fcioErrorString = "invalid object requested";
                break;
        case FC_BADPORT:
                fcioErrorString = "invalid port specified";
                break;
        case FC_NOTTHISPORT:
                fcioErrorString = "resource not at this port";
                break;
        case FC_PREJECT:
                fcioErrorString = "reject at remote N_Port";
                break;
        case FC_FREJECT:
                fcioErrorString = "reject at remote Fabric";
                break;
        case FC_PBUSY:
                fcioErrorString = "remote N_Port busy";
                break;
        case FC_FBUSY:
                fcioErrorString = "remote Fabric busy";
                break;
        case FC_ALREADY:
                fcioErrorString = "already logged in";
                break;
        case FC_LOGINREQ:
                fcioErrorString = "login required";
                break;
        case FC_RESETFAIL:
                fcioErrorString = "reset failed";
                break;
        case FC_INVALID_REQUEST:
                fcioErrorString = "request is invalid";
                break;
        case FC_OUTOFBOUNDS:
                fcioErrorString = "port number is out of bounds";
                break;
        case FC_TRAN_BUSY:
                fcioErrorString = "command transport busy";
                break;
        case FC_STATEC_BUSY:
                fcioErrorString = "port driver currently busy";
                break;
        case FC_DEVICE_BUSY:
                fcioErrorString = "transport working on this device";
                break;
        case FC_DEVICE_NOT_TGT:
                fcioErrorString = "device is not a SCSI target";
                break;
        default:
                snprintf(message, MAX_FCIO_MSG_LEN, "Unknown error code 0x%x",
                    fcio_errno);
                return;
        }
        snprintf(message, MAX_FCIO_MSG_LEN, "%s", fcioErrorString.c_str());
}