1 /** 2 * Copyright © 2020 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #include "json_parser.hpp" 17 18 #include "conditions.hpp" 19 #include "json_config.hpp" 20 #include "nonzero_speed_trust.hpp" 21 #include "power_interface.hpp" 22 #include "power_off_rule.hpp" 23 #include "tach_sensor.hpp" 24 #include "types.hpp" 25 26 #include <fmt/format.h> 27 28 #include <nlohmann/json.hpp> 29 #include <phosphor-logging/log.hpp> 30 31 #include <algorithm> 32 #include <map> 33 #include <memory> 34 #include <optional> 35 #include <vector> 36 37 namespace phosphor::fan::monitor 38 { 39 40 using json = nlohmann::json; 41 using namespace phosphor::logging; 42 43 namespace tClass 44 { 45 46 // Get a constructed trust group class for a non-zero speed group 47 CreateGroupFunction 48 getNonZeroSpeed(const std::vector<trust::GroupDefinition>& group) 49 { 50 return [group]() { 51 return std::make_unique<trust::NonzeroSpeed>(std::move(group)); 52 }; 53 } 54 55 } // namespace tClass 56 57 const std::map<std::string, trustHandler> trusts = { 58 {"nonzerospeed", tClass::getNonZeroSpeed}}; 59 const std::map<std::string, condHandler> conditions = { 60 {"propertiesmatch", condition::getPropertiesMatch}}; 61 const std::map<std::string, size_t> methods = { 62 {"timebased", MethodMode::timebased}, {"count", MethodMode::count}}; 63 64 const std::vector<CreateGroupFunction> getTrustGrps(const json& obj) 65 { 66 std::vector<CreateGroupFunction> grpFuncs; 67 68 if (obj.contains("sensor_trust_groups")) 69 { 70 for (auto& stg : obj["sensor_trust_groups"]) 71 { 72 if (!stg.contains("class") || !stg.contains("group")) 73 { 74 // Log error on missing required parameters 75 log<level::ERR>( 76 "Missing required fan monitor trust group parameters", 77 entry("REQUIRED_PARAMETERS=%s", "{class, group}")); 78 throw std::runtime_error( 79 "Missing required fan trust group parameters"); 80 } 81 auto tgClass = stg["class"].get<std::string>(); 82 std::vector<trust::GroupDefinition> group; 83 for (auto& member : stg["group"]) 84 { 85 // Construct list of group members 86 if (!member.contains("name")) 87 { 88 // Log error on missing required parameter 89 log<level::ERR>( 90 "Missing required fan monitor trust group member name", 91 entry("CLASS=%s", tgClass.c_str())); 92 throw std::runtime_error( 93 "Missing required fan monitor trust group member name"); 94 } 95 auto in_trust = true; 96 if (member.contains("in_trust")) 97 { 98 in_trust = member["in_trust"].get<bool>(); 99 } 100 group.emplace_back(trust::GroupDefinition{ 101 member["name"].get<std::string>(), in_trust}); 102 } 103 // The class for fan sensor trust groups 104 // (Must have a supported function within the tClass namespace) 105 std::transform(tgClass.begin(), tgClass.end(), tgClass.begin(), 106 tolower); 107 auto handler = trusts.find(tgClass); 108 if (handler != trusts.end()) 109 { 110 // Call function for trust group class 111 grpFuncs.emplace_back(handler->second(group)); 112 } 113 else 114 { 115 // Log error on unsupported trust group class 116 log<level::ERR>("Invalid fan monitor trust group class", 117 entry("CLASS=%s", tgClass.c_str())); 118 throw std::runtime_error( 119 "Invalid fan monitor trust group class"); 120 } 121 } 122 } 123 124 return grpFuncs; 125 } 126 127 const std::vector<SensorDefinition> getSensorDefs(const json& sensors) 128 { 129 std::vector<SensorDefinition> sensorDefs; 130 131 for (const auto& sensor : sensors) 132 { 133 if (!sensor.contains("name") || !sensor.contains("has_target")) 134 { 135 // Log error on missing required parameters 136 log<level::ERR>( 137 "Missing required fan sensor definition parameters", 138 entry("REQUIRED_PARAMETERS=%s", "{name, has_target}")); 139 throw std::runtime_error( 140 "Missing required fan sensor definition parameters"); 141 } 142 // Target interface is optional and defaults to 143 // 'xyz.openbmc_project.Control.FanSpeed' 144 std::string targetIntf = "xyz.openbmc_project.Control.FanSpeed"; 145 if (sensor.contains("target_interface")) 146 { 147 targetIntf = sensor["target_interface"].get<std::string>(); 148 } 149 // Factor is optional and defaults to 1 150 auto factor = 1.0; 151 if (sensor.contains("factor")) 152 { 153 factor = sensor["factor"].get<double>(); 154 } 155 // Offset is optional and defaults to 0 156 auto offset = 0; 157 if (sensor.contains("offset")) 158 { 159 offset = sensor["offset"].get<int64_t>(); 160 } 161 // Threshold is optional and defaults to 1 162 auto threshold = 1; 163 if (sensor.contains("threshold")) 164 { 165 threshold = sensor["threshold"].get<size_t>(); 166 } 167 168 sensorDefs.emplace_back(std::tuple( 169 sensor["name"].get<std::string>(), sensor["has_target"].get<bool>(), 170 targetIntf, factor, offset, threshold)); 171 } 172 173 return sensorDefs; 174 } 175 176 const std::vector<FanDefinition> getFanDefs(const json& obj) 177 { 178 std::vector<FanDefinition> fanDefs; 179 180 for (const auto& fan : obj["fans"]) 181 { 182 if (!fan.contains("inventory") || !fan.contains("deviation") || 183 !fan.contains("sensors")) 184 { 185 // Log error on missing required parameters 186 log<level::ERR>( 187 "Missing required fan monitor definition parameters", 188 entry("REQUIRED_PARAMETERS=%s", 189 "{inventory, deviation, sensors}")); 190 throw std::runtime_error( 191 "Missing required fan monitor definition parameters"); 192 } 193 // Valid deviation range is 0 - 100% 194 auto deviation = fan["deviation"].get<size_t>(); 195 if (deviation < 0 || 100 < deviation) 196 { 197 auto msg = 198 fmt::format( 199 "Invalid deviation of {} found, must be between 0 and 100", 200 deviation) 201 .c_str(); 202 log<level::ERR>(msg); 203 throw std::runtime_error(msg); 204 } 205 206 // Construct the sensor definitions for this fan 207 auto sensorDefs = getSensorDefs(fan["sensors"]); 208 209 // Functional delay is optional and defaults to 0 210 size_t funcDelay = 0; 211 if (fan.contains("functional_delay")) 212 { 213 funcDelay = fan["functional_delay"].get<size_t>(); 214 } 215 216 // Method is optional and defaults to time based functional 217 // determination 218 size_t method = MethodMode::timebased; 219 size_t countInterval = 1; 220 if (fan.contains("method")) 221 { 222 auto methodConf = fan["method"].get<std::string>(); 223 auto methodFunc = methods.find(methodConf); 224 if (methodFunc != methods.end()) 225 { 226 method = methodFunc->second; 227 } 228 else 229 { 230 // Log error on unsupported method parameter 231 log<level::ERR>("Invalid fan method"); 232 throw std::runtime_error("Invalid fan method"); 233 } 234 235 // Read the count interval value used with the count method. 236 if (method == MethodMode::count) 237 { 238 if (fan.contains("count_interval")) 239 { 240 countInterval = fan["count_interval"].get<size_t>(); 241 } 242 } 243 } 244 245 // Timeout defaults to 0 246 size_t timeout = 0; 247 if (method == MethodMode::timebased) 248 { 249 if (!fan.contains("allowed_out_of_range_time")) 250 { 251 // Log error on missing required parameter 252 log<level::ERR>( 253 "Missing required fan monitor definition parameters", 254 entry("REQUIRED_PARAMETER=%s", 255 "{allowed_out_of_range_time}")); 256 throw std::runtime_error( 257 "Missing required fan monitor definition parameters"); 258 } 259 else 260 { 261 timeout = fan["allowed_out_of_range_time"].get<size_t>(); 262 } 263 } 264 265 // Monitor start delay is optional and defaults to 0 266 size_t monitorDelay = 0; 267 if (fan.contains("monitor_start_delay")) 268 { 269 monitorDelay = fan["monitor_start_delay"].get<size_t>(); 270 } 271 272 // num_sensors_nonfunc_for_fan_nonfunc is optional and defaults 273 // to zero if not present, meaning the code will not set the 274 // parent fan to nonfunctional based on sensors. 275 size_t nonfuncSensorsCount = 0; 276 if (fan.contains("num_sensors_nonfunc_for_fan_nonfunc")) 277 { 278 nonfuncSensorsCount = 279 fan["num_sensors_nonfunc_for_fan_nonfunc"].get<size_t>(); 280 } 281 282 // nonfunc_rotor_error_delay is optional, though it will 283 // default to zero if 'fault_handling' is present. 284 std::optional<size_t> nonfuncRotorErrorDelay; 285 if (fan.contains("nonfunc_rotor_error_delay")) 286 { 287 nonfuncRotorErrorDelay = 288 fan["nonfunc_rotor_error_delay"].get<size_t>(); 289 } 290 else if (obj.contains("fault_handling")) 291 { 292 nonfuncRotorErrorDelay = 0; 293 } 294 295 // fan_missing_error_delay is optional. 296 std::optional<size_t> fanMissingErrorDelay; 297 if (fan.contains("fan_missing_error_delay")) 298 { 299 fanMissingErrorDelay = 300 fan.at("fan_missing_error_delay").get<size_t>(); 301 } 302 303 // Handle optional conditions 304 auto cond = std::optional<Condition>(); 305 if (fan.contains("condition")) 306 { 307 if (!fan["condition"].contains("name")) 308 { 309 // Log error on missing required parameter 310 log<level::ERR>( 311 "Missing required fan monitor condition parameter", 312 entry("REQUIRED_PARAMETER=%s", "{name}")); 313 throw std::runtime_error( 314 "Missing required fan monitor condition parameter"); 315 } 316 auto name = fan["condition"]["name"].get<std::string>(); 317 // The function for fan monitoring condition 318 // (Must have a supported function within the condition namespace) 319 std::transform(name.begin(), name.end(), name.begin(), tolower); 320 auto handler = conditions.find(name); 321 if (handler != conditions.end()) 322 { 323 cond = handler->second(fan["condition"]); 324 } 325 else 326 { 327 log<level::INFO>( 328 "No handler found for configured condition", 329 entry("CONDITION_NAME=%s", name.c_str()), 330 entry("JSON_DUMP=%s", fan["condition"].dump().c_str())); 331 } 332 } 333 334 // if the fan should be set to functional when plugged in 335 bool setFuncOnPresent = false; 336 if (fan.contains("set_func_on_present")) 337 { 338 setFuncOnPresent = fan["set_func_on_present"].get<bool>(); 339 } 340 341 fanDefs.emplace_back(std::tuple( 342 fan["inventory"].get<std::string>(), method, funcDelay, timeout, 343 deviation, nonfuncSensorsCount, monitorDelay, countInterval, 344 nonfuncRotorErrorDelay, fanMissingErrorDelay, sensorDefs, cond, 345 setFuncOnPresent)); 346 } 347 348 return fanDefs; 349 } 350 351 PowerRuleState getPowerOffPowerRuleState(const json& powerOffConfig) 352 { 353 // The state is optional and defaults to runtime 354 PowerRuleState ruleState{PowerRuleState::runtime}; 355 356 if (powerOffConfig.contains("state")) 357 { 358 auto state = powerOffConfig.at("state").get<std::string>(); 359 if (state == "at_pgood") 360 { 361 ruleState = PowerRuleState::atPgood; 362 } 363 else if (state != "runtime") 364 { 365 auto msg = fmt::format("Invalid power off state entry {}", state); 366 log<level::ERR>(msg.c_str()); 367 throw std::runtime_error(msg.c_str()); 368 } 369 } 370 371 return ruleState; 372 } 373 374 std::unique_ptr<PowerOffCause> getPowerOffCause(const json& powerOffConfig) 375 { 376 std::unique_ptr<PowerOffCause> cause; 377 378 if (!powerOffConfig.contains("count") || !powerOffConfig.contains("cause")) 379 { 380 const auto msg = 381 "Missing 'count' or 'cause' entries in power off config"; 382 log<level::ERR>(msg); 383 throw std::runtime_error(msg); 384 } 385 386 auto count = powerOffConfig.at("count").get<size_t>(); 387 auto powerOffCause = powerOffConfig.at("cause").get<std::string>(); 388 389 const std::map<std::string, std::function<std::unique_ptr<PowerOffCause>()>> 390 causes{ 391 {"missing_fan_frus", 392 [count]() { return std::make_unique<MissingFanFRUCause>(count); }}, 393 {"nonfunc_fan_rotors", [count]() { 394 return std::make_unique<NonfuncFanRotorCause>(count); 395 }}}; 396 397 auto it = causes.find(powerOffCause); 398 if (it != causes.end()) 399 { 400 cause = it->second(); 401 } 402 else 403 { 404 auto msg = 405 fmt::format("Invalid power off cause {} in power off config JSON", 406 powerOffCause); 407 log<level::ERR>(msg.c_str()); 408 throw std::runtime_error(msg.c_str()); 409 } 410 411 return cause; 412 } 413 414 std::unique_ptr<PowerOffAction> 415 getPowerOffAction(const json& powerOffConfig, 416 std::shared_ptr<PowerInterfaceBase>& powerInterface, 417 PowerOffAction::PrePowerOffFunc& func) 418 { 419 std::unique_ptr<PowerOffAction> action; 420 if (!powerOffConfig.contains("type")) 421 { 422 const auto msg = "Missing 'type' entry in power off config"; 423 log<level::ERR>(msg); 424 throw std::runtime_error(msg); 425 } 426 427 auto type = powerOffConfig.at("type").get<std::string>(); 428 429 if (((type == "hard") || (type == "soft")) && 430 !powerOffConfig.contains("delay")) 431 { 432 const auto msg = "Missing 'delay' entry in power off config"; 433 log<level::ERR>(msg); 434 throw std::runtime_error(msg); 435 } 436 else if ((type == "epow") && 437 (!powerOffConfig.contains("service_mode_delay") || 438 !powerOffConfig.contains("meltdown_delay"))) 439 { 440 const auto msg = "Missing 'service_mode_delay' or 'meltdown_delay' " 441 "entry in power off config"; 442 log<level::ERR>(msg); 443 throw std::runtime_error(msg); 444 } 445 446 if (type == "hard") 447 { 448 action = std::make_unique<HardPowerOff>( 449 powerOffConfig.at("delay").get<uint32_t>(), powerInterface, func); 450 } 451 else if (type == "soft") 452 { 453 action = std::make_unique<SoftPowerOff>( 454 powerOffConfig.at("delay").get<uint32_t>(), powerInterface, func); 455 } 456 else if (type == "epow") 457 { 458 action = std::make_unique<EpowPowerOff>( 459 powerOffConfig.at("service_mode_delay").get<uint32_t>(), 460 powerOffConfig.at("meltdown_delay").get<uint32_t>(), powerInterface, 461 func); 462 } 463 else 464 { 465 auto msg = 466 fmt::format("Invalid 'type' entry {} in power off config", type); 467 log<level::ERR>(msg.c_str()); 468 throw std::runtime_error(msg.c_str()); 469 } 470 471 return action; 472 } 473 474 std::vector<std::unique_ptr<PowerOffRule>> 475 getPowerOffRules(const json& obj, 476 std::shared_ptr<PowerInterfaceBase>& powerInterface, 477 PowerOffAction::PrePowerOffFunc& func) 478 { 479 std::vector<std::unique_ptr<PowerOffRule>> rules; 480 481 if (!(obj.contains("fault_handling") && 482 obj.at("fault_handling").contains("power_off_config"))) 483 { 484 return rules; 485 } 486 487 for (const auto& config : obj.at("fault_handling").at("power_off_config")) 488 { 489 auto state = getPowerOffPowerRuleState(config); 490 auto cause = getPowerOffCause(config); 491 auto action = getPowerOffAction(config, powerInterface, func); 492 493 auto rule = std::make_unique<PowerOffRule>( 494 std::move(state), std::move(cause), std::move(action)); 495 rules.push_back(std::move(rule)); 496 } 497 498 return rules; 499 } 500 501 std::optional<size_t> getNumNonfuncRotorsBeforeError(const json& obj) 502 { 503 std::optional<size_t> num; 504 505 if (obj.contains("fault_handling")) 506 { 507 // Defaults to 1 if not present inside of 'fault_handling'. 508 num = obj.at("fault_handling") 509 .value("num_nonfunc_rotors_before_error", 1); 510 } 511 512 return num; 513 } 514 515 } // namespace phosphor::fan::monitor 516