Zane Shelley | 0b8368c | 2021-03-18 17:33:41 -0500 | [diff] [blame] | 1 | #include <analyzer/resolution.hpp> |
Zane Shelley | 236bb73 | 2021-03-24 17:07:46 -0500 | [diff] [blame] | 2 | #include <util/pdbg.hpp> |
| 3 | #include <util/trace.hpp> |
Zane Shelley | 0b8368c | 2021-03-18 17:33:41 -0500 | [diff] [blame] | 4 | |
| 5 | namespace analyzer |
| 6 | { |
| 7 | |
Zane Shelley | 2d11432 | 2021-08-25 17:06:12 -0500 | [diff] [blame] | 8 | //------------------------------------------------------------------------------ |
| 9 | |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 10 | // Helper function to get the root cause chip target from the service data. |
| 11 | pdbg_target* __getRootCauseChipTarget(const ServiceData& i_sd) |
Zane Shelley | 0b8368c | 2021-03-18 17:33:41 -0500 | [diff] [blame] | 12 | { |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 13 | auto target = util::pdbg::getTrgt(i_sd.getRootCause().getChip()); |
| 14 | assert(nullptr != target); // This would be a really bad bug. |
| 15 | return target; |
| 16 | } |
Zane Shelley | 236bb73 | 2021-03-24 17:07:46 -0500 | [diff] [blame] | 17 | |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 18 | //------------------------------------------------------------------------------ |
| 19 | |
| 20 | // Helper function to get a unit target from the given unit path, which is a |
| 21 | // devtree path relative the the containing chip. An empty string indicates the |
| 22 | // chip target should be returned. |
| 23 | pdbg_target* __getUnitTarget(pdbg_target* i_chipTarget, |
| 24 | const std::string& i_unitPath) |
| 25 | { |
| 26 | assert(nullptr != i_chipTarget); |
| 27 | |
| 28 | auto target = i_chipTarget; // default, if i_unitPath is empty |
| 29 | |
| 30 | if (!i_unitPath.empty()) |
Zane Shelley | 236bb73 | 2021-03-24 17:07:46 -0500 | [diff] [blame] | 31 | { |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 32 | auto path = std::string{util::pdbg::getPath(target)} + "/" + i_unitPath; |
| 33 | |
| 34 | target = util::pdbg::getTrgt(path); |
| 35 | if (nullptr == target) |
Zane Shelley | 236bb73 | 2021-03-24 17:07:46 -0500 | [diff] [blame] | 36 | { |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 37 | // Likely a bug the RAS data files. |
| 38 | throw std::logic_error("Unable to find target for " + path); |
Zane Shelley | 236bb73 | 2021-03-24 17:07:46 -0500 | [diff] [blame] | 39 | } |
| 40 | } |
| 41 | |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 42 | return target; |
| 43 | } |
| 44 | |
| 45 | //------------------------------------------------------------------------------ |
| 46 | |
Zane Shelley | 5d63cef | 2021-09-17 18:10:17 -0500 | [diff] [blame] | 47 | // Helper function to get the connected target on the other side of the |
| 48 | // given bus. |
| 49 | pdbg_target* __getConnectedTarget(pdbg_target* i_rxTarget, |
| 50 | const callout::BusType& i_busType) |
| 51 | { |
| 52 | assert(nullptr != i_rxTarget); |
| 53 | |
| 54 | pdbg_target* txTarget = nullptr; |
| 55 | |
| 56 | auto rxType = util::pdbg::getTrgtType(i_rxTarget); |
| 57 | std::string rxPath = util::pdbg::getPath(i_rxTarget); |
| 58 | |
| 59 | if (callout::BusType::SMP_BUS == i_busType && |
| 60 | util::pdbg::TYPE_IOLINK == rxType) |
| 61 | { |
| 62 | // TODO: Will need to reference some sort of data that can tell us how |
| 63 | // the processors are connected in the system. For now, return the |
| 64 | // RX target to avoid returning a nullptr. |
| 65 | trace::inf("No support to get peer target on SMP bus"); |
| 66 | txTarget = i_rxTarget; |
| 67 | } |
Zane Shelley | be619c0 | 2021-09-30 17:56:42 -0500 | [diff] [blame] | 68 | else if (callout::BusType::SMP_BUS == i_busType && |
| 69 | util::pdbg::TYPE_IOHS == rxType) |
| 70 | { |
| 71 | // TODO: Will need to reference some sort of data that can tell us how |
| 72 | // the processors are connected in the system. For now, return the |
| 73 | // RX target to avoid returning a nullptr. |
| 74 | trace::inf("No support to get peer target on SMP bus"); |
| 75 | txTarget = i_rxTarget; |
| 76 | } |
Zane Shelley | 5d63cef | 2021-09-17 18:10:17 -0500 | [diff] [blame] | 77 | else if (callout::BusType::OMI_BUS == i_busType && |
| 78 | util::pdbg::TYPE_OMI == rxType) |
| 79 | { |
| 80 | // This is a bit clunky. The pdbg APIs only give us the ability to |
| 81 | // iterate over the children instead of just returning a list. So we'll |
| 82 | // push all the children to a list and go from there. |
| 83 | std::vector<pdbg_target*> childList; |
| 84 | |
| 85 | pdbg_target* childTarget = nullptr; |
| 86 | pdbg_for_each_target("ocmb", i_rxTarget, childTarget) |
| 87 | { |
| 88 | if (nullptr != childTarget) |
| 89 | { |
| 90 | childList.push_back(childTarget); |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | // We know there should only be one OCMB per OMI. |
| 95 | if (1 != childList.size()) |
| 96 | { |
| 97 | throw std::logic_error("Invalid child list size for " + rxPath); |
| 98 | } |
| 99 | |
| 100 | // Get the connected target. |
| 101 | txTarget = childList.front(); |
| 102 | } |
| 103 | else if (callout::BusType::OMI_BUS == i_busType && |
| 104 | util::pdbg::TYPE_OCMB == rxType) |
| 105 | { |
| 106 | txTarget = pdbg_target_parent("omi", i_rxTarget); |
| 107 | if (nullptr == txTarget) |
| 108 | { |
| 109 | throw std::logic_error("No parent OMI found for " + rxPath); |
| 110 | } |
| 111 | } |
| 112 | else |
| 113 | { |
| 114 | // This would be a code bug. |
| 115 | throw std::logic_error("Unsupported config: i_rxTarget=" + rxPath + |
| 116 | " i_busType=" + i_busType.getString()); |
| 117 | } |
| 118 | |
| 119 | assert(nullptr != txTarget); // just in case we missed something above |
| 120 | |
| 121 | return txTarget; |
| 122 | } |
| 123 | |
| 124 | //------------------------------------------------------------------------------ |
| 125 | |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame^] | 126 | void __calloutTarget(ServiceData& io_sd, pdbg_target* i_target, |
| 127 | const callout::Priority& i_priority, bool i_guard) |
| 128 | { |
| 129 | nlohmann::json callout; |
| 130 | callout["LocationCode"] = util::pdbg::getLocationCode(i_target); |
| 131 | callout["Priority"] = i_priority.getUserDataString(); |
| 132 | callout["Deconfigured"] = false; |
| 133 | callout["Guarded"] = i_guard; |
| 134 | io_sd.addCallout(callout); |
| 135 | } |
| 136 | |
| 137 | //------------------------------------------------------------------------------ |
| 138 | |
Zane Shelley | 1eff945 | 2021-11-03 13:59:54 -0500 | [diff] [blame] | 139 | void __calloutBackplane(ServiceData& io_sd, const callout::Priority& i_priority) |
| 140 | { |
| 141 | // TODO: There isn't a device tree object for this. So will need to hardcode |
| 142 | // the location code for now. In the future, we will need a mechanism |
| 143 | // to make this data driven. |
| 144 | |
| 145 | nlohmann::json callout; |
| 146 | callout["LocationCode"] = "P0"; |
| 147 | callout["Priority"] = i_priority.getUserDataString(); |
| 148 | callout["Deconfigured"] = false; |
| 149 | callout["Guarded"] = false; |
| 150 | io_sd.addCallout(callout); |
| 151 | } |
| 152 | |
| 153 | //------------------------------------------------------------------------------ |
| 154 | |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 155 | void HardwareCalloutResolution::resolve(ServiceData& io_sd) const |
| 156 | { |
| 157 | // Get the target for the hardware callout. |
| 158 | auto target = __getUnitTarget(__getRootCauseChipTarget(io_sd), iv_unitPath); |
| 159 | |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame^] | 160 | // Get the entity path for this target. |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 161 | auto entityPath = util::pdbg::getPhysDevPath(target); |
Zane Shelley | c85716c | 2021-08-17 10:54:06 -0500 | [diff] [blame] | 162 | |
| 163 | // Add the actual callout to the service data. |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame^] | 164 | __calloutTarget(io_sd, target, iv_priority, iv_guard); |
Zane Shelley | 236bb73 | 2021-03-24 17:07:46 -0500 | [diff] [blame] | 165 | |
Zane Shelley | 9513582 | 2021-08-23 09:00:05 -0500 | [diff] [blame] | 166 | // Add the guard info to the service data. |
Zane Shelley | 2d11432 | 2021-08-25 17:06:12 -0500 | [diff] [blame] | 167 | Guard guard = io_sd.addGuard(entityPath, iv_guard); |
| 168 | |
| 169 | // Add the callout FFDC to the service data. |
| 170 | nlohmann::json ffdc; |
| 171 | ffdc["Callout Type"] = "Hardware Callout"; |
| 172 | ffdc["Target"] = entityPath; |
| 173 | ffdc["Priority"] = iv_priority.getRegistryString(); |
| 174 | ffdc["Guard Type"] = guard.getString(); |
| 175 | io_sd.addCalloutFFDC(ffdc); |
Zane Shelley | 0b8368c | 2021-03-18 17:33:41 -0500 | [diff] [blame] | 176 | } |
| 177 | |
Zane Shelley | c85716c | 2021-08-17 10:54:06 -0500 | [diff] [blame] | 178 | //------------------------------------------------------------------------------ |
| 179 | |
Zane Shelley | 5d63cef | 2021-09-17 18:10:17 -0500 | [diff] [blame] | 180 | void ConnectedCalloutResolution::resolve(ServiceData& io_sd) const |
| 181 | { |
| 182 | // Get the chip target from the root cause signature. |
| 183 | auto chipTarget = __getRootCauseChipTarget(io_sd); |
| 184 | |
| 185 | // Get the endpoint target for the receiving side of the bus. |
| 186 | auto rxTarget = __getUnitTarget(chipTarget, iv_unitPath); |
| 187 | |
| 188 | // Get the endpoint target for the transfer side of the bus. |
| 189 | auto txTarget = __getConnectedTarget(rxTarget, iv_busType); |
| 190 | |
| 191 | // Callout the TX endpoint. |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame^] | 192 | __calloutTarget(io_sd, txTarget, iv_priority, iv_guard); |
Zane Shelley | 5d63cef | 2021-09-17 18:10:17 -0500 | [diff] [blame] | 193 | |
| 194 | // Guard the TX endpoint. |
| 195 | Guard txGuard = |
| 196 | io_sd.addGuard(util::pdbg::getPhysDevPath(txTarget), iv_guard); |
| 197 | |
| 198 | // Add the callout FFDC to the service data. |
| 199 | nlohmann::json ffdc; |
| 200 | ffdc["Callout Type"] = "Connected Callout"; |
| 201 | ffdc["Bus Type"] = iv_busType.getString(); |
| 202 | ffdc["Target"] = util::pdbg::getPhysDevPath(txTarget); |
| 203 | ffdc["Priority"] = iv_priority.getRegistryString(); |
| 204 | ffdc["Guard Type"] = txGuard.getString(); |
| 205 | io_sd.addCalloutFFDC(ffdc); |
| 206 | } |
| 207 | |
| 208 | //------------------------------------------------------------------------------ |
| 209 | |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 210 | void BusCalloutResolution::resolve(ServiceData& io_sd) const |
| 211 | { |
| 212 | // Get the chip target from the root cause signature. |
| 213 | auto chipTarget = __getRootCauseChipTarget(io_sd); |
| 214 | |
| 215 | // Get the endpoint target for the receiving side of the bus. |
| 216 | auto rxTarget = __getUnitTarget(chipTarget, iv_unitPath); |
| 217 | |
| 218 | // Get the endpoint target for the transfer side of the bus. |
| 219 | auto txTarget = __getConnectedTarget(rxTarget, iv_busType); |
| 220 | |
| 221 | // Callout the RX endpoint. |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame^] | 222 | __calloutTarget(io_sd, rxTarget, iv_priority, iv_guard); |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 223 | |
| 224 | // Callout the TX endpoint. |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame^] | 225 | __calloutTarget(io_sd, txTarget, iv_priority, iv_guard); |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 226 | |
| 227 | // Callout everything else in between. |
| 228 | // TODO: For P10 (OMI bus and XBUS), the callout is simply the backplane. |
Zane Shelley | 1eff945 | 2021-11-03 13:59:54 -0500 | [diff] [blame] | 229 | __calloutBackplane(io_sd, iv_priority); |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 230 | |
| 231 | // Guard the RX endpoint. |
| 232 | Guard guard = |
| 233 | io_sd.addGuard(util::pdbg::getPhysDevPath(rxTarget), iv_guard); |
| 234 | |
| 235 | // Guard the TX endpoint. |
| 236 | // No need to check return because it is the same as RX target. |
| 237 | io_sd.addGuard(util::pdbg::getPhysDevPath(txTarget), iv_guard); |
| 238 | |
| 239 | // TODO: Currently no guard for "everything else in between". |
| 240 | |
| 241 | // Add the callout FFDC to the service data. |
| 242 | nlohmann::json ffdc; |
| 243 | ffdc["Callout Type"] = "Bus Callout"; |
| 244 | ffdc["Bus Type"] = iv_busType.getString(); |
| 245 | ffdc["RX Target"] = util::pdbg::getPhysDevPath(rxTarget); |
| 246 | ffdc["TX Target"] = util::pdbg::getPhysDevPath(txTarget); |
| 247 | ffdc["Priority"] = iv_priority.getRegistryString(); |
| 248 | ffdc["Guard Type"] = guard.getString(); |
| 249 | io_sd.addCalloutFFDC(ffdc); |
| 250 | } |
| 251 | |
| 252 | //------------------------------------------------------------------------------ |
| 253 | |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 254 | void ClockCalloutResolution::resolve(ServiceData& io_sd) const |
| 255 | { |
Zane Shelley | 1eff945 | 2021-11-03 13:59:54 -0500 | [diff] [blame] | 256 | // Callout the clock target. |
| 257 | // TODO: For P10, the callout is simply the backplane. Also, there are no |
| 258 | // clock targets in the device tree. So at the moment there is no |
| 259 | // guard support for clock targets. |
| 260 | __calloutBackplane(io_sd, iv_priority); |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 261 | |
| 262 | // Add the callout FFDC to the service data. |
Zane Shelley | 1eff945 | 2021-11-03 13:59:54 -0500 | [diff] [blame] | 263 | // TODO: Add the target and guard type if guard is ever supported. |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 264 | nlohmann::json ffdc; |
| 265 | ffdc["Callout Type"] = "Clock Callout"; |
| 266 | ffdc["Clock Type"] = iv_clockType.getString(); |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 267 | ffdc["Priority"] = iv_priority.getRegistryString(); |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 268 | io_sd.addCalloutFFDC(ffdc); |
| 269 | } |
| 270 | |
| 271 | //------------------------------------------------------------------------------ |
| 272 | |
Zane Shelley | c85716c | 2021-08-17 10:54:06 -0500 | [diff] [blame] | 273 | void ProcedureCalloutResolution::resolve(ServiceData& io_sd) const |
| 274 | { |
| 275 | // Add the actual callout to the service data. |
| 276 | nlohmann::json callout; |
| 277 | callout["Procedure"] = iv_procedure.getString(); |
| 278 | callout["Priority"] = iv_priority.getUserDataString(); |
| 279 | io_sd.addCallout(callout); |
Zane Shelley | 2d11432 | 2021-08-25 17:06:12 -0500 | [diff] [blame] | 280 | |
| 281 | // Add the callout FFDC to the service data. |
| 282 | nlohmann::json ffdc; |
| 283 | ffdc["Callout Type"] = "Procedure Callout"; |
| 284 | ffdc["Procedure"] = iv_procedure.getString(); |
| 285 | ffdc["Priority"] = iv_priority.getRegistryString(); |
| 286 | io_sd.addCalloutFFDC(ffdc); |
Zane Shelley | c85716c | 2021-08-17 10:54:06 -0500 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | //------------------------------------------------------------------------------ |
| 290 | |
Zane Shelley | 0b8368c | 2021-03-18 17:33:41 -0500 | [diff] [blame] | 291 | } // namespace analyzer |