dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / sun_fc / common / Handle.cc

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



#include "Handle.h"
#include "Exceptions.h"
#include "Trace.h"
#include <libdevinfo.h>
#include <iostream>
#include <iomanip>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stropts.h>

#define MAX_INIT_HANDLE_ID      0x7fff
#define MAX_TGT_HANDLE_ID       0xffff

using namespace std;

/**
 * Global lock for list of Handles
 */
pthread_mutex_t Handle::staticLock = PTHREAD_MUTEX_INITIALIZER;

/**
 * Tracking for the previous handle we have opened
 */
HBA_HANDLE Handle::prevOpen = 0;

/**
 * Tracking for the previous target HBA handle we have opened
 */
HBA_HANDLE Handle::prevTgtOpen = 0x8000;

/**
 * Global map from HBA_HANDLE to Handle pointers (our global list)
 */
map<HBA_HANDLE, Handle*> Handle::openHandles;

/**
 * @memo            Create a new open handle for a specified HBA
 * @precondition    HBA port(s) must be loaded
 * @postcondition   An open handle will be present in the global tracking list
 *                  and must be closed at some point to prevent leakage. If no
 *                  handle could be assigned (the track list is full), an
 *                  exception will be thrown. Scope for valid ids in the track
 *                  list is [1, MAX_INIT_HANDLE_ID].
 * @param           myhba The HBA to open a handle for
 */
Handle::Handle(HBA *myhba) {
        map<HBA_HANDLE, Handle*>::iterator mapend;
        Trace log("Handle::Handle");
        modeVal = INITIATOR;
        lock(&staticLock);
        mapend = openHandles.end();
        /* Start the search for a free id from the previously assigned one */
        id = prevOpen + 1;
        while (id != prevOpen) {
                /* Exceeds the max valid value, continue the search from 1 */
                if (id > MAX_INIT_HANDLE_ID)
                        id = 1;

                if (openHandles.find(id) == mapend) {
                        /* the id is not in use */
                        break;
                }
                id ++;
        }
        if (id == prevOpen) {
                /* no usable id for now */
                unlock(&staticLock);
                throw TryAgainException();
        }
        prevOpen = id;
        hba = myhba;
        openHandles[id] = this;
        unlock(&staticLock);
}

/**
 * @memo            Create a new open handle for a specified HBA
 * @precondition    HBA port(s) must be loaded
 * @postcondition   An open handle will be present in the global tracking list
 *                  and must be closed at some point to prevent leakage. If no
 *                  handle could be assigned (the track list is full), an
 *                  exception will be thrown. Scope for valid ids in the track
 *                  list is [0x8000, MAX_TGT_HANDLE_ID].
 * @param           myhba The HBA to open a handle for
 *                  m The mode of HBA to open handle for
 */
#if 0
// appears unused
Handle::Handle(HBA *myhba, MODE m) {
        map<HBA_HANDLE, Handle*>::iterator mapend;
        Trace log("Handle::Handle");
        lock(&staticLock);
        modeVal = m;


        // if initiator mode call constructor for initiator.
        if (m == INITIATOR) {
                Handle(myhba, TARGET);
        }

        mapend = openHandles.end();
        /* Start the search for a free id from the previously assigned one */
        id = prevTgtOpen + 1;
        while (id != prevTgtOpen) {
                /*
                 * Exceeds the max valid target id value,
                 * continue the search from 1.
                 */
                if (id > MAX_TGT_HANDLE_ID)
                        id = 0x8001;

                if (openHandles.find(id) == mapend) {
                        /* the id is not in use */
                        break;
                }
                id ++;
        }
        if (id == prevTgtOpen) {
                /* no usable id for now */
                unlock(&staticLock);
                throw TryAgainException();
        }
        prevTgtOpen = id;
        hba = myhba;
        openHandles[id] = this;
        unlock(&staticLock);
}
#endif
/**
 * @memo            Free up the handle (aka, close it)
 * @postcondition   This handle will be removed from the global list
 * @exception       ... underlying exceptions will be thrown
 */
Handle::~Handle() {
        Trace log("Handle::~Handle");
        // Remove this handle from the global list
        lock(&staticLock);
        try {
            openHandles.erase(openHandles.find(getHandle()));
            unlock(&staticLock);
        } catch (...) {
            unlock(&staticLock);
            throw;
        }

        // Now nuke all internal dynamic allocations
        typedef map<uint64_t, HandlePort *>::const_iterator CI;
        lock();
        try {
            for (CI port = portHandles.begin(); port != portHandles.end();
                    port++) {
                delete port->second;
            }
            portHandles.clear();
            unlock();
        } catch (...) {
            unlock();
            throw;
        }
}

/**
 * @memo            Locate a handle in the global list of open handles
 * @precondition    The requested handle must already be open
 * @exception       InvalidHandleException Thrown if the id does not match
 *                  an open handle
 * @return          The open Handle
 * @param           id The id of the handle to fetch
 *
 * @doc             The HBA API uses a simple integer type to represent
 *                  an open Handle, but we use an instance of the Handle
 *                  class.  This interface allows a caller to quickly convert
 *                  from the API integer value to related the Handle instance.
 */
Handle* Handle::findHandle(HBA_HANDLE id) {
        Trace log("Handle::findHandle(id)");
        Handle *tmp = NULL;
        lock(&staticLock);
        try {
            if (openHandles.find(id) == openHandles.end()) {
                throw InvalidHandleException();
            }
            tmp = openHandles[id];
            unlock(&staticLock);
            return (tmp);
        } catch (...) {
            unlock(&staticLock);
            throw;
        }
}

/**
 * @memo            Find an open handle based on Node or Port WWN
 * @precondition    The given HBA must already be open
 * @exception       IllegalWWNException Thrown if no matching open Handle found
 * @return          The open handle matching the wwn argument
 * @param           wwn The Node or Port WWN of the HBA whos open handle
 *                  is requested.
 *
 */
Handle* Handle::findHandle(uint64_t wwn) {
        Trace log("Handle::findHandle(wwn)");
        Handle *tmp = NULL;
        lock(&staticLock);
        try {
            for (int i = 0; i < openHandles.size(); i++) {
                tmp = openHandles[i];
                if (tmp->getHBA()->containsWWN(wwn)) {
                    unlock(&staticLock);
                    return (tmp);
                }
            }
            tmp = NULL;
        } catch (...) { tmp = NULL; }
        unlock(&staticLock);
        if (tmp == NULL) {
            throw IllegalWWNException();
        }
        return (tmp);
}

/**
 * @memo            Refresh underlying index values
 * @postcondition   All HandlePorts will be reset and prior index values
 *                  will be undefined.
 * @exception       ... underlying exceptions will be thrown
 *
 * @doc             A number of APIs in the standard interface require
 *                  the use of index values for identifying what "thing"
 *                  to operate on.  When dynamic reconfiguration occurs
 *                  these indexes may become inconsistent.  This routine
 *                  is called to reset the indexes and signify that the caller
 *                  no longer holds or will refer to any old indexes.
 */
void Handle::refresh() {
        Trace log("Handle::refresh");
        lock();
        try {
            typedef map<uint64_t, HandlePort *>::const_iterator CI;
            for (CI port = portHandles.begin(); port != portHandles.end();
                    port++) {
                port->second->refresh();
            }
            unlock();
        } catch (...) {
            unlock();
            throw;
        }
}

/**
 * @memo            Close the specified handle
 * @precondition    The handle must be open
 * @postcondition   The handle will be closed and should be discarded.
 * @param           id The handle to close
 */
void Handle::closeHandle(HBA_HANDLE id) {
        Trace log("Handle::closeHandle");
        Handle *myHandle = findHandle(id);
        delete myHandle;
}

/**
 * @memo            Get the integer value for return to the API
 * @exception       ... underlying exceptions will be thrown
 * @return          The integer value representing the handle
 *
 * @doc             The HBA API uses integer values to represent handles.
 *                  Call this routine to convert a Handle instance into
 *                  its representative integer value.
 */
HBA_HANDLE Handle::getHandle() {
        Trace log("Handle::getHandle");
        HBA_HANDLE tmp;
        lock();
        try {
            tmp = (HBA_HANDLE) id;
            unlock();
            return (tmp);
        } catch (...) {
            unlock();
            throw;
        }
}

/**
 * @memo            Compare two handles for equality
 * @return          TRUE if the handles are the same
 * @return          FALSE if the handles are different
 */
bool Handle::operator==(Handle comp) {
        Trace log("Handle::operator==");
        return (this->id == comp.id);
}

/**
 * @memo            Get the underlying Handle port based on index
 * @return          The Handle port for the given port index
 * @param           index The index of the desired port
 */
HandlePort* Handle::getHandlePortByIndex(int index) {
        Trace log("Handle::getHandlePortByIndex");
        HBAPort* port = hba->getPortByIndex(index);
        return (getHandlePort(port->getPortWWN()));
}

/**
 * @memo            Get the underlying Handle port based on Port wwn
 * @exception       IllegalWWNException thrown if the wwn is not found
 * @return          The handle port for the specified WWN
 * @param           wwn The Port WWN of the HBA port
 *
 */
HandlePort* Handle::getHandlePort(uint64_t wwn) {
        Trace log("Handle::getHandlePort");
        lock();
        try {
            // Check to see if the wwn is in the map
            if (portHandles.find(wwn) == portHandles.end()) {
                // Not found, add a new one
                HBAPort* port = hba->getPort(wwn);
                portHandles[wwn] = new HandlePort(this, hba, port);
            }
            HandlePort *portHandle = portHandles[wwn];
            unlock();
            return (portHandle);
        } catch (...) {
            unlock();
            throw;
        }
}

/**
 * @memo            Get the HBA attributes from the underlying HBA
 *
 * @see             HBA::getHBAAttributes
 */
HBA_ADAPTERATTRIBUTES Handle::getHBAAttributes() {
        Trace log("Handle::getHBAAttributes");
        lock();
        try {
            HBA_ADAPTERATTRIBUTES attributes = hba->getHBAAttributes();
            unlock();
            return (attributes);
        } catch (...) {
            unlock();
            throw;
        }
}

/**
 * @memo            Do FORCELIP
 *
 * @see             HBA::doForceLip
 */
int Handle::doForceLip() {
        Trace log("Handle::doForceLip");
        lock();
        try {
            int rval = hba->doForceLip();
            unlock();
            return (rval);
        } catch (...) {
            unlock();
            throw;
        }
}

HBA_ADAPTERATTRIBUTES Handle::npivGetHBAAttributes() {
        Trace log("Handle::npivGetHBAAttributes");
        lock();
        try {
                HBA_ADAPTERATTRIBUTES attributes = hba->npivGetHBAAttributes();
                unlock();
                return (attributes);
        } catch (...) {
                unlock();
                throw;
        }
}


/**
 * @memo            Get the HBA port attributes from the HBA
 * @see             HBAPort::getPortAttributes
 * @see             HBAPort::getDisoveredAttributes
 *
 * @doc             This routine will return either HBA port
 *                  attributes, or discovered port attributes
 *
 */
HBA_PORTATTRIBUTES Handle::getPortAttributes(uint64_t wwn) {
        Trace log("Handle::getPortAttributes");
        uint64_t tmp;
        HBA_PORTATTRIBUTES attributes;

        lock();
        try {
            // Is this a WWN for one of the adapter ports?
            if (hba->containsWWN(wwn)) {
                attributes = hba->getPort(wwn)->getPortAttributes(tmp);
                unlock();
                return (attributes);
            } else { // Is this a target we know about?
                // Loop through all ports and look for the first match

                for (int i = 0; i < hba->getNumberOfPorts(); i++) {
                    try {
                        attributes =
                            hba->getPortByIndex(i)->getDiscoveredAttributes(
                            wwn, tmp);
                        unlock();
                        return (attributes);
                    } catch (HBAException &e) {
                        continue;
                    }
                }

                // If we get to here, then we don't see this WWN on this HBA
                throw IllegalWWNException();
            }
        } catch (...) {
            unlock();
            throw;
        }
}