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 fanDefs.emplace_back(std::tuple( 335 fan["inventory"].get<std::string>(), method, funcDelay, timeout, 336 deviation, nonfuncSensorsCount, monitorDelay, countInterval, 337 nonfuncRotorErrorDelay, fanMissingErrorDelay, sensorDefs, cond)); 338 } 339 340 return fanDefs; 341 } 342 343 PowerRuleState getPowerOffPowerRuleState(const json& powerOffConfig) 344 { 345 // The state is optional and defaults to runtime 346 PowerRuleState ruleState{PowerRuleState::runtime}; 347 348 if (powerOffConfig.contains("state")) 349 { 350 auto state = powerOffConfig.at("state").get<std::string>(); 351 if (state == "at_pgood") 352 { 353 ruleState = PowerRuleState::atPgood; 354 } 355 else if (state != "runtime") 356 { 357 auto msg = fmt::format("Invalid power off state entry {}", state); 358 log<level::ERR>(msg.c_str()); 359 throw std::runtime_error(msg.c_str()); 360 } 361 } 362 363 return ruleState; 364 } 365 366 std::unique_ptr<PowerOffCause> getPowerOffCause(const json& powerOffConfig) 367 { 368 std::unique_ptr<PowerOffCause> cause; 369 370 if (!powerOffConfig.contains("count") || !powerOffConfig.contains("cause")) 371 { 372 const auto msg = 373 "Missing 'count' or 'cause' entries in power off config"; 374 log<level::ERR>(msg); 375 throw std::runtime_error(msg); 376 } 377 378 auto count = powerOffConfig.at("count").get<size_t>(); 379 auto powerOffCause = powerOffConfig.at("cause").get<std::string>(); 380 381 const std::map<std::string, std::function<std::unique_ptr<PowerOffCause>()>> 382 causes{ 383 {"missing_fan_frus", 384 [count]() { return std::make_unique<MissingFanFRUCause>(count); }}, 385 {"nonfunc_fan_rotors", [count]() { 386 return std::make_unique<NonfuncFanRotorCause>(count); 387 }}}; 388 389 auto it = causes.find(powerOffCause); 390 if (it != causes.end()) 391 { 392 cause = it->second(); 393 } 394 else 395 { 396 auto msg = 397 fmt::format("Invalid power off cause {} in power off config JSON", 398 powerOffCause); 399 log<level::ERR>(msg.c_str()); 400 throw std::runtime_error(msg.c_str()); 401 } 402 403 return cause; 404 } 405 406 std::unique_ptr<PowerOffAction> 407 getPowerOffAction(const json& powerOffConfig, 408 std::shared_ptr<PowerInterfaceBase>& powerInterface, 409 PowerOffAction::PrePowerOffFunc& func) 410 { 411 std::unique_ptr<PowerOffAction> action; 412 if (!powerOffConfig.contains("type")) 413 { 414 const auto msg = "Missing 'type' entry in power off config"; 415 log<level::ERR>(msg); 416 throw std::runtime_error(msg); 417 } 418 419 auto type = powerOffConfig.at("type").get<std::string>(); 420 421 if (((type == "hard") || (type == "soft")) && 422 !powerOffConfig.contains("delay")) 423 { 424 const auto msg = "Missing 'delay' entry in power off config"; 425 log<level::ERR>(msg); 426 throw std::runtime_error(msg); 427 } 428 else if ((type == "epow") && 429 (!powerOffConfig.contains("service_mode_delay") || 430 !powerOffConfig.contains("meltdown_delay"))) 431 { 432 const auto msg = "Missing 'service_mode_delay' or 'meltdown_delay' " 433 "entry in power off config"; 434 log<level::ERR>(msg); 435 throw std::runtime_error(msg); 436 } 437 438 if (type == "hard") 439 { 440 action = std::make_unique<HardPowerOff>( 441 powerOffConfig.at("delay").get<uint32_t>(), powerInterface, func); 442 } 443 else if (type == "soft") 444 { 445 action = std::make_unique<SoftPowerOff>( 446 powerOffConfig.at("delay").get<uint32_t>(), powerInterface, func); 447 } 448 else if (type == "epow") 449 { 450 action = std::make_unique<EpowPowerOff>( 451 powerOffConfig.at("service_mode_delay").get<uint32_t>(), 452 powerOffConfig.at("meltdown_delay").get<uint32_t>(), powerInterface, 453 func); 454 } 455 else 456 { 457 auto msg = 458 fmt::format("Invalid 'type' entry {} in power off config", type); 459 log<level::ERR>(msg.c_str()); 460 throw std::runtime_error(msg.c_str()); 461 } 462 463 return action; 464 } 465 466 std::vector<std::unique_ptr<PowerOffRule>> 467 getPowerOffRules(const json& obj, 468 std::shared_ptr<PowerInterfaceBase>& powerInterface, 469 PowerOffAction::PrePowerOffFunc& func) 470 { 471 std::vector<std::unique_ptr<PowerOffRule>> rules; 472 473 if (!(obj.contains("fault_handling") && 474 obj.at("fault_handling").contains("power_off_config"))) 475 { 476 return rules; 477 } 478 479 for (const auto& config : obj.at("fault_handling").at("power_off_config")) 480 { 481 auto state = getPowerOffPowerRuleState(config); 482 auto cause = getPowerOffCause(config); 483 auto action = getPowerOffAction(config, powerInterface, func); 484 485 auto rule = std::make_unique<PowerOffRule>( 486 std::move(state), std::move(cause), std::move(action)); 487 rules.push_back(std::move(rule)); 488 } 489 490 return rules; 491 } 492 493 std::optional<size_t> getNumNonfuncRotorsBeforeError(const json& obj) 494 { 495 std::optional<size_t> num; 496 497 if (obj.contains("fault_handling")) 498 { 499 // Defaults to 1 if not present inside of 'fault_handling'. 500 num = obj.at("fault_handling") 501 .value("num_nonfunc_rotors_before_error", 1); 502 } 503 504 return num; 505 } 506 507 } // namespace phosphor::fan::monitor 508