/*
* for each device uid, call the library to update it's firmware with the path provided
*/
void wbem::software::NVDIMMSoftwareInstallationServiceFactory::installFromPath(
const std::string& deviceUid,
const std::string& path, bool activate, bool force) const
throw (framework::Exception)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
COMMON_LOG_DEBUG_F("URI: %s", path.c_str());
if(path.empty())
{
throw framework::ExceptionBadParameter("path");
}
if (!core::device::isUidValid(deviceUid))
{
throw framework::ExceptionBadParameter("deviceUid");
}
int rc;
NVM_UID uid;
uid_copy(deviceUid.c_str(), uid);
// library will check if device is manageable and can update the FW ... if not it will return an error
if (NVM_SUCCESS !=
(rc = m_UpdateDeviceFw(uid, path.c_str(), path.length(), activate, force)))
{
throw exception::NvmExceptionLibError(rc);
}
}
/*
* Open the library
*/
int nvm_open_lib()
{
int rc = NVM_SUCCESS;
// initialize the connection to the database
if (!open_default_lib_store())
{
rc = NVM_ERR_UNKNOWN;
}
else
{
char sim_path[CONFIG_VALUE_LEN];
// attempt to open a default simulator
if (get_config_value(SQL_KEY_DEFAULT_SIMULATOR, sim_path) == COMMON_SUCCESS)
{
// don't care about failures. sim_adapter will log any
// errors to the config database. other adapters will just
// return not supported
COMMON_LOG_DEBUG_F("Opening default simulator %s", sim_path);
nvm_add_simulator(sim_path, s_strnlen(sim_path, CONFIG_VALUE_LEN));
}
// initialize the event monitor lock
// event monitoring is per process so no need to be cross-process safe
// thus no name on the mutex
if (!mutex_init((OS_MUTEX*)&g_eventmonitor_lock, NULL))
{
rc = NVM_ERR_UNKNOWN;
}
// initialize the context lock
// context is per proces so no need to be cross-process safe
// thus no name on the mutex
if (!mutex_init((OS_MUTEX*)&g_context_lock, NULL))
{
rc = NVM_ERR_UNKNOWN;
}
}
return rc;
}
wbem::framework::Instance *wbem::indication::InstIndicationFactory::createIndication(
struct event *pEvent)
throw(framework::Exception)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
framework::Instance *pResult = NULL;
if (pEvent == NULL)
{
COMMON_LOG_ERROR("pEvent was NULL");
}
else
{
COMMON_LOG_DEBUG_F("Event Type: %d, Event Code: %d", (int)pEvent->type, (int)pEvent->code);
try
{
if (isNamespaceEvent(pEvent))
{
pResult = createNamespaceIndication(pEvent);
}
else if (isDeviceEvent(pEvent))
{
pResult = createDeviceIndication(pEvent);
}
else if (isSensorEvent(pEvent))
{
pResult = createSensorIndication(pEvent);
}
}
catch (core::NoMemoryException)
{
throw framework::ExceptionNoMemory(__FILE__, __FUNCTION__, "Could not allocate memory");
}
}
return pResult;
}
/*
* Retrieve a specific instance given an object path
*/
wbem::framework::Instance* wbem::memory::MemoryControllerFactory::getInstance(
framework::ObjectPath &path, framework::attribute_names_t &attributes)
throw (framework::Exception)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
// create the instance, initialize with attributes from the path
framework::Instance *pInstance = new framework::Instance(path);
try
{
checkAttributes(attributes);
path.checkKey(CREATIONCLASSNAME_KEY, MEMORYCONTROLLER_CREATIONCLASSNAME);
path.checkKey(SYSTEMCREATIONCLASSNAME_KEY, server::BASESERVER_CREATIONCLASSNAME);
path.checkKey(SYSTEMNAME_KEY, server::getHostName());
// extract the memory controller id from the object path
framework::Attribute devIdAttr = path.getKeyValue(DEVICEID_KEY);
COMMON_LOG_DEBUG_F("DeviceID: %s", devIdAttr.asStr().c_str());
int rc = nvm_get_device_count();
if (rc < NVM_SUCCESS)
{
throw exception::NvmExceptionLibError(rc);
}
else if (rc == 0)
{
throw framework::Exception(
"Could not find any NVDIMMs connected to Memory Controller");
}
// get the device_discovery information for all of the dimms
struct device_discovery dimms[rc];
if ((rc = nvm_get_devices(dimms, rc)) < NVM_SUCCESS)
{
throw exception::NvmExceptionLibError(rc);
}
else if (rc == 0)
{
throw framework::Exception(
"Could not find any NVDIMMs connected to Memory Controller");
}
// initialize indicator
int instance_found = 0;
// find the set of unique memory controller ids used across all DIMMs
for (int i = 0; i < rc; i++)
{
// compare the current DIMM's mem controller to the one that we are searching for
instance_found = (devIdAttr.stringValue().compare(
generateUniqueMemoryControllerID(&(dimms[i]))) == 0);
if (instance_found)
{
// if found, update pInstance
MemoryControllerFactory::addNonKeyAttributesToInstance(
pInstance, &attributes, &(dimms[i]));
// break the loop since we found what we were looking for
break;
}
}
// handle failures
if (!instance_found)
{
COMMON_LOG_ERROR_F("Device ID Not Found: %s", devIdAttr.stringValue().c_str());
throw framework::ExceptionBadParameter(DEVICEID_KEY.c_str());
}
}
catch (framework::Exception) // clean up and re-throw
{
delete pInstance;
throw;
}
return pInstance;
}
void monitor::EventMonitor::checkConfigGoalStatus(const std::string &uidStr, const deviceInfo &device) const
{
// check platform config errors
struct event_filter filter;
memset(&filter, 0, sizeof (filter));
filter.filter_mask = NVM_FILTER_ON_UID | NVM_FILTER_ON_TYPE;
memmove(filter.uid, device.discovery.uid, NVM_MAX_UID_LEN);
filter.type = EVENT_TYPE_CONFIG;
struct config_goal goal;
memset(&goal, 0, sizeof (goal));
int rc = nvm_get_config_goal(device.discovery.uid, &goal);
if (rc == NVM_SUCCESS)
{
enum config_goal_status configGoalStatus = goal.status;
// ensure this is a new event
if (!device.stored ||
configGoalStatus != device.storedState.config_goal_status)
{
// configuration processed successfully
if (configGoalStatus == CONFIG_GOAL_STATUS_SUCCESS)
{
store_event_by_parts(EVENT_TYPE_CONFIG,
EVENT_SEVERITY_INFO,
EVENT_CODE_CONFIG_GOAL_APPLIED,
device.discovery.uid,
false,
uidStr.c_str(),
NULL,
NULL,
DIAGNOSTIC_RESULT_UNKNOWN);
// acknowledge any old config events for this dimm
acknowledge_events(&filter);
}
else if (configGoalStatus == CONFIG_GOAL_STATUS_ERR_BADREQUEST)
{
store_event_by_parts(EVENT_TYPE_CONFIG,
EVENT_SEVERITY_WARN,
EVENT_CODE_CONFIG_GOAL_FAILED_CONFIG_ERROR,
device.discovery.uid,
true,
uidStr.c_str(),
NULL,
NULL,
DIAGNOSTIC_RESULT_UNKNOWN);
}
else if (configGoalStatus == CONFIG_GOAL_STATUS_ERR_FW)
{
store_event_by_parts(EVENT_TYPE_CONFIG,
EVENT_SEVERITY_WARN,
EVENT_CODE_CONFIG_GOAL_FAILED_FW_ERROR,
device.discovery.uid,
true,
uidStr.c_str(),
NULL,
NULL,
DIAGNOSTIC_RESULT_UNKNOWN);
}
else if (configGoalStatus == CONFIG_GOAL_STATUS_ERR_INSUFFICIENTRESOURCES)
{
store_event_by_parts(EVENT_TYPE_CONFIG,
EVENT_SEVERITY_WARN,
EVENT_CODE_CONFIG_GOAL_FAILED_INSUFFICIENT_RESOURCES,
device.discovery.uid,
true,
uidStr.c_str(),
NULL,
NULL,
DIAGNOSTIC_RESULT_UNKNOWN);
}
else if (configGoalStatus == CONFIG_GOAL_STATUS_ERR_UNKNOWN)
{
store_event_by_parts(EVENT_TYPE_CONFIG,
EVENT_SEVERITY_WARN,
EVENT_CODE_CONFIG_GOAL_FAILED_UNKNOWN,
device.discovery.uid,
true,
uidStr.c_str(),
NULL,
NULL,
DIAGNOSTIC_RESULT_UNKNOWN);
}
else if (configGoalStatus == CONFIG_GOAL_STATUS_UNKNOWN)
{
store_event_by_parts(EVENT_TYPE_CONFIG,
EVENT_SEVERITY_CRITICAL,
EVENT_CODE_CONFIG_DATA_INVALID,
device.discovery.uid,
true,
uidStr.c_str(),
NULL,
NULL,
DIAGNOSTIC_RESULT_UNKNOWN);
}
} // end new config status
}
else if (rc == NVM_ERR_BADDEVICECONFIG)
{
store_event_by_parts(EVENT_TYPE_CONFIG,
EVENT_SEVERITY_CRITICAL,
EVENT_CODE_CONFIG_DATA_INVALID,
device.discovery.uid,
true,
uidStr.c_str(),
NULL,
NULL,
DIAGNOSTIC_RESULT_UNKNOWN);
}
else if (rc == NVM_ERR_NOTFOUND)
{
COMMON_LOG_DEBUG_F("No config goal found for DIMM %s", uidStr.c_str());
}
else
{
COMMON_LOG_ERROR_F("Error fetching config goal for DIMM %s, rc=%d", uidStr.c_str(), rc);
}
}
void monitor::EventMonitor::saveCurrentTopologyState(const DeviceMap &devices)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
bool saved = true;
PersistentStore *pStore = get_lib_store();
if (pStore)
{
// Only keep the latest topology
if (db_delete_all_topology_states(pStore) != DB_SUCCESS)
{
COMMON_LOG_ERROR("couldn't delete old topology_state");
saved = false;
}
else
{
// Preserve topology state in config DB
for (DeviceMap::const_iterator iter = devices.begin();
iter != devices.end(); iter++)
{
const std::string &uidStr = iter->first;
const struct deviceInfo &device = iter->second;
// only store current devices
if (device.discovered)
{
struct db_topology_state topoState;
memset(&topoState, 0, sizeof(topoState));
s_strcpy(topoState.uid, uidStr.c_str(), NVM_MAX_UID_LEN);
topoState.device_handle = device.discovery.device_handle.handle;
topoState.manufacturer = MANUFACTURER_TO_UINT(device.discovery.manufacturer);
topoState.serial_num = SERIAL_NUMBER_TO_UINT(device.discovery.serial_number);
memmove(topoState.model_num, device.discovery.model_number, NVM_MODEL_LEN);
topoState.current_config_status = device.status.config_status;
topoState.config_goal_status = CONFIG_GOAL_STATUS_UNKNOWN;
struct config_goal goal;
memset(&goal, 0, sizeof (goal));
int rc = nvm_get_config_goal(device.discovery.uid, &goal);
if (rc == NVM_SUCCESS)
{
topoState.config_goal_status = goal.status;
}
else if (rc == NVM_ERR_NOTFOUND)
{
COMMON_LOG_DEBUG_F("No goal for DIMM %s", uidStr.c_str());
}
else
{
COMMON_LOG_ERROR_F("Error fetching config goalfor DIMM %s: %d",
uidStr.c_str(),
rc);
}
if (db_add_topology_state(pStore, &topoState) != DB_SUCCESS)
{
COMMON_LOG_ERROR_F("couldn't add topology_state for DIMM %s",
topoState.uid);
saved = false;
break;
}
}
}
}
// everything succeeded
if (saved)
{
add_config_value(SQL_KEY_TOPOLOGY_STATE_VALID, "1");
}
}
}
