dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / sun_fc / common / HBAList.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */



#include "HBAList.h"
#include "Exceptions.h"
#include "Trace.h"
#include "sun_fc_version.h"
#include <string>
#include <sstream>
#include "FCHBA.h"
#include "TgtFCHBA.h"
#include <cstring>
#include <climits>
#include <cstdlib>

using namespace std;

/**
 * @memo            Private constructor (used to create singleton instance)
 * @see             HBAList::instance
 */
HBAList::HBAList() { }

/**
 * Internal singleton instance
 */
HBAList* HBAList::_instance = 0;

/**
 * Max number of adapters that this class supports.
 */
const int32_t HBAList::HBA_MAX_PER_LIST = INT_MAX;

/**
 * @memo            Free up resources held by this HBA list
 * @postcondition   All memory used by this list will be freed
 * @return          HBA_STATUS_OK on success
 * 
 */
HBA_STATUS HBAList::unload() {
        Trace log("HBAList::unload");
        lock();
        _instance = NULL;
        unlock();
        return (HBA_STATUS_OK);
}

/**
 * @memo            Fetch the singleton instance
 * @return          The singleton instance
 * 
 * @doc             Only one instance of HBAList must be present
 *                  per address space at a time.  The singleton design pattern
 *                  is used to enforce this behavior.
 */
HBAList* HBAList::instance() {
        Trace log("HBAList::instance");
        if (_instance == 0) {
            _instance = new HBAList();
        }
        return (_instance);
}

/**
 * @memo            Fetch an HBA based on name.
 *                  Always returns  non-null or throw an Exception.
 * @precondition    HBAs must be loaded in the list
 * @postcondition   A handle will be opened.  The caller must close the handle
 *                  at some later time to prevent leakage.
 * @exception       BadArgumentException if the name is not properly formatted
 * @exception       IllegalIndexException if the name does not match any
 *                  present HBAs within this list.
 * @return          A valid handle for future API calls
 * @param           name The name of the HBA to open
 * 
 * @doc             This routine will always return a handle (ie, non null)
 *                  or will throw an exception.
 */
Handle* HBAList::openHBA(string name) {
        Trace log("HBAList::openHBA(name)");
        int index = -1;
        try {
            string::size_type offset = name.find_last_of("-");
            if (offset >= 0) {
                string indexString = name.substr(offset+1);
                index = atoi(indexString.c_str());
            }
        } catch (...) {
            throw BadArgumentException();
        }
        lock();
        if (index < 0 || index > hbas.size()) {
            unlock();
            throw IllegalIndexException();
        } else {
            HBA *tmp = hbas[index];
            unlock();
            tmp->validatePresent();
            return (new Handle(tmp));
        }
}

/**
 * @memo            Fetch an target mode FC HBA based on name.
 *                  Always returns  non-null or throw an Exception.
 * @precondition    Target mode HBAs must be loaded in the list
 * @postcondition   A handle will be opened.  The caller must close the handle
 *                  at some later time to prevent leakage.
 * @exception       BadArgumentException if the name is not properly formatted
 * @exception       IllegalIndexException if the name does not match any
 *                  present HBAs within this list.
 * @return          A valid handle for future API calls
 * @param           name The name of the target mode HBA to open
 * 
 * @doc             This routine will always return a handle (ie, non null)
 *                  or will throw an exception.
 */
Handle* HBAList::openTgtHBA(string name) {
        Trace log("HBAList::openHBA(name)");
        int index = -1;
        try {
            string::size_type offset = name.find_last_of("-");
            if (offset >= 0) {
                string indexString = name.substr(offset+1);
                index = atoi(indexString.c_str());
            }
        } catch (...) {
            throw BadArgumentException();
        }
        lock();
        if (index < 0 || index > tgthbas.size()) {
            unlock();
            throw IllegalIndexException();
        } else {
            HBA *tmp = tgthbas[index];
            unlock();
            tmp->validatePresent();
            return (new Handle(tmp));
        }
}

/**
 * @memo            Get the name of an HBA at the given index
 * @precondition    HBAs must be loaded in the list
 * @exception       IllegalIndexException Thrown if the index doesn't match any
 *                  HBA in the list
 * @return          The name of the specified HBA
 * @param           index The zero based index of the desired HBA
 * 
 */
string HBAList::getHBAName(int index) {
        Trace log("HBAList::getHBAName");
        lock();
        if (index < 0 || index > hbas.size()) {
            unlock();
            throw IllegalIndexException();
        } else {
            HBA *tmp = hbas[index];
            unlock();
            tmp->validatePresent();
            char buf[128];
            snprintf(buf, 128, "%s-%d", tmp->getName().c_str(), index);
            string name = buf;
            return (name);
        }
}

/**
 * @memo            Get the name of an target mode HBA at the given index
 * @precondition    Target mode HBAs must be loaded in the list
 * @exception       IllegalIndexException Thrown if the index doesn't match any
 *                  HBA in the list
 * @return          The name of the specified target mode HBA
 * @param           index The zero based index of the desired target mode HBA
 * 
 */
string HBAList::getTgtHBAName(int index) {
        Trace log("HBAList::getTgtHBAName");
        lock();
        if (index < 0 || index > tgthbas.size()) {
            unlock();
            throw IllegalIndexException();
        } else {
            HBA *tmp = tgthbas[index];
            unlock();
            tmp->validatePresent();
            char buf[128];
            snprintf(buf, 128, "%s-%d", tmp->getName().c_str(), index);
            string name = buf;
            return (name);
        }
}

/**
 * @memo            Open an HBA based on a WWN
 * @precondition    HBAs must be loaded in the list
 * @postcondition   A handle will be opened.  The caller must close the handle
 *                  at some later time to prevent leakage.
 * @exception       IllegalWWNException Thrown if the wwn doesn't match any
 *                  HBA in the list
 * @return          A valid Handle for later use by API calls
 * @param           wwn The node or any port WWN of HBA to open
 * @see             HBA::containsWWN
 * 
 * @doc             This routine will accept both Node and Port WWNs based
 *                  on the HBA routine containsWWN
 */
Handle* HBAList::openHBA(uint64_t wwn) {

        Trace log("HBAList::openHBA(wwn)");
        lock();
        HBA *tmp;
        for (int i = 0; i < hbas.size(); i++) {
            if (hbas[i]->containsWWN(wwn)) {
                tmp = hbas[i];
                unlock();
                tmp->validatePresent();
                return (new Handle(tmp));
            }
        }
        unlock();
        throw IllegalWWNException();
}

/**
 * @memo            Open an target mode HBA based on a WWN
 * @precondition    Targee mode HBAs must be loaded in the list
 * @postcondition   A handle will be opened.  The caller must close the handle
 *                  at some later time to prevent leakage.
 * @exception       IllegalWWNException Thrown if the wwn doesn't match any
 *                  target mode HBA in the list
 * @return          A valid Handle for later use by API calls
 * @param           The node WWN or any port WWN of target mode HBA to open
 * @see             HBA::containsWWN
 * 
 * @doc             This routine will accept both Node and Port WWNs based
 *                  on the HBA routine containsWWN
 */
Handle* HBAList::openTgtHBA(uint64_t wwn) {

        Trace log("HBAList::openTgtHBA(wwn)");
        lock();
        HBA *tmp;
        for (int i = 0; i < tgthbas.size(); i++) {
            if (tgthbas[i]->containsWWN(wwn)) {
                tmp = tgthbas[i];
                unlock();
                tmp->validatePresent();
                return (new Handle(tmp));
            }
        }
        unlock();
        throw IllegalWWNException();
}

/**
 * @memo            Get the number of adapters present in the list
 * @postcondition   List of HBAs will be loaded
 * @exception       ... Underlying exceptions will be thrown
 * @return          The number of adapters in the list
 * 
 * @doc             This routine will triger discovery of HBAs on the system.
 *                  It will also handle addition/removal of HBAs in the list
 *                  based on dynamic reconfiguration operations.  The max 
 *                  number of HBAs that HBA API supports is up to the
 *                  uint32_t size.  VSL supports up to int32_t size thus
 *                  it gives enough room for the HBA API library
 *                  to handle up to max uint32_t number if adapters. 
 */
int HBAList::getNumberofAdapters() {
        Trace log("HBAList::getNumberofAdapters");
        lock();

        try {
        if (hbas.size() == 0) {
            // First pass, just store them all blindly
            FCHBA::loadAdapters(hbas);
        } else {
            // Second pass, do the update operation
            vector<HBA*> tmp;
            FCHBA::loadAdapters(tmp);
            bool matched;
            for (int i = 0; i < tmp.size(); i++) {
                matched = false;
                for (int j = 0; j < hbas.size(); j++) {
                    if (*tmp[i] == *hbas[j]) {
                        matched = true;
                        break;
                    }
                }
                if (matched) {
                    delete (tmp[i]);
                } else {
                    hbas.insert(hbas.end(), tmp[i]);
                }
            }
        }
        } catch (...) {
            unlock();
            throw;
        }

        unlock();

        // When there is more than HBA_MAX_PER_LIST(= int32_max)
        // VSL returns an error so it is safe to cast it here.
        return ((uint32_t)hbas.size());
}

/**
 * @memo            Get the number of target mode adapters present in the list
 * @postcondition   List of TgtHBAs will be loaded
 * @exception       ... Underlying exceptions will be thrown
 * @return          The number of target mode adapters in the list
 * 
 * @doc             This routine will triger discovery of Target mode HBAs on
 *                  the system. It will also handle addition/removal of Target
 *                  mode HBAs in the list based on dynamic reconfiguration 
 *                  operations. The max number of target mode HBAs that
 *                  HBA API supports is up to the
 *                  uint32_t size.  VSL supports up to int32_t size thus
 *                  it gives enough room for the HBA API library
 *                  to handle up to max uint32_t number of adapters. 
 */
int HBAList::getNumberofTgtAdapters() {
        Trace log("HBAList::getNumberofTgtAdapters");
        lock();

        try {
            if (tgthbas.size() == 0) {
                // First pass, just store them all blindly
                TgtFCHBA::loadAdapters(tgthbas);
            } else {
                // Second pass, do the update operation
                vector<HBA*> tmp;
                TgtFCHBA::loadAdapters(tmp);
                bool matched;
                for (int i = 0; i < tmp.size(); i++) {
                    matched = false;
                    for (int j = 0; j < tgthbas.size(); j++) {
                        if (*tmp[i] == *tgthbas[j]) {
                            matched = true;
                            break;
                        }
                    }
                    if (matched) {
                        delete (tmp[i]);
                    } else {
                        tgthbas.insert(tgthbas.end(), tmp[i]);
                    }
                }
            }
        } catch (...) {
            unlock();
            throw;
        }

        unlock();

        // When there is more than HBA_MAX_PER_LIST(= int32_max)
        // VSL returns an error so it is safe to cast it here.
        return ((uint32_t)tgthbas.size());
}

/**
 * @memo            Load the list
 * @return          HBA_STATUS_OK
 * 
 * @doc             Currently this routine is a no-op and may be a cantidate
 *                  for removal in the future.
 */
HBA_STATUS HBAList::load() {
        Trace log("HBAList::load");

        // No lock is required since no VSL specific action requried.
        return (HBA_STATUS_OK);
}

/**
 * @memo            Free up resources
 */
HBAList::~HBAList() {
        Trace log("HBAList::~HBAList");
        for (int i = 0; i < hbas.size(); i++) {
            delete (hbas[i]);
        }
        for (int i = 0; i < tgthbas.size(); i++) {
            delete (tgthbas[i]);
        }
}

HBA_LIBRARYATTRIBUTES HBAList::getVSLAttributes() {
        HBA_LIBRARYATTRIBUTES attrs;
        char    build_time[] = BUILD_TIME;
        attrs.final = 0;
        memset(&attrs, 0, sizeof(attrs));
        strlcpy(attrs.VName, VSL_NAME, sizeof (attrs.VName));
        strlcpy(attrs.VVersion, VSL_STRING_VERSION, sizeof (attrs.VVersion));
        strptime(build_time, "%c", &attrs.build_date);

        return (attrs);
}