1 #include "config.h" 2 3 #include "single_fab.hpp" 4 5 #include "constants.hpp" 6 #include "event_logger.hpp" 7 #include "parser.hpp" 8 #include "types.hpp" 9 10 #include <nlohmann/json.hpp> 11 #include <utility/common_utility.hpp> 12 #include <utility/json_utility.hpp> 13 #include <utility/vpd_specific_utility.hpp> 14 15 namespace vpd 16 { 17 constexpr auto pimPersistVsbpPath = 18 "/var/lib/phosphor-inventory-manager/xyz/openbmc_project/inventory/system/chassis/motherboard/com.ibm.ipzvpd.VSBP"; 19 constexpr auto IM_SIZE_IN_BYTES = 0x04; 20 constexpr auto IM_KW_VALUE_OFFSET = 0x000005fb; 21 22 std::string SingleFab::getImFromPersistedLocation() const noexcept 23 { 24 try 25 { 26 uint16_t l_errCode = 0; 27 auto l_parsedVsbpJsonObj = 28 jsonUtility::getParsedJson(pimPersistVsbpPath, l_errCode); 29 30 if (l_errCode) 31 { 32 throw JsonException( 33 "Failed to parse JSON file [ " + 34 std::string(pimPersistVsbpPath) + " ], error : " + 35 vpdSpecificUtility::getErrCodeMsg(l_errCode), 36 pimPersistVsbpPath); 37 } 38 39 if (!l_parsedVsbpJsonObj.contains("value0") || 40 !l_parsedVsbpJsonObj["value0"].contains(constants::kwdIM) || 41 !l_parsedVsbpJsonObj["value0"][constants::kwdIM].is_array()) 42 { 43 throw std::runtime_error("Mandatory tag(s) missing from JSON"); 44 } 45 46 const types::BinaryVector l_imValue = 47 l_parsedVsbpJsonObj["value0"][constants::kwdIM] 48 .get<types::BinaryVector>(); 49 50 std::ostringstream l_imData; 51 for (const auto& l_byte : l_imValue) 52 { 53 l_imData << std::setw(2) << std::setfill('0') << std::hex 54 << static_cast<int>(l_byte); 55 } 56 return l_imData.str(); 57 } 58 catch (const std::exception& l_ex) 59 {} 60 61 return std::string(); 62 } 63 64 std::string SingleFab::getImFromPlanar() const noexcept 65 { 66 try 67 { 68 const std::string l_systemPlanarPath(SYSTEM_VPD_FILE_PATH); 69 Parser l_parserObj(l_systemPlanarPath, nlohmann::json{}); 70 71 std::shared_ptr<ParserInterface> l_vpdParserInstance = 72 l_parserObj.getVpdParserInstance(); 73 74 auto l_readValue = l_vpdParserInstance->readKeywordFromHardware( 75 std::make_tuple(constants::recVSBP, constants::kwdIM)); 76 77 if (auto l_keywordValue = 78 std::get_if<types::BinaryVector>(&l_readValue); 79 l_keywordValue && !l_keywordValue->empty()) 80 { 81 std::ostringstream l_imData; 82 for (const auto& l_byte : *l_keywordValue) 83 { 84 l_imData << std::setw(2) << std::setfill('0') << std::hex 85 << static_cast<int>(l_byte); 86 } 87 88 return l_imData.str(); 89 } 90 } 91 catch (const std::ifstream::failure& l_ex) 92 {} 93 94 return std::string(); 95 } 96 97 bool SingleFab::setImOnPlanar(const std::string& i_imValue) const noexcept 98 { 99 try 100 { 101 types::BinaryVector l_imValue; 102 const std::string l_systemPlanarEepromPath = SYSTEM_VPD_FILE_PATH; 103 104 // Convert string to vector of bytes 105 for (auto l_value : i_imValue | std::views::chunk(2)) 106 { 107 std::string l_byteString(l_value.begin(), l_value.end()); 108 l_imValue.push_back( 109 static_cast<uint8_t>(std::stoi(l_byteString, nullptr, 16))); 110 } 111 112 std::shared_ptr<Parser> l_parserObj = std::make_shared<Parser>( 113 l_systemPlanarEepromPath, nlohmann::json{}); 114 115 int l_bytes_updated = l_parserObj->updateVpdKeywordOnHardware( 116 std::make_tuple(constants::recVSBP, constants::kwdIM, l_imValue)); 117 118 return l_bytes_updated > 0 ? true : false; 119 } 120 catch (const std::exception& l_ex) 121 { 122 return false; 123 } 124 } 125 126 bool SingleFab::isFieldModeEnabled() const noexcept 127 { 128 try 129 { 130 std::vector<std::string> l_cmdOutput = 131 commonUtility::executeCmd("/sbin/fw_printenv fieldmode"); 132 133 if (l_cmdOutput.size() > 0) 134 { 135 commonUtility::toLower(l_cmdOutput[0]); 136 137 // Remove the new line character from the string. 138 l_cmdOutput[0].erase(l_cmdOutput[0].length() - 1); 139 140 return l_cmdOutput[0] == "fieldmode=true" ? true : false; 141 } 142 } 143 catch (const std::exception& l_ex) 144 {} 145 146 return false; 147 } 148 149 void SingleFab::updateSystemImValueInVpdToP11Series( 150 std::string i_currentImValuePlanar) const noexcept 151 { 152 bool l_retVal{false}; 153 if (!i_currentImValuePlanar.empty()) 154 { 155 if (i_currentImValuePlanar.compare( 156 constants::VALUE_4, constants::VALUE_1, 157 std::to_string(constants::VALUE_3)) == 158 constants::STR_CMP_SUCCESS) 159 { 160 i_currentImValuePlanar.replace(constants::VALUE_4, 161 constants::VALUE_1, 162 std::to_string(constants::VALUE_2)); 163 } 164 165 // update the IM value to P11 series(6000x). Replace the first character 166 // of IM value string with '6' 167 l_retVal = setImOnPlanar(i_currentImValuePlanar.replace( 168 constants::VALUE_0, constants::VALUE_1, 169 std::to_string(constants::VALUE_6))); 170 } 171 172 if (!l_retVal) 173 { 174 EventLogger::createSyncPel( 175 types::ErrorType::InternalFailure, 176 types::SeverityType::Informational, __FILE__, __FUNCTION__, 0, 177 std::string("Failed to update IM value to P11 series."), 178 std::nullopt, std::nullopt, std::nullopt, std::nullopt); 179 } 180 } 181 182 int SingleFab::singleFabImOverride() const noexcept 183 { 184 const std::string& l_planarImValue = getImFromPlanar(); 185 const std::string& l_eBmcImValue = getImFromPersistedLocation(); 186 const bool& l_isFieldModeEnabled = isFieldModeEnabled(); 187 const bool& l_isLabModeEnabled = 188 !l_isFieldModeEnabled; // used for understanding 189 const bool& l_isPowerVsImage = vpdSpecificUtility::isPowerVsImage(); 190 const bool& l_isNormalImage = !l_isPowerVsImage; // used for understanding 191 192 if (!isValidImSeries(l_planarImValue)) 193 { 194 // Create Errorlog for invalid IM series encountered 195 EventLogger::createSyncPel( 196 types::ErrorType::InvalidSystem, types::SeverityType::Error, 197 __FILE__, __FUNCTION__, 0, 198 std::string("Invalid IM found on the system planar, IM value : ") + 199 l_planarImValue, 200 std::nullopt, std::nullopt, std::nullopt, std::nullopt); 201 202 return constants::SUCCESS; 203 } 204 205 if (!l_eBmcImValue.empty()) 206 { 207 if (isP10System(l_eBmcImValue)) 208 { 209 if (isP10System(l_planarImValue)) 210 { 211 if (l_isFieldModeEnabled && l_isNormalImage) 212 { 213 EventLogger::createSyncPel( 214 types::ErrorType::SystemTypeMismatch, 215 types::SeverityType::Warning, __FILE__, __FUNCTION__, 0, 216 std::string("Mismatch in IM value found eBMC IM [") + 217 l_eBmcImValue + std::string("] planar IM [") + 218 l_planarImValue + 219 std::string("] Field mode enabled [") + 220 ((l_isFieldModeEnabled) ? "true" : "false") + 221 std::string("]"), 222 std::nullopt, std::nullopt, std::nullopt, std::nullopt); 223 224 return constants::FAILURE; 225 } 226 } 227 else if (isP11System(l_planarImValue)) 228 { 229 if (!(l_isLabModeEnabled && l_isNormalImage)) 230 { 231 EventLogger::createSyncPel( 232 types::ErrorType::SystemTypeMismatch, 233 types::SeverityType::Warning, __FILE__, __FUNCTION__, 0, 234 std::string("Mismatch in IM value found eBMC IM [") + 235 l_eBmcImValue + std::string("] planar IM [") + 236 l_planarImValue + 237 std::string("] Field mode enabled [") + 238 ((l_isFieldModeEnabled) ? "true" : "false") + 239 std::string("]"), 240 std::nullopt, std::nullopt, std::nullopt, std::nullopt); 241 242 return constants::FAILURE; 243 } 244 } 245 } 246 else if (isP11System(l_eBmcImValue)) 247 { 248 if (l_isPowerVsImage) 249 { 250 EventLogger::createSyncPel( 251 types::ErrorType::SystemTypeMismatch, 252 types::SeverityType::Warning, __FILE__, __FUNCTION__, 0, 253 std::string("Mismatch in IM value found eBMC IM [") + 254 l_eBmcImValue + std::string("] planar IM [") + 255 l_planarImValue + 256 std::string("] Field mode enabled [") + 257 ((l_isFieldModeEnabled) ? "true" : "false") + 258 std::string("]"), 259 std::nullopt, std::nullopt, std::nullopt, std::nullopt); 260 261 return constants::FAILURE; 262 } 263 else 264 { 265 if (isP10System(l_planarImValue)) 266 { 267 updateSystemImValueInVpdToP11Series(l_planarImValue); 268 } 269 } 270 } 271 } 272 else 273 { 274 if (isP11System(l_planarImValue) && l_isPowerVsImage) 275 { 276 EventLogger::createSyncPel( 277 types::ErrorType::SystemTypeMismatch, 278 types::SeverityType::Warning, __FILE__, __FUNCTION__, 0, 279 std::string("Mismatch in IM value found eBMC IM [") + 280 l_eBmcImValue + std::string("] planar IM [") + 281 l_planarImValue + std::string("] Field mode enabled [") + 282 ((l_isFieldModeEnabled) ? "true" : "false") + 283 std::string("]"), 284 std::nullopt, std::nullopt, std::nullopt, std::nullopt); 285 286 return constants::FAILURE; 287 } 288 else if (isP10System(l_planarImValue) && l_isNormalImage) 289 { 290 if (l_isLabModeEnabled) 291 { 292 EventLogger::createSyncPel( 293 types::ErrorType::UnknownSystemSettings, 294 types::SeverityType::Warning, __FILE__, __FUNCTION__, 0, 295 std::string("Mismatch in IM value found eBMC IM [") + 296 l_eBmcImValue + std::string("] planar IM [") + 297 l_planarImValue + 298 std::string("] Field mode enabled [") + 299 ((l_isFieldModeEnabled) ? "true" : "false") + 300 std::string("]"), 301 std::nullopt, std::nullopt, std::nullopt, std::nullopt); 302 } 303 else 304 { 305 updateSystemImValueInVpdToP11Series(l_planarImValue); 306 } 307 } 308 } 309 return constants::SUCCESS; 310 } 311 } // namespace vpd 312