path: root/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);
}