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