monitor::EventMonitor::~EventMonitor()
{
if (get_lib_store())
{
close_lib_store();
}
}
monitor::EventMonitor::EventMonitor() : NvmMonitorBase("EVENT"), m_nsMgmtCallbackId(-1)
{
if (!get_lib_store())
{
open_default_lib_store();
}
}
/*
* Clear existing diagnostic results for the specified diagnostic
* and optionally for the specified device.
*/
void diag_clear_results(const enum diagnostic_test type,
const NVM_BOOL clear_specific_device, const NVM_GUID device_guid)
{
int event_count;
PersistentStore *p_store = get_lib_store();
if (p_store)
{
db_get_event_count_by_event_type_type(p_store, type, &event_count);
struct db_event events[event_count];
db_get_events_by_event_type_type(p_store, type, events, event_count);
for (int i = 0; i < event_count; i++)
{
NVM_BOOL matched = 1;
// check for a matching guid is requested
if (clear_specific_device)
{
COMMON_GUID guid;
str_to_guid(events[i].guid, guid);
if (guid_cmp(guid, device_guid) != 1)
{
matched = 0;
}
}
if (matched)
{
db_delete_event_by_id(p_store, events[i].id);
}
}
}
}
void monitor::EventMonitor::monitor()
{
PersistentStore *pStore = get_lib_store();
if (pStore)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
// clean up any context
nvm_create_context();
DeviceMap devMap;
buildDeviceMap(devMap);
for (DeviceMap::const_iterator devIter = devMap.begin();
devIter != devMap.end(); devIter++)
{
const std::string &uidStr = devIter->first;
const struct device_discovery &discovery = devIter->second.discovery;
// ignore unmanageable dimms
if (discovery.manageability == MANAGEMENT_VALIDCONFIG)
{
bool storedStateChanged = false;
bool firstState = false;
// get stored device state
struct db_dimm_state storedState;
memset(&storedState, 0, sizeof (storedState));
if (db_get_dimm_state_by_device_handle(pStore,
discovery.device_handle.handle, &storedState) != DB_SUCCESS)
{
// initial state, just store current
firstState = true;
COMMON_LOG_INFO_F("Failed to retrieve the stored health state of dimm %u",
discovery.device_handle.handle);
storedState.device_handle = discovery.device_handle.handle;
storedStateChanged = true;
}
// check for dimm health state transition
monitorDimmStatus(uidStr, discovery, storedState,
storedStateChanged, firstState);
// check for dimm sensor transitions
monitorDimmSensors(uidStr, discovery, storedState,
storedStateChanged, firstState);
// update stored dimm state
if (storedStateChanged)
{
// clear existing dimm state
if (!firstState)
{
db_delete_dimm_state_by_device_handle(pStore,
discovery.device_handle.handle);
}
// add current state
if (db_add_dimm_state(pStore, &storedState) != DB_SUCCESS)
{
COMMON_LOG_ERROR_F("Failed to store the health state of dimm %u",
discovery.device_handle.handle);
}
}
}
}
// Monitor namespace health transitions
monitorNamespaces(pStore);
// clean up
devMap.clear();
nvm_free_context();
}
}
/*
* Build a map of uids to discovery information for all NVM-DIMM in the system
*/
void monitor::EventMonitor::buildDeviceMap(DeviceMap& map, bool addStoredTopology)
{
LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
// build a map of the current devices
int devCount = nvm_get_device_count();
if (devCount < 0) // error getting dimm count
{
COMMON_LOG_ERROR_F("nvm_get_device_count failed with error %d", devCount);
}
else if (devCount > 0) // at least one dimm
{
struct device_discovery devList[devCount];
devCount = nvm_get_devices(devList, devCount);
if (devCount < 0) // error get dimm discovery
{
COMMON_LOG_ERROR_F("nvm_get_devices failed with error %d", devCount);
}
else if (devCount > 0) // at least one dimm
{
for (int i = 0; i < devCount; i++)
{
NVM_UID uidStr;
uid_copy(devList[i].uid, uidStr);
struct deviceInfo devInfo;
memset(&devInfo, 0, sizeof (deviceInfo));
devInfo.discovered = true;
devInfo.discovery = devList[i];
if (devList[i].manageability == MANAGEMENT_VALIDCONFIG)
{
// Fetch the device status
int rc = nvm_get_device_status(devList[i].uid, &devInfo.status);
if (rc != NVM_SUCCESS)
{
COMMON_LOG_ERROR_F("nvm_get_device_status failed for dimm %s, error = %d",
uidStr, rc);
}
}
map[uidStr] = devInfo;
}
}
}
// add stored db info
if (addStoredTopology)
{
int valid = 0;
PersistentStore *pStore = get_lib_store();
if (pStore)
{
if ((get_config_value_int(SQL_KEY_TOPOLOGY_STATE_VALID, &valid) == COMMON_SUCCESS) &&
(valid))
{
int topoStateCount = 0;
if (db_get_topology_state_count(pStore, &topoStateCount) == DB_SUCCESS &&
topoStateCount > 0)
{
// Populate the previous topology state map
struct db_topology_state topologyState[topoStateCount];
if (db_get_topology_states(pStore, topologyState, topoStateCount) == topoStateCount)
{
for (int i = 0; i < topoStateCount; i++)
{
std::string uidStr = topologyState[i].uid;
if (map.find(uidStr) == map.end()) // doesn't exist - missing dimm
{
struct deviceInfo devInfo;
memset(&devInfo, 0, sizeof (deviceInfo));
devInfo.discovered = false;
devInfo.stored = true;
devInfo.storedState = topologyState[i];
map[uidStr] = devInfo;
}
else
{
map[uidStr].stored = true;
map[uidStr].storedState = topologyState[i];
}
}
}
}
}
}
}
}
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");
}
}
}
