sun_fc/common/FCSyseventBridge.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 "FCSyseventBridge.h"
#include "Exceptions.h"
#include "Trace.h"
#include "AdapterAddEvent.h"
#include "AdapterEvent.h"
#include "AdapterPortEvent.h"
#include "AdapterDeviceEvent.h"
#include "TargetEvent.h"
#include "sun_fc.h"
#include <libnvpair.h>
#include <iostream>
#include <climits>

using namespace std;

FCSyseventBridge* FCSyseventBridge::_instance = NULL;

FCSyseventBridge* FCSyseventBridge::getInstance() {
    Trace log("FCSyseventBridge::getInstance");
    if (_instance == NULL) {
	_instance = new FCSyseventBridge();
    }
    return (_instance);

}


void FCSyseventBridge::addListener(AdapterAddEventListener *listener) {
    lock();
    try {
	adapterAddEventListeners.insert(adapterAddEventListeners.begin(),
		listener);
	validateRegistration();
	unlock();
    } catch (...) {
	unlock();
	throw;
    }
}
void FCSyseventBridge::addListener(AdapterEventListener *listener, HBA *hba) {
    lock();
    try {
	adapterEventListeners.insert(adapterEventListeners.begin(), listener);
	validateRegistration();
	unlock();
    } catch (...) {
	unlock();
	throw;
    }
}
void FCSyseventBridge::addListener(AdapterPortEventListener *listener,
	    HBAPort *port) {
    lock();
    try {
	adapterPortEventListeners.insert(adapterPortEventListeners.begin(),
		listener);
	validateRegistration();
	unlock();
    } catch (...) {
	unlock();
	throw;
    }
}
void FCSyseventBridge::addListener(AdapterDeviceEventListener *listener,
    HBAPort *port) {
	lock();
	try {
		adapterDeviceEventListeners.insert(adapterDeviceEventListeners.begin(),
		    listener);
		validateRegistration();
		unlock();
	} catch (...) {
		unlock();
		throw;
	}
}
void FCSyseventBridge::addListener(TargetEventListener *listener,
	    HBAPort *port, uint64_t targetWWN, bool filter) {
    lock();
    try {
	targetEventListeners.insert(targetEventListeners.begin(), listener);
	validateRegistration();
	unlock();
    } catch (...) {
	unlock();
	throw;
    }
}

void FCSyseventBridge::removeListener(AdapterAddEventListener *listener) {
    lock();
    try {
	typedef vector<AdapterAddEventListener *>::iterator Iter;
	for (Iter tmp = adapterAddEventListeners.begin();
		tmp != adapterAddEventListeners.end(); tmp++) {
	    if (*tmp == listener) {
		adapterAddEventListeners.erase(tmp);
		unlock();
		return;
	    }
	}
	throw InvalidHandleException();
    } catch (...) {
	unlock();
	throw;
    }
}

void FCSyseventBridge::removeListener(AdapterEventListener *listener) {
    lock();
    try {
	typedef vector<AdapterEventListener *>::iterator Iter;
	for (Iter tmp = adapterEventListeners.begin();
		tmp != adapterEventListeners.end(); tmp++) {
	    if (*tmp == listener) {
		adapterEventListeners.erase(tmp);
		unlock();
		return;
	    }
	}
	throw InvalidHandleException();
    } catch (...) {
	unlock();
	throw;
    }
}

void FCSyseventBridge::removeListener(AdapterPortEventListener *listener) {
    lock();
    try {
	typedef vector<AdapterPortEventListener *>::iterator Iter;
	for (Iter tmp = adapterPortEventListeners.begin();
		tmp != adapterPortEventListeners.end(); tmp++) {
	    if (*tmp == listener) {
		adapterPortEventListeners.erase(tmp);
		unlock();
		return;
	    }
	}
	throw InvalidHandleException();
    } catch (...) {
	unlock();
	throw;
    }
}

void FCSyseventBridge::removeListener(AdapterDeviceEventListener *listener) {
	lock();
	try {
		typedef vector<AdapterDeviceEventListener *>::iterator Iter;
		for (Iter tmp = adapterDeviceEventListeners.begin();
		    tmp != adapterDeviceEventListeners.end(); tmp++) {
			if (*tmp == listener) {
				adapterDeviceEventListeners.erase(tmp);
				unlock();
				return;
			}
		}
		throw InvalidHandleException();
	} catch (...) {
		unlock();
		throw;
	}
}

void FCSyseventBridge::removeListener(TargetEventListener *listener) {
    lock();
    try {
	typedef vector<TargetEventListener *>::iterator Iter;
	for (Iter tmp = targetEventListeners.begin();
		tmp != targetEventListeners.end(); tmp++) {
	    if (*tmp == listener) {
		targetEventListeners.erase(tmp);
		unlock();
		return;
	    }
	}
	throw InvalidHandleException();
    } catch (...) {
	unlock();
	throw;
    }
}

extern "C" void static_dispatch(sysevent_t *ev) {
    Trace log("static_dispatch");
    FCSyseventBridge::getInstance()->dispatch(ev);
}

void FCSyseventBridge::dispatch(sysevent_t *ev) {
    Trace log("FCSyseventBridge::dispatch");
    nvlist_t		    *list = NULL;
    hrtime_t			when;

    if (ev == NULL) {
	log.debug("Null event.");
	return;
    }

    if (sysevent_get_attr_list(ev, &list) || list == NULL) {
	log.debug("Empty event.");
	return;
    }

    string eventVendor = sysevent_get_vendor_name(ev);
    string eventPublisher = sysevent_get_pub_name(ev);
    string eventClass = sysevent_get_class_name(ev);
    string eventSubClass = sysevent_get_subclass_name(ev);

    sysevent_get_time(ev, &when);

    // Now that we know what type of event it is, handle it accordingly
    if (eventClass == "EC_sunfc") {

	// All events of this class type have instance and port-wwn for
	// the HBA port.
	uint32_t	instance;
	if (nvlist_lookup_uint32(list, (char *)"instance",
		&instance)) {
	    log.genericIOError(
		"Improperly formed event: no instance field.");
	    nvlist_free(list);
	    return;
	}
	uchar_t		*rawPortWWN;
	uint32_t	rawPortWWNLength;

	if (nvlist_lookup_byte_array(list, (char *)"port-wwn",
		&rawPortWWN, &rawPortWWNLength)) {
	    log.genericIOError(
		"Improperly formed event: no port-wwn field.");
	    nvlist_free(list);
	    return;
	}

	// Now deal with the specific details of each subclass type
	if (eventSubClass == "ESC_sunfc_port_offline") {

	    // Create event instance
	    AdapterPortEvent event(
		wwnConversion(rawPortWWN),
		AdapterPortEvent::OFFLINE,
		0);

	    // Dispatch to interested parties.
	    lock();
	    try {
		typedef vector<AdapterPortEventListener *>::iterator Iter;
		for (Iter tmp = adapterPortEventListeners.begin();
			tmp != adapterPortEventListeners.end(); tmp++) {
		    (*tmp)->dispatch(event);
		}
	    } catch (...) {
		unlock();
		nvlist_free(list);
		throw;
	    }
	    unlock();

	} else if (eventSubClass == "ESC_sunfc_port_online") {

	    // Create event instance
	    AdapterPortEvent event(
		wwnConversion(rawPortWWN),
		AdapterPortEvent::ONLINE,
		0);

	    // Dispatch to interested parties.
	    lock();
	    try {
		typedef vector<AdapterPortEventListener *>::iterator Iter;
		for (Iter tmp = adapterPortEventListeners.begin();
			tmp != adapterPortEventListeners.end(); tmp++) {
		    (*tmp)->dispatch(event);
		}
	    } catch (...) {
		unlock();
		nvlist_free(list);
		throw;
	    }
	    unlock();

	} else if (eventSubClass == "ESC_sunfc_device_online") {
		AdapterDeviceEvent event(
		    wwnConversion(rawPortWWN),
		    AdapterDeviceEvent::ONLINE,
		    0);
		lock();
		try {
			typedef vector<AdapterDeviceEventListener *>::iterator Iter;
			for (Iter tmp = adapterDeviceEventListeners.begin();
			    tmp != adapterDeviceEventListeners.end(); tmp++) {
				(*tmp)->dispatch(event);
			}
		} catch (...) {
			unlock();
			nvlist_free(list);
			throw;
		}
		unlock();

	} else if (eventSubClass == "ESC_sunfc_device_offline") {
		AdapterDeviceEvent event(
		    wwnConversion(rawPortWWN),
		    AdapterDeviceEvent::OFFLINE,
		    0);
		lock();
		try {
			typedef vector<AdapterDeviceEventListener *>::iterator Iter;
			for (Iter tmp = adapterDeviceEventListeners.begin();
			    tmp != adapterDeviceEventListeners.end(); tmp++) {
				(*tmp)->dispatch(event);
			}
		} catch (...) {
			unlock();
			nvlist_free(list);
			throw;
		}
		unlock();

	} else if (eventSubClass == "ESC_sunfc_port_rscn") {
	    /*
	     * RSCNs are a little tricky.  There can be multiple
	     * affected page properties, each numbered.  To make sure
	     * we get them all, we loop through all properties
	     * in the nvlist and if their name begins with "affected_page_"
	     * then we send an event for them.
	     */
	    uint32_t	affected_page;
	    nvpair_t    *attr = NULL;
	    for (attr = nvlist_next_nvpair(list, NULL);
		    attr != NULL;
		    attr = nvlist_next_nvpair(list, attr)) {
		string name = nvpair_name(attr);
		if (name.find("affected_page_") != name.npos) {

		    if (nvpair_value_uint32(attr, &affected_page)) {
			log.genericIOError(
			    "Improperly formed event: "
			    "corrupt affected_page field");
			continue;
		    }
		    // Create event instance
		    AdapterPortEvent event(
			wwnConversion(rawPortWWN),
			AdapterPortEvent::FABRIC,
			affected_page);

		    // Dispatch to interested parties.
		    lock();
		    typedef vector<AdapterPortEventListener *>::iterator Iter;
		    try {
			for (Iter tmp = adapterPortEventListeners.begin();
				tmp != adapterPortEventListeners.end(); tmp++) {
			    (*tmp)->dispatch(event);
			}
		    } catch (...) {
			unlock();
			nvlist_free(list);
			throw;
		    }
		    unlock();
		}
	    }
	} else if (eventSubClass == "ESC_sunfc_target_add") {
	    uchar_t	*rawTargetPortWWN;
	    uint32_t	rawTargetPortWWNLength;

	    if (nvlist_lookup_byte_array(list, (char *)"target-port-wwn",
		    &rawTargetPortWWN, &rawTargetPortWWNLength)) {
		log.genericIOError(
		    "Improperly formed event: no target-port-wwn field.");
		nvlist_free(list);
		return;
	    }

	    // Create event instance
	    AdapterPortEvent event(
		wwnConversion(rawPortWWN),
		AdapterPortEvent::NEW_TARGETS,
		0);

	    // Dispatch to interested parties.
	    lock();
	    try {
		typedef vector<AdapterPortEventListener *>::iterator Iter;
		for (Iter tmp = adapterPortEventListeners.begin();
			tmp != adapterPortEventListeners.end(); tmp++) {
		    (*tmp)->dispatch(event);
		}
	    } catch (...) {
		unlock();
		nvlist_free(list);
		throw;
	    }
	    unlock();
	} else if (eventSubClass == "ESC_sunfc_target_remove") {
	    uchar_t	*rawTargetPortWWN;
	    uint32_t	rawTargetPortWWNLength;

	    if (nvlist_lookup_byte_array(list, (char *)"target-port-wwn",
		    &rawTargetPortWWN, &rawTargetPortWWNLength)) {
		log.genericIOError(
		    "Improperly formed event: no target-port-wwn field.");
		nvlist_free(list);
		return;
	    }
	    // Create event instance
	    TargetEvent event(
		wwnConversion(rawPortWWN),
		wwnConversion(rawTargetPortWWN),
		TargetEvent::REMOVED);

	    // Dispatch to interested parties.
	    lock();
	    try {
		typedef vector<TargetEventListener *>::iterator Iter;
		for (Iter tmp = targetEventListeners.begin();
			tmp != targetEventListeners.end(); tmp++) {
		    (*tmp)->dispatch(event);
		}
	    } catch (...) {
		unlock();
		nvlist_free(list);
		throw;
	    }
	    unlock();
	} else if (eventSubClass == "ESC_sunfc_port_attach") {
	    // Create event instance
	    AdapterAddEvent event(wwnConversion(rawPortWWN));
	    // Dispatch to interested parties.
	    lock();
	    try {
		typedef vector<AdapterAddEventListener *>::iterator Iter;
		for (Iter tmp = adapterAddEventListeners.begin();
			tmp != adapterAddEventListeners.end(); tmp++) {
		    (*tmp)->dispatch(event);
		}
	    } catch (...) {
		unlock();
		nvlist_free(list);
		throw;
	    }
	    unlock();
	} else if (eventSubClass == "ESC_sunfc_port_detach") {
	    // Technically, we should probably try to coalesce
	    // all detach events for the same multi-ported adapter
	    // and only send one event to the client, but for now,
	    // we'll just blindly send duplicates.

	    // Create event instance
	    AdapterEvent event(
		wwnConversion(rawPortWWN),
		AdapterEvent::REMOVE);

	    // Dispatch to interested parties.
	    lock();
	    try {
		typedef vector<AdapterEventListener *>::iterator Iter;
		for (Iter tmp = adapterEventListeners.begin();
			tmp != adapterEventListeners.end(); tmp++) {
		    (*tmp)->dispatch(event);
		}
	    } catch (...) {
		unlock();
		nvlist_free(list);
		throw;
	    }
	    unlock();

	} else {
	    log.genericIOError(
		    "Unrecognized subclass \"%s\": Ignoring event",
		    eventSubClass.c_str());
	}
    } else {
	// This should not happen, as we only asked for specific classes.
	log.genericIOError(
		"Unrecognized class \"%s\": Ignoring event",
		eventClass.c_str());
    }
    nvlist_free(list);
}

void FCSyseventBridge::validateRegistration() {
    Trace log("FCSyseventBridge::validateRegistration");
    uint64_t count = 0;
    count = adapterAddEventListeners.size() +
	    adapterEventListeners.size() +
	    adapterPortEventListeners.size() +
	    targetEventListeners.size();
    if (count == 1) {
	handle = sysevent_bind_handle(static_dispatch);
	if (handle == NULL) {
	    log.genericIOError(
		"Unable to bind sysevent handle.");
	    return;
	}
	const char *subclass_list[9] = {
		"ESC_sunfc_port_attach",
		"ESC_sunfc_port_detach",
		"ESC_sunfc_port_offline",
		"ESC_sunfc_port_online",
		"ESC_sunfc_port_rscn",
		"ESC_sunfc_target_add",
		"ESC_sunfc_target_remove",
		"ESC_sunfc_device_online",
		"ESC_sunfc_device_offline"
	    };
	if (sysevent_subscribe_event(handle,
		"EC_sunfc", (const char **)subclass_list, 9)) {
	    log.genericIOError(
		"Unable to subscribe to sun_fc events.");
	    sysevent_unbind_handle(handle);
	    handle = NULL;
	}
    } else if (count == 0 && handle != NULL) {
	// Remove subscription
	sysevent_unbind_handle(handle);
	handle == NULL;
    } // Else do nothing
}

int32_t FCSyseventBridge::getMaxListener() {
    return (INT_MAX);
}