// Copyright(c) 2018-2020, Intel Corporation
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of Intel Corporation nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
/**
* \file threshold.c
* \brief fpga sensor threshold functions
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif // HAVE_CONFIG_H
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <glob.h>
#include "types_int.h"
#include "metrics_int.h"
#include "common_int.h"
#include "metrics/bmc/bmc.h"
#include "metrics_int.h"
#include "metrics_max10.h"
#include "threshold.h"
fpga_result xfpga_fpgaGetMetricsThresholdInfo(fpga_handle handle,
metric_threshold *metric_thresholds,
uint32_t *num_thresholds)
{
fpga_result result = FPGA_OK;
struct _fpga_token *_token = NULL;
enum fpga_hw_type hw_type = FPGA_HW_UNKNOWN;
fpga_objtype objtype;
if (handle == NULL ||
(metric_thresholds == NULL &&
num_thresholds == NULL)) {
OPAE_ERR("Invalid input parameters");
return FPGA_INVALID_PARAM;
}
struct _fpga_handle *_handle = (struct _fpga_handle *)handle;
_token = (struct _fpga_token *)_handle->token;
if (_token == NULL) {
OPAE_ERR("Invalid token within handle");
return FPGA_INVALID_PARAM;
}
result = get_fpga_object_type(handle, &objtype);
if (result != FPGA_OK) {
OPAE_ERR("Failed to object type");
return result;
}
if (objtype != FPGA_DEVICE) {
OPAE_ERR("FPGA object type is not FPGA DEVICE ");
return result;
}
// get fpga hw type.
result = get_fpga_hw_type(_handle, &hw_type);
if (result != FPGA_OK) {
OPAE_ERR("Failed to discover hardware type.");
return result;
}
switch (hw_type) {
// MCP
case FPGA_HW_MCP: {
OPAE_ERR("Not Supported MCP thresholds.");
result = FPGA_EXCEPTION;
}
break;
// DCP RC
case FPGA_HW_DCP_RC: {
result = get_bmc_threshold_info(handle,
metric_thresholds, num_thresholds);
if (result != FPGA_OK) {
OPAE_ERR("Failed to get bmc thresholds.");
return result;
}
}
break;
// VC DC
case FPGA_HW_DCP_DC:
case FPGA_HW_DCP_VC: {
// Max10
result = get_max10_threshold_info(handle,
metric_thresholds, num_thresholds);
if (result != FPGA_OK) {
OPAE_ERR("Failed to get max10 thresholds.");
return result;
}
}
break;
default:
OPAE_ERR("Unknown Device ID.");
result = FPGA_EXCEPTION;
}
return result;
}
fpga_result get_bmc_threshold_info(fpga_handle handle,
metric_threshold *metric_thresholds,
uint32_t *num_thresholds)
{
fpga_result result = FPGA_OK;
fpga_result resval = FPGA_OK;
uint32_t num_sensors = 0;
uint32_t num_values = 0;
uint32_t x = 0;
sdr_details details;
bmc_sdr_handle records;
bmc_values_handle values;
size_t len;
if (handle == NULL ||
num_thresholds == NULL) {
OPAE_ERR("Invalid input parameters");
return FPGA_INVALID_PARAM;
}
struct _fpga_handle *_handle = (struct _fpga_handle *)handle;
if (pthread_mutex_lock(&_handle->lock)) {
OPAE_ERR("pthread_mutex_lock failed");
return FPGA_EXCEPTION;
}
if (_handle->bmc_handle == NULL)
_handle->bmc_handle = metrics_load_bmc_lib();
if (!_handle->bmc_handle) {
OPAE_ERR("Failed to load BMC module %s", dlerror());
if (pthread_mutex_unlock(&_handle->lock)) {
OPAE_ERR("pthread_mutex_unlock failed");
}
return FPGA_EXCEPTION;
}
if (pthread_mutex_unlock(&_handle->lock)) {
OPAE_ERR("pthread_mutex_unlock failed");
}
result = xfpga_bmcLoadSDRs(_handle, &records, &num_sensors);
if (result != FPGA_OK) {
OPAE_ERR("Failed to load BMC SDR.");
return result;
}
result = xfpga_bmcReadSensorValues(_handle, records, &values, &num_values);
if (result != FPGA_OK) {
OPAE_ERR("Failed to read BMC sensor values.");
goto destroy_sdr;
}
// Return number of thresholds.
if (metric_thresholds == NULL && num_thresholds != NULL) {
*num_thresholds = num_values;
goto destroy_values;
}
// Return number of threshold info and value.
if (metric_thresholds != NULL && num_thresholds != NULL) {
for (x = 0; x < num_sensors; x++) {
// Sensor Name
result = xfpga_bmcGetSDRDetails(_handle, values, x, &details);
if (result != FPGA_OK) {
OPAE_MSG("Failed to read sensor readings.");
continue;
}
len = strnlen(details.name, sizeof(metric_thresholds[x].metric_name) - 1);
memcpy(metric_thresholds[x].metric_name, details.name, len);
metric_thresholds[x].metric_name[len] = '\0';
// Upper Non-Recoverable Threshold
if (details.thresholds.upper_nr_thresh.is_valid) {
len = strnlen(UPPER_NR_THRESHOLD,
sizeof(metric_thresholds[x].upper_nr_threshold.threshold_name) - 1);
memcpy(metric_thresholds[x].upper_nr_threshold.threshold_name,
UPPER_NR_THRESHOLD, len);
metric_thresholds[x].upper_nr_threshold.threshold_name[len] = '\0';
metric_thresholds[x].upper_nr_threshold.value = details.thresholds.upper_nr_thresh.value;
metric_thresholds[x].upper_nr_threshold.is_valid = true;
}
// Upper Critical Threshold
if (details.thresholds.upper_c_thresh.is_valid) {
len = strnlen(UPPER_C_THRESHOLD,
sizeof(metric_thresholds[x].upper_c_threshold.threshold_name) - 1);
memcpy(metric_thresholds[x].upper_c_threshold.threshold_name,
UPPER_C_THRESHOLD, len);
metric_thresholds[x].upper_c_threshold.threshold_name[len] = '\0';
metric_thresholds[x].upper_c_threshold.value = details.thresholds.upper_c_thresh.value;
metric_thresholds[x].upper_c_threshold.is_valid = true;
}
// Upper Non-Critical Threshold
if (details.thresholds.upper_nc_thresh.is_valid) {
len = strnlen(UPPER_NC_THRESHOLD,
sizeof(metric_thresholds[x].upper_nc_threshold.threshold_name) - 1);
memcpy(metric_thresholds[x].upper_nc_threshold.threshold_name,
UPPER_NC_THRESHOLD, len);
metric_thresholds[x].upper_nc_threshold.threshold_name[len] = '\0';
metric_thresholds[x].upper_nc_threshold.value = details.thresholds.upper_nc_thresh.value;
metric_thresholds[x].upper_nc_threshold.is_valid = true;
}
// Lower Non-Recoverable Threshold
if (details.thresholds.lower_nr_thresh.is_valid) {
len = strnlen(LOWER_NR_THRESHOLD,
sizeof(metric_thresholds[x].lower_nr_threshold.threshold_name) - 1);
memcpy(metric_thresholds[x].lower_nr_threshold.threshold_name,
LOWER_NR_THRESHOLD, len);
metric_thresholds[x].lower_nr_threshold.threshold_name[len] = '\0';
metric_thresholds[x].lower_nr_threshold.value = details.thresholds.lower_nr_thresh.value;
metric_thresholds[x].lower_nr_threshold.is_valid = true;
}
// Lower Critical Threshold
if (details.thresholds.lower_c_thresh.is_valid) {
len = strnlen(LOWER_C_THRESHOLD,
sizeof(metric_thresholds[x].lower_c_threshold.threshold_name) - 1);
memcpy(metric_thresholds[x].lower_c_threshold.threshold_name,
LOWER_C_THRESHOLD, len);
metric_thresholds[x].lower_c_threshold.threshold_name[len] = '\0';
metric_thresholds[x].lower_c_threshold.value = details.thresholds.lower_c_thresh.value;
metric_thresholds[x].lower_c_threshold.is_valid = true;
}
// Lower Non-Critical Threshold
if (details.thresholds.lower_nc_thresh.is_valid) {
len = strnlen(LOWER_NC_THRESHOLD,
sizeof(metric_thresholds[x].lower_nc_threshold.threshold_name) - 1);
memcpy(metric_thresholds[x].lower_nc_threshold.threshold_name,
LOWER_NC_THRESHOLD, len);
metric_thresholds[x].lower_nc_threshold.threshold_name[len] = '\0';
metric_thresholds[x].lower_nc_threshold.value = details.thresholds.lower_nc_thresh.value;
metric_thresholds[x].lower_nc_threshold.is_valid = true;
}
} // for loop end
} // endif
destroy_values:
resval = (result != FPGA_OK) ? result : resval;
result = xfpga_bmcDestroySensorValues(_handle, &values);
if (result != FPGA_OK) {
OPAE_MSG("Failed to Destroy Sensor value.");
}
destroy_sdr:
resval = (result != FPGA_OK) ? result : resval;
result = xfpga_bmcDestroySDRs(_handle, &records);
if (result != FPGA_OK) {
OPAE_ERR("Failed to Destroy SDR.");
}
resval = (result != FPGA_OK) ? result : resval;
return resval;
}
fpga_result get_max10_threshold_info(fpga_handle handle,
metric_threshold *metric_thresholds,
uint32_t *num_thresholds)
{
fpga_result result = FPGA_OK;
fpga_result resval = FPGA_OK;
char sysfspath[SYSFS_PATH_MAX] = { 0, };
size_t i = 0;
struct _fpga_token *_token = NULL;
char *tmp = NULL;
uint32_t tot_bytes = 0;
uint64_t value = 0;
glob_t pglob;
size_t len;
if (handle == NULL ||
num_thresholds == NULL) {
OPAE_ERR("Invalid input parameters");
return FPGA_INVALID_PARAM;
}
struct _fpga_handle *_handle = (struct _fpga_handle *)handle;
_token = (struct _fpga_token *)_handle->token;
if (_token == NULL) {
OPAE_ERR("Invalid token within handle");
return FPGA_INVALID_PARAM;
}
// Sensor path
if (snprintf(sysfspath, sizeof(sysfspath),
"%s/%s", _token->sysfspath, MAX10_SYSFS_PATH) < 0) {
OPAE_ERR("buffer overflow in snprintf");
return FPGA_EXCEPTION;
}
int gres = glob(sysfspath, GLOB_NOSORT, NULL, &pglob);
if ((gres) || (1 != pglob.gl_pathc)) {
OPAE_ERR("Failed pattern match %s: %s", sysfspath, strerror(errno));
globfree(&pglob);
return FPGA_NOT_FOUND;
}
globfree(&pglob);
// scan sensors
if (snprintf(sysfspath, sizeof(sysfspath),
"%s/%s", _token->sysfspath, MAX10_SENSOR_SYSFS_PATH) < 0) {
OPAE_ERR("buffer overflow in snprintf");
return FPGA_EXCEPTION;
}
gres = glob(sysfspath, GLOB_NOSORT, NULL, &pglob);
if (gres) {
OPAE_ERR("Failed pattern match %s: %s", sysfspath, strerror(errno));
globfree(&pglob);
return FPGA_NOT_FOUND;
}
if (metric_thresholds == NULL && num_thresholds != NULL) {
*num_thresholds = pglob.gl_pathc;
goto out;
}
// read thresholds
for (i = 0; i < pglob.gl_pathc; i++) {
// Sensor name
result = read_sensor_sysfs_file(pglob.gl_pathv[i], SENSOR_SYSFS_NAME, (void **)&tmp, &tot_bytes);
if (FPGA_OK != result || !tmp) {
if (tmp) {
free(tmp);
tmp = NULL;
}
continue;
}
memset(&metric_thresholds[i].metric_name, 0, sizeof(metric_thresholds[i].metric_name));
len = strnlen(tmp, sizeof(metric_thresholds[i].metric_name) - 1);
memcpy(metric_thresholds[i].metric_name, tmp, len);
metric_thresholds[i].metric_name[len] = '\0';
if (tmp) {
free(tmp);
tmp = NULL;
}
// Upper Critical Threshold
len = strnlen(UPPER_C_THRESHOLD,
sizeof(metric_thresholds[i].upper_c_threshold.threshold_name) - 1);
memcpy(metric_thresholds[i].upper_c_threshold.threshold_name,
UPPER_C_THRESHOLD, len);
metric_thresholds[i].upper_c_threshold.threshold_name[len] = '\0';
snprintf(sysfspath, sizeof(sysfspath),
"%s/%s", pglob.gl_pathv[i], SYSFS_HIGH_FATAL);
resval = sysfs_read_u64(sysfspath, &value);
if (resval == FPGA_OK) {
metric_thresholds[i].upper_c_threshold.value = ((double)value / MILLI);
metric_thresholds[i].upper_c_threshold.is_valid = true;
}
// Upper Non-Critical Threshold
len = strnlen(UPPER_NC_THRESHOLD,
sizeof(metric_thresholds[i].upper_nc_threshold.threshold_name) - 1);
memcpy(metric_thresholds[i].upper_nc_threshold.threshold_name,
UPPER_NC_THRESHOLD, len);
metric_thresholds[i].upper_nc_threshold.threshold_name[len] = '\0';
snprintf(sysfspath, sizeof(sysfspath),
"%s/%s", pglob.gl_pathv[i], SYSFS_HIGH_WARN);
resval = sysfs_read_u64(sysfspath, &value);
if (resval == FPGA_OK) {
metric_thresholds[i].upper_nc_threshold.value = ((double)value / MILLI);
metric_thresholds[i].upper_nc_threshold.is_valid = true;
}
// Lower Critical Threshold
len = strnlen(LOWER_C_THRESHOLD,
sizeof(metric_thresholds[i].upper_nc_threshold.threshold_name) - 1);
memcpy(metric_thresholds[i].upper_nc_threshold.threshold_name,
LOWER_C_THRESHOLD, len);
metric_thresholds[i].upper_nc_threshold.threshold_name[len] = '\0';
snprintf(sysfspath, sizeof(sysfspath),
"%s/%s", pglob.gl_pathv[i], SYSFS_LOW_FATAL);
resval = sysfs_read_u64(sysfspath, &value);
if (resval == FPGA_OK) {
metric_thresholds[i].lower_c_threshold.value = ((double)value / MILLI);
metric_thresholds[i].lower_c_threshold.is_valid = true;
}
// Lower Non-Critical Threshold
len = strnlen(LOWER_NC_THRESHOLD,
sizeof(metric_thresholds[i].lower_nc_threshold.threshold_name) - 1);
memcpy(metric_thresholds[i].lower_nc_threshold.threshold_name,
LOWER_NC_THRESHOLD, len);
metric_thresholds[i].lower_nc_threshold.threshold_name[len] = '\0';
snprintf(sysfspath, sizeof(sysfspath),
"%s/%s", pglob.gl_pathv[i], SYSFS_LOW_WARN);
resval = sysfs_read_u64(sysfspath, &value);
if (resval == FPGA_OK) {
metric_thresholds[i].lower_nc_threshold.value = ((double)value / MILLI);
metric_thresholds[i].lower_nc_threshold.is_valid = true;
}
// Lower Non-Critical Threshold
len = strnlen(SYSFS_HYSTERESIS,
sizeof(metric_thresholds[i].hysteresis.threshold_name) - 1);
memcpy(metric_thresholds[i].hysteresis.threshold_name,
SYSFS_HYSTERESIS, len);
metric_thresholds[i].hysteresis.threshold_name[len] = '\0';
snprintf(sysfspath, sizeof(sysfspath),
"%s/%s", pglob.gl_pathv[i], SYSFS_HYSTERESIS);
resval = sysfs_read_u64(sysfspath, &value);
if (resval == FPGA_OK) {
metric_thresholds[i].hysteresis.value = ((double)value / MILLI);
metric_thresholds[i].hysteresis.is_valid = true;
}
} //end for loop
out:
globfree(&pglob);
return result;
}