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; |
Zane Shelley | bf3326f | 2021-11-12 13:41:39 -0600 | [diff] [blame] | 133 | callout["Guarded"] = false; // default |
| 134 | |
| 135 | // Check if guard info should be added. |
| 136 | if (i_guard) |
| 137 | { |
| 138 | auto guardType = io_sd.queryGuardPolicy(); |
| 139 | |
| 140 | if (!(callout::GuardType::NONE == guardType)) |
| 141 | { |
| 142 | callout["Guarded"] = true; |
| 143 | callout["EntityPath"] = util::pdbg::getPhysBinPath(i_target); |
| 144 | callout["GuardType"] = guardType.getString(); |
| 145 | } |
| 146 | } |
| 147 | |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame] | 148 | io_sd.addCallout(callout); |
| 149 | } |
| 150 | |
| 151 | //------------------------------------------------------------------------------ |
| 152 | |
Zane Shelley | 1eff945 | 2021-11-03 13:59:54 -0500 | [diff] [blame] | 153 | void __calloutBackplane(ServiceData& io_sd, const callout::Priority& i_priority) |
| 154 | { |
| 155 | // TODO: There isn't a device tree object for this. So will need to hardcode |
| 156 | // the location code for now. In the future, we will need a mechanism |
| 157 | // to make this data driven. |
| 158 | |
| 159 | nlohmann::json callout; |
| 160 | callout["LocationCode"] = "P0"; |
| 161 | callout["Priority"] = i_priority.getUserDataString(); |
| 162 | callout["Deconfigured"] = false; |
| 163 | callout["Guarded"] = false; |
| 164 | io_sd.addCallout(callout); |
| 165 | } |
| 166 | |
| 167 | //------------------------------------------------------------------------------ |
| 168 | |
Zane Shelley | 96d5486 | 2021-09-17 11:16:12 -0500 | [diff] [blame] | 169 | void HardwareCalloutResolution::resolve(ServiceData& io_sd) const |
| 170 | { |
| 171 | // Get the target for the hardware callout. |
| 172 | auto target = __getUnitTarget(__getRootCauseChipTarget(io_sd), iv_unitPath); |
| 173 | |
Zane Shelley | c85716c | 2021-08-17 10:54:06 -0500 | [diff] [blame] | 174 | // Add the actual callout to the service data. |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame] | 175 | __calloutTarget(io_sd, target, iv_priority, iv_guard); |
Zane Shelley | 236bb73 | 2021-03-24 17:07:46 -0500 | [diff] [blame] | 176 | |
Zane Shelley | 2d11432 | 2021-08-25 17:06:12 -0500 | [diff] [blame] | 177 | // Add the callout FFDC to the service data. |
| 178 | nlohmann::json ffdc; |
| 179 | ffdc["Callout Type"] = "Hardware Callout"; |
Zane Shelley | a00426f | 2021-11-04 10:50:50 -0500 | [diff] [blame] | 180 | ffdc["Target"] = util::pdbg::getPhysDevPath(target); |
Zane Shelley | 2d11432 | 2021-08-25 17:06:12 -0500 | [diff] [blame] | 181 | ffdc["Priority"] = iv_priority.getRegistryString(); |
Zane Shelley | a00426f | 2021-11-04 10:50:50 -0500 | [diff] [blame] | 182 | ffdc["Guard"] = iv_guard; |
Zane Shelley | 2d11432 | 2021-08-25 17:06:12 -0500 | [diff] [blame] | 183 | io_sd.addCalloutFFDC(ffdc); |
Zane Shelley | 0b8368c | 2021-03-18 17:33:41 -0500 | [diff] [blame] | 184 | } |
| 185 | |
Zane Shelley | c85716c | 2021-08-17 10:54:06 -0500 | [diff] [blame] | 186 | //------------------------------------------------------------------------------ |
| 187 | |
Zane Shelley | 5d63cef | 2021-09-17 18:10:17 -0500 | [diff] [blame] | 188 | void ConnectedCalloutResolution::resolve(ServiceData& io_sd) const |
| 189 | { |
| 190 | // Get the chip target from the root cause signature. |
| 191 | auto chipTarget = __getRootCauseChipTarget(io_sd); |
| 192 | |
| 193 | // Get the endpoint target for the receiving side of the bus. |
| 194 | auto rxTarget = __getUnitTarget(chipTarget, iv_unitPath); |
| 195 | |
| 196 | // Get the endpoint target for the transfer side of the bus. |
| 197 | auto txTarget = __getConnectedTarget(rxTarget, iv_busType); |
| 198 | |
| 199 | // Callout the TX endpoint. |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame] | 200 | __calloutTarget(io_sd, txTarget, iv_priority, iv_guard); |
Zane Shelley | 5d63cef | 2021-09-17 18:10:17 -0500 | [diff] [blame] | 201 | |
Zane Shelley | 5d63cef | 2021-09-17 18:10:17 -0500 | [diff] [blame] | 202 | // Add the callout FFDC to the service data. |
| 203 | nlohmann::json ffdc; |
| 204 | ffdc["Callout Type"] = "Connected Callout"; |
| 205 | ffdc["Bus Type"] = iv_busType.getString(); |
| 206 | ffdc["Target"] = util::pdbg::getPhysDevPath(txTarget); |
| 207 | ffdc["Priority"] = iv_priority.getRegistryString(); |
Zane Shelley | a00426f | 2021-11-04 10:50:50 -0500 | [diff] [blame] | 208 | ffdc["Guard"] = iv_guard; |
Zane Shelley | 5d63cef | 2021-09-17 18:10:17 -0500 | [diff] [blame] | 209 | io_sd.addCalloutFFDC(ffdc); |
| 210 | } |
| 211 | |
| 212 | //------------------------------------------------------------------------------ |
| 213 | |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 214 | void BusCalloutResolution::resolve(ServiceData& io_sd) const |
| 215 | { |
| 216 | // Get the chip target from the root cause signature. |
| 217 | auto chipTarget = __getRootCauseChipTarget(io_sd); |
| 218 | |
| 219 | // Get the endpoint target for the receiving side of the bus. |
| 220 | auto rxTarget = __getUnitTarget(chipTarget, iv_unitPath); |
| 221 | |
| 222 | // Get the endpoint target for the transfer side of the bus. |
| 223 | auto txTarget = __getConnectedTarget(rxTarget, iv_busType); |
| 224 | |
| 225 | // Callout the RX endpoint. |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame] | 226 | __calloutTarget(io_sd, rxTarget, iv_priority, iv_guard); |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 227 | |
| 228 | // Callout the TX endpoint. |
Zane Shelley | 9a738f7 | 2021-11-03 20:45:30 -0500 | [diff] [blame] | 229 | __calloutTarget(io_sd, txTarget, iv_priority, iv_guard); |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 230 | |
| 231 | // Callout everything else in between. |
| 232 | // 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] | 233 | __calloutBackplane(io_sd, iv_priority); |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 234 | |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 235 | // Add the callout FFDC to the service data. |
| 236 | nlohmann::json ffdc; |
| 237 | ffdc["Callout Type"] = "Bus Callout"; |
| 238 | ffdc["Bus Type"] = iv_busType.getString(); |
| 239 | ffdc["RX Target"] = util::pdbg::getPhysDevPath(rxTarget); |
| 240 | ffdc["TX Target"] = util::pdbg::getPhysDevPath(txTarget); |
| 241 | ffdc["Priority"] = iv_priority.getRegistryString(); |
Zane Shelley | a00426f | 2021-11-04 10:50:50 -0500 | [diff] [blame] | 242 | ffdc["Guard"] = iv_guard; |
Zane Shelley | 4757a7b | 2021-09-20 22:23:38 -0500 | [diff] [blame] | 243 | io_sd.addCalloutFFDC(ffdc); |
| 244 | } |
| 245 | |
| 246 | //------------------------------------------------------------------------------ |
| 247 | |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 248 | void ClockCalloutResolution::resolve(ServiceData& io_sd) const |
| 249 | { |
Zane Shelley | 1eff945 | 2021-11-03 13:59:54 -0500 | [diff] [blame] | 250 | // Callout the clock target. |
| 251 | // TODO: For P10, the callout is simply the backplane. Also, there are no |
| 252 | // clock targets in the device tree. So at the moment there is no |
| 253 | // guard support for clock targets. |
| 254 | __calloutBackplane(io_sd, iv_priority); |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 255 | |
| 256 | // Add the callout FFDC to the service data. |
Zane Shelley | 1eff945 | 2021-11-03 13:59:54 -0500 | [diff] [blame] | 257 | // TODO: Add the target and guard type if guard is ever supported. |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 258 | nlohmann::json ffdc; |
| 259 | ffdc["Callout Type"] = "Clock Callout"; |
| 260 | ffdc["Clock Type"] = iv_clockType.getString(); |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 261 | ffdc["Priority"] = iv_priority.getRegistryString(); |
Zane Shelley | 84721d9 | 2021-09-08 13:30:27 -0500 | [diff] [blame] | 262 | io_sd.addCalloutFFDC(ffdc); |
| 263 | } |
| 264 | |
| 265 | //------------------------------------------------------------------------------ |
| 266 | |
Zane Shelley | c85716c | 2021-08-17 10:54:06 -0500 | [diff] [blame] | 267 | void ProcedureCalloutResolution::resolve(ServiceData& io_sd) const |
| 268 | { |
| 269 | // Add the actual callout to the service data. |
| 270 | nlohmann::json callout; |
| 271 | callout["Procedure"] = iv_procedure.getString(); |
| 272 | callout["Priority"] = iv_priority.getUserDataString(); |
| 273 | io_sd.addCallout(callout); |
Zane Shelley | 2d11432 | 2021-08-25 17:06:12 -0500 | [diff] [blame] | 274 | |
| 275 | // Add the callout FFDC to the service data. |
| 276 | nlohmann::json ffdc; |
| 277 | ffdc["Callout Type"] = "Procedure Callout"; |
| 278 | ffdc["Procedure"] = iv_procedure.getString(); |
| 279 | ffdc["Priority"] = iv_priority.getRegistryString(); |
| 280 | io_sd.addCalloutFFDC(ffdc); |
Zane Shelley | c85716c | 2021-08-17 10:54:06 -0500 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | //------------------------------------------------------------------------------ |
| 284 | |
Zane Shelley | 0b8368c | 2021-03-18 17:33:41 -0500 | [diff] [blame] | 285 | } // namespace analyzer |