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 // Target path is optional 150 std::string targetPath; 151 if (sensor.contains("target_path")) 152 { 153 targetPath = sensor["target_path"].get<std::string>(); 154 } 155 // Factor is optional and defaults to 1 156 double factor = 1.0; 157 if (sensor.contains("factor")) 158 { 159 factor = sensor["factor"].get<double>(); 160 } 161 // Offset is optional and defaults to 0 162 int64_t offset = 0; 163 if (sensor.contains("offset")) 164 { 165 offset = sensor["offset"].get<int64_t>(); 166 } 167 // Threshold is optional and defaults to 1 168 size_t threshold = 1; 169 if (sensor.contains("threshold")) 170 { 171 threshold = sensor["threshold"].get<size_t>(); 172 } 173 // Ignore being above the allowed max is optional, defaults to not 174 bool ignoreAboveMax = false; 175 if (sensor.contains("ignore_above_max")) 176 { 177 ignoreAboveMax = sensor["ignore_above_max"].get<bool>(); 178 } 179 180 SensorDefinition def{.name = sensor["name"].get<std::string>(), 181 .hasTarget = sensor["has_target"].get<bool>(), 182 .targetInterface = targetIntf, 183 .targetPath = targetPath, 184 .factor = factor, 185 .offset = offset, 186 .threshold = threshold, 187 .ignoreAboveMax = ignoreAboveMax}; 188 189 sensorDefs.push_back(std::move(def)); 190 } 191 192 return sensorDefs; 193 } 194 195 const std::vector<FanDefinition> getFanDefs(const json& obj) 196 { 197 std::vector<FanDefinition> fanDefs; 198 199 for (const auto& fan : obj["fans"]) 200 { 201 if (!fan.contains("inventory") || !fan.contains("deviation") || 202 !fan.contains("sensors")) 203 { 204 // Log error on missing required parameters 205 log<level::ERR>( 206 "Missing required fan monitor definition parameters", 207 entry("REQUIRED_PARAMETERS=%s", 208 "{inventory, deviation, sensors}")); 209 throw std::runtime_error( 210 "Missing required fan monitor definition parameters"); 211 } 212 // Valid deviation range is 0 - 100% 213 auto deviation = fan["deviation"].get<size_t>(); 214 if (100 < deviation) 215 { 216 auto msg = fmt::format( 217 "Invalid deviation of {} found, must be between 0 and 100", 218 deviation); 219 220 log<level::ERR>(msg.c_str()); 221 throw std::runtime_error(msg.c_str()); 222 } 223 224 // Upper deviation defaults to the deviation value and 225 // can also be separately specified. 226 size_t upperDeviation = deviation; 227 if (fan.contains("upper_deviation")) 228 { 229 upperDeviation = fan["upper_deviation"].get<size_t>(); 230 if (100 < upperDeviation) 231 { 232 auto msg = 233 fmt::format("Invalid upper_deviation of {} found, must " 234 "be between 0 and 100", 235 upperDeviation); 236 237 log<level::ERR>(msg.c_str()); 238 throw std::runtime_error(msg.c_str()); 239 } 240 } 241 242 // Construct the sensor definitions for this fan 243 auto sensorDefs = getSensorDefs(fan["sensors"]); 244 245 // Functional delay is optional and defaults to 0 246 size_t funcDelay = 0; 247 if (fan.contains("functional_delay")) 248 { 249 funcDelay = fan["functional_delay"].get<size_t>(); 250 } 251 252 // Method is optional and defaults to time based functional 253 // determination 254 size_t method = MethodMode::timebased; 255 size_t countInterval = 1; 256 if (fan.contains("method")) 257 { 258 auto methodConf = fan["method"].get<std::string>(); 259 auto methodFunc = methods.find(methodConf); 260 if (methodFunc != methods.end()) 261 { 262 method = methodFunc->second; 263 } 264 else 265 { 266 // Log error on unsupported method parameter 267 log<level::ERR>("Invalid fan method"); 268 throw std::runtime_error("Invalid fan method"); 269 } 270 271 // Read the count interval value used with the count method. 272 if (method == MethodMode::count) 273 { 274 if (fan.contains("count_interval")) 275 { 276 countInterval = fan["count_interval"].get<size_t>(); 277 } 278 } 279 } 280 281 // Timeout defaults to 0 282 size_t timeout = 0; 283 if (method == MethodMode::timebased) 284 { 285 if (!fan.contains("allowed_out_of_range_time")) 286 { 287 // Log error on missing required parameter 288 log<level::ERR>( 289 "Missing required fan monitor definition parameters", 290 entry("REQUIRED_PARAMETER=%s", 291 "{allowed_out_of_range_time}")); 292 throw std::runtime_error( 293 "Missing required fan monitor definition parameters"); 294 } 295 else 296 { 297 timeout = fan["allowed_out_of_range_time"].get<size_t>(); 298 } 299 } 300 301 // Monitor start delay is optional and defaults to 0 302 size_t monitorDelay = 0; 303 if (fan.contains("monitor_start_delay")) 304 { 305 monitorDelay = fan["monitor_start_delay"].get<size_t>(); 306 } 307 308 // num_sensors_nonfunc_for_fan_nonfunc is optional and defaults 309 // to zero if not present, meaning the code will not set the 310 // parent fan to nonfunctional based on sensors. 311 size_t nonfuncSensorsCount = 0; 312 if (fan.contains("num_sensors_nonfunc_for_fan_nonfunc")) 313 { 314 nonfuncSensorsCount = 315 fan["num_sensors_nonfunc_for_fan_nonfunc"].get<size_t>(); 316 } 317 318 // nonfunc_rotor_error_delay is optional, though it will 319 // default to zero if 'fault_handling' is present. 320 std::optional<size_t> nonfuncRotorErrorDelay; 321 if (fan.contains("nonfunc_rotor_error_delay")) 322 { 323 nonfuncRotorErrorDelay = 324 fan["nonfunc_rotor_error_delay"].get<size_t>(); 325 } 326 else if (obj.contains("fault_handling")) 327 { 328 nonfuncRotorErrorDelay = 0; 329 } 330 331 // fan_missing_error_delay is optional. 332 std::optional<size_t> fanMissingErrorDelay; 333 if (fan.contains("fan_missing_error_delay")) 334 { 335 fanMissingErrorDelay = 336 fan.at("fan_missing_error_delay").get<size_t>(); 337 } 338 339 // Handle optional conditions 340 auto cond = std::optional<Condition>(); 341 if (fan.contains("condition")) 342 { 343 if (!fan["condition"].contains("name")) 344 { 345 // Log error on missing required parameter 346 log<level::ERR>( 347 "Missing required fan monitor condition parameter", 348 entry("REQUIRED_PARAMETER=%s", "{name}")); 349 throw std::runtime_error( 350 "Missing required fan monitor condition parameter"); 351 } 352 auto name = fan["condition"]["name"].get<std::string>(); 353 // The function for fan monitoring condition 354 // (Must have a supported function within the condition namespace) 355 std::transform(name.begin(), name.end(), name.begin(), tolower); 356 auto handler = conditions.find(name); 357 if (handler != conditions.end()) 358 { 359 cond = handler->second(fan["condition"]); 360 } 361 else 362 { 363 log<level::INFO>( 364 "No handler found for configured condition", 365 entry("CONDITION_NAME=%s", name.c_str()), 366 entry("JSON_DUMP=%s", fan["condition"].dump().c_str())); 367 } 368 } 369 370 // if the fan should be set to functional when plugged in 371 bool setFuncOnPresent = false; 372 if (fan.contains("set_func_on_present")) 373 { 374 setFuncOnPresent = fan["set_func_on_present"].get<bool>(); 375 } 376 377 FanDefinition def{.name = fan["inventory"].get<std::string>(), 378 .method = method, 379 .funcDelay = funcDelay, 380 .timeout = timeout, 381 .deviation = deviation, 382 .upperDeviation = upperDeviation, 383 .numSensorFailsForNonfunc = nonfuncSensorsCount, 384 .monitorStartDelay = monitorDelay, 385 .countInterval = countInterval, 386 .nonfuncRotorErrDelay = nonfuncRotorErrorDelay, 387 .fanMissingErrDelay = fanMissingErrorDelay, 388 .sensorList = std::move(sensorDefs), 389 .condition = cond, 390 .funcOnPresent = setFuncOnPresent}; 391 392 fanDefs.push_back(std::move(def)); 393 } 394 395 return fanDefs; 396 } 397 398 PowerRuleState getPowerOffPowerRuleState(const json& powerOffConfig) 399 { 400 // The state is optional and defaults to runtime 401 PowerRuleState ruleState{PowerRuleState::runtime}; 402 403 if (powerOffConfig.contains("state")) 404 { 405 auto state = powerOffConfig.at("state").get<std::string>(); 406 if (state == "at_pgood") 407 { 408 ruleState = PowerRuleState::atPgood; 409 } 410 else if (state != "runtime") 411 { 412 auto msg = fmt::format("Invalid power off state entry {}", state); 413 log<level::ERR>(msg.c_str()); 414 throw std::runtime_error(msg.c_str()); 415 } 416 } 417 418 return ruleState; 419 } 420 421 std::unique_ptr<PowerOffCause> getPowerOffCause(const json& powerOffConfig) 422 { 423 std::unique_ptr<PowerOffCause> cause; 424 425 if (!powerOffConfig.contains("count") || !powerOffConfig.contains("cause")) 426 { 427 const auto msg = 428 "Missing 'count' or 'cause' entries in power off config"; 429 log<level::ERR>(msg); 430 throw std::runtime_error(msg); 431 } 432 433 auto count = powerOffConfig.at("count").get<size_t>(); 434 auto powerOffCause = powerOffConfig.at("cause").get<std::string>(); 435 436 const std::map<std::string, std::function<std::unique_ptr<PowerOffCause>()>> 437 causes{ 438 {"missing_fan_frus", 439 [count]() { return std::make_unique<MissingFanFRUCause>(count); }}, 440 {"nonfunc_fan_rotors", [count]() { 441 return std::make_unique<NonfuncFanRotorCause>(count); 442 }}}; 443 444 auto it = causes.find(powerOffCause); 445 if (it != causes.end()) 446 { 447 cause = it->second(); 448 } 449 else 450 { 451 auto msg = 452 fmt::format("Invalid power off cause {} in power off config JSON", 453 powerOffCause); 454 log<level::ERR>(msg.c_str()); 455 throw std::runtime_error(msg.c_str()); 456 } 457 458 return cause; 459 } 460 461 std::unique_ptr<PowerOffAction> 462 getPowerOffAction(const json& powerOffConfig, 463 std::shared_ptr<PowerInterfaceBase>& powerInterface, 464 PowerOffAction::PrePowerOffFunc& func) 465 { 466 std::unique_ptr<PowerOffAction> action; 467 if (!powerOffConfig.contains("type")) 468 { 469 const auto msg = "Missing 'type' entry in power off config"; 470 log<level::ERR>(msg); 471 throw std::runtime_error(msg); 472 } 473 474 auto type = powerOffConfig.at("type").get<std::string>(); 475 476 if (((type == "hard") || (type == "soft")) && 477 !powerOffConfig.contains("delay")) 478 { 479 const auto msg = "Missing 'delay' entry in power off config"; 480 log<level::ERR>(msg); 481 throw std::runtime_error(msg); 482 } 483 else if ((type == "epow") && 484 (!powerOffConfig.contains("service_mode_delay") || 485 !powerOffConfig.contains("meltdown_delay"))) 486 { 487 const auto msg = "Missing 'service_mode_delay' or 'meltdown_delay' " 488 "entry in power off config"; 489 log<level::ERR>(msg); 490 throw std::runtime_error(msg); 491 } 492 493 if (type == "hard") 494 { 495 action = std::make_unique<HardPowerOff>( 496 powerOffConfig.at("delay").get<uint32_t>(), powerInterface, func); 497 } 498 else if (type == "soft") 499 { 500 action = std::make_unique<SoftPowerOff>( 501 powerOffConfig.at("delay").get<uint32_t>(), powerInterface, func); 502 } 503 else if (type == "epow") 504 { 505 action = std::make_unique<EpowPowerOff>( 506 powerOffConfig.at("service_mode_delay").get<uint32_t>(), 507 powerOffConfig.at("meltdown_delay").get<uint32_t>(), powerInterface, 508 func); 509 } 510 else 511 { 512 auto msg = fmt::format("Invalid 'type' entry {} in power off config", 513 type); 514 log<level::ERR>(msg.c_str()); 515 throw std::runtime_error(msg.c_str()); 516 } 517 518 return action; 519 } 520 521 std::vector<std::unique_ptr<PowerOffRule>> 522 getPowerOffRules(const json& obj, 523 std::shared_ptr<PowerInterfaceBase>& powerInterface, 524 PowerOffAction::PrePowerOffFunc& func) 525 { 526 std::vector<std::unique_ptr<PowerOffRule>> rules; 527 528 if (!(obj.contains("fault_handling") && 529 obj.at("fault_handling").contains("power_off_config"))) 530 { 531 return rules; 532 } 533 534 for (const auto& config : obj.at("fault_handling").at("power_off_config")) 535 { 536 auto state = getPowerOffPowerRuleState(config); 537 auto cause = getPowerOffCause(config); 538 auto action = getPowerOffAction(config, powerInterface, func); 539 540 auto rule = std::make_unique<PowerOffRule>( 541 std::move(state), std::move(cause), std::move(action)); 542 rules.push_back(std::move(rule)); 543 } 544 545 return rules; 546 } 547 548 std::optional<size_t> getNumNonfuncRotorsBeforeError(const json& obj) 549 { 550 std::optional<size_t> num; 551 552 if (obj.contains("fault_handling")) 553 { 554 // Defaults to 1 if not present inside of 'fault_handling'. 555 num = obj.at("fault_handling") 556 .value("num_nonfunc_rotors_before_error", 1); 557 } 558 559 return num; 560 } 561 562 } // namespace phosphor::fan::monitor 563