blob: 0f7aaafa2e53ef86359b5a4d6fcd53779b5db95b [file] [log] [blame]
#pragma once
#include "config.h"
#include "occ_errors.hpp"
#include "occ_events.hpp"
#include "occ_ffdc.hpp"
#include "occ_presence.hpp"
#include "powermode.hpp"
#include <org/open_power/OCC/Device/error.hpp>
#include <filesystem>
#include <fstream>
#include <regex>
namespace open_power
{
namespace occ
{
class Manager;
class Status;
namespace fs = std::filesystem;
using namespace sdbusplus::org::open_power::OCC::Device::Error;
/** @class Device
* @brief Binds and unbinds the OCC driver upon request
*/
class Device
{
public:
Device() = delete;
~Device() = default;
Device(const Device&) = delete;
Device& operator=(const Device&) = delete;
Device(Device&&) = default;
Device& operator=(Device&&) = default;
/** @brief Constructs the Device object
*
* @param[in] event - Unique ptr reference to sd_event
* @param[in] path - Path to the OCC instance
* @param[in] manager - OCC manager instance
* @param[in] status - Status instance
* @param[in] instance - OCC instance number
*/
Device(EventPtr& event, const fs::path& path, Manager& manager,
Status& status,
#ifdef POWER10
std::unique_ptr<powermode::PowerMode>& powerModeRef,
#endif
unsigned int instance = 0) :
devPath(path), instance(instance), statusObject(status),
managerObject(manager),
error(event, path / "occ_error",
std::bind(std::mem_fn(&Device::errorCallback), this,
std::placeholders::_1)),
timeout(event,
path /
fs::path("../../sbefifo" + std::to_string(instance + 1)) /
"timeout",
#ifdef PLDM
std::bind(std::mem_fn(&Device::timeoutCallback), this,
std::placeholders::_1)
#else
nullptr
#endif
),
ffdc(event, path / "ffdc", instance),
presence(event, path / "occs_present", manager,
std::bind(std::mem_fn(&Device::errorCallback), this,
std::placeholders::_1)),
throttleProcTemp(
event, path / "occ_dvfs_overtemp",
std::bind(std::mem_fn(&Device::throttleProcTempCallback), this,
std::placeholders::_1)),
throttleProcPower(
event, path / "occ_dvfs_power",
std::bind(std::mem_fn(&Device::throttleProcPowerCallback), this,
std::placeholders::_1)),
throttleMemTemp(event, path / "occ_mem_throttle",
std::bind(std::mem_fn(&Device::throttleMemTempCallback),
this, std::placeholders::_1))
#ifdef POWER10
,
pmode(powerModeRef)
#endif
{
// Nothing to do here
}
/** @brief Sets the device active or inactive
*
* @param[in] active - Indicates whether or not to set the device active
*/
void setActive(bool active);
/** @brief Starts to monitor for errors
*
* @param[in] poll - Indicates whether or not the error file should
* actually be polled for changes. Disabling polling is
* necessary for error files that don't support the poll
* file operation.
*/
inline void addErrorWatch(bool poll = true)
{
try
{
throttleProcTemp.addWatch(poll);
}
catch (const OpenFailure& e)
{
// try the old kernel version
throttleProcTemp.setFile(devPath / "occ_dvfs_ot");
throttleProcTemp.addWatch(poll);
}
#ifdef POWER10
if (master())
{
pmode->addIpsWatch(poll);
}
#endif
throttleProcPower.addWatch(poll);
throttleMemTemp.addWatch(poll);
try
{
ffdc.addWatch(poll);
}
catch (const OpenFailure& e)
{
// nothing to do if there is no FFDC file
}
try
{
timeout.addWatch(poll);
}
catch (const std::exception& e)
{
// nothing to do if there is no SBE timeout file
}
error.addWatch(poll);
}
/** @brief stops monitoring for errors */
inline void removeErrorWatch()
{
// we can always safely remove watch even if we don't add it
presence.removeWatch();
ffdc.removeWatch();
error.removeWatch();
timeout.removeWatch();
throttleMemTemp.removeWatch();
throttleProcPower.removeWatch();
throttleProcTemp.removeWatch();
#ifdef POWER10
if (master())
{
pmode->removeIpsWatch();
}
#endif
}
/** @brief Starts to watch how many OCCs are present on the master */
inline void addPresenceWatchMaster()
{
if (master())
{
presence.addWatch();
}
}
/** @brief helper function to get the last part of the path
*
* @param[in] path - Path to parse
* @return - Last directory name in the path
*/
static std::string getPathBack(const fs::path& path);
/** @brief Returns true if the device is active */
bool active() const;
/** @brief Returns true if device represents the master OCC */
bool master() const;
private:
/** @brief This directory contains the error files */
const fs::path devPath;
/** @brief OCC instance ID */
const unsigned int instance;
/** Store the associated Status instance */
Status& statusObject;
/** Store the parent Manager instance */
Manager& managerObject;
/** Abstraction of error monitoring */
Error error;
/** Abstraction of SBE timeout monitoring */
Error timeout;
/** SBE FFDC monitoring */
FFDC ffdc;
/** Abstraction of OCC presence monitoring */
Presence presence;
/** Error instances for watching for throttling events */
Error throttleProcTemp;
Error throttleProcPower;
Error throttleMemTemp;
#ifdef POWER10
/** @brief OCC PowerMode object */
std::unique_ptr<powermode::PowerMode>& pmode;
#endif
/** @brief file reader to read a binary string ("1" or "0")
*
* @param[in] fileName - Name of file to be read
* @return - The value returned by reading the file
*/
bool readBinary(const std::string& fileName) const;
/** @brief file writer to achieve bind and unbind
*
* @param[in] filename - Name of file to be written
* @param[in] data - Data to be written to
* @return - None
*/
void write(const fs::path& fileName, const std::string& data)
{
// If there is an error, move the exception all the way up
std::ofstream file(fileName, std::ios::out);
file << data;
file.close();
return;
}
/** @brief callback for OCC error monitoring
*
* @param[in] error - Errno stored in the error file, 0 if no error
*/
void errorCallback(int error);
/** @brief callback for OCC presence monitoring
*
* @param[in] occsPresent - The number of OCCs indicated in the poll
* response
*/
void presenceCallback(int occsPresent);
#ifdef PLDM
/** @brief callback for SBE timeout monitoring
*
* @param[in] error - True if an error is reported, false otherwise
*/
void timeoutCallback(int error);
#endif
/** @brief callback for the proc temp throttle event
*
* @param[in] error - True if an error is reported, false otherwise
*/
void throttleProcTempCallback(int error);
/** @brief callback for the proc power throttle event
*
* @param[in] error - True if an error is reported, false otherwise
*/
void throttleProcPowerCallback(int error);
/** @brief callback for the proc temp throttle event
*
* @param[in] error - True if an error is reported, false otherwise
*/
void throttleMemTempCallback(int error);
/** @brief Get the pathname for a file based on a regular expression
*
* @param[in] basePath - The path where the files will be checked
* @param[in] expr - Regular expression describing the target file
*
* @return path to the file or empty path if not found
*/
fs::path getFilenameByRegex(fs::path basePath,
const std::regex& expr) const;
};
} // namespace occ
} // namespace open_power