analyzer/filter-root-cause.cpp - openbmc/openpower-hw-diags - Gitiles

 #include <assert.h>

 #include <hei_main.hpp>
 #include <util/pdbg.hpp>

 #include <algorithm>
 #include <limits>
 #include <string>

 namespace analyzer
 {

 //------------------------------------------------------------------------------

 uint64_t __hash(unsigned int i_bytes, const std::string& i_str)
 {
     // This hash is a simple "n*s[0] + (n-1)*s[1] + ... + s[n-1]" algorithm,
     // where s[i] is a chunk from the input string the length of i_bytes.

     // Currently only supporting 1-8 byte hashes.
     assert(1 <= i_bytes && i_bytes <= sizeof(uint64_t));

     // Start hashing each chunk.
     uint64_t sumA = 0;
     uint64_t sumB = 0;

     // Iterate one chunk at a time.
     for (unsigned int i = 0; i < i_str.size(); i += i_bytes)
     {
         // Combine each chunk into a single integer value. If we reach the end
         // of the string, pad with null characters.
         uint64_t chunk = 0;
         for (unsigned int j = 0; j < i_bytes; j++)
         {
             chunk <<= 8;
             chunk |= (i + j < i_str.size()) ? i_str[i + j] : '\0';
         }

         // Apply the simple hash.
         sumA += chunk;
         sumB += sumA;
     }

     // Mask off everything except the target number of bytes.
     auto mask = std::numeric_limits<uint64_t>::max();
     sumB &= mask >> ((sizeof(uint64_t) - i_bytes) * 8);

     return sumB;
 }

 //------------------------------------------------------------------------------

 bool __findRcsOscError(const std::vector<libhei::Signature>& i_list,
                        libhei::Signature& o_rootCause)
 {
     // TODO: Consider returning all of them instead of one as root cause.
     auto itr = std::find_if(i_list.begin(), i_list.end(), [&](const auto& t) {
         return (__hash(2, "TP_LOCAL_FIR") == t.getId() &&
                 (42 == t.getBit() || 43 == t.getBit()));
     });

     if (i_list.end() != itr)
     {
         o_rootCause = *itr;
         return true;
     }

     return false;
 }

 //------------------------------------------------------------------------------

 bool __findPllUnlock(const std::vector<libhei::Signature>& i_list,
                      libhei::Signature& o_rootCause)
 {
     // TODO: Consider returning all of them instead of one as root cause.
     auto itr = std::find_if(i_list.begin(), i_list.end(), [&](const auto& t) {
         return (__hash(2, "PLL_UNLOCK") == t.getId() &&
                 (0 == t.getBit() || 1 == t.getBit()));
     });

     if (i_list.end() != itr)
     {
         o_rootCause = *itr;
         return true;
     }

     return false;
 }

 //------------------------------------------------------------------------------

 bool __findMemoryChannelFailure(const std::vector<libhei::Signature>& i_list,
                                 libhei::Signature& o_rootCause)
 {
     using namespace util::pdbg;

     static const auto mc_dstl_fir       = __hash(2, "MC_DSTL_FIR");
     static const auto mc_ustl_fir       = __hash(2, "MC_USTL_FIR");
     static const auto mc_omi_dl_err_rpt = __hash(2, "MC_OMI_DL_ERR_RPT");

     for (const auto s : i_list)
     {
         const auto targetType = getTrgtType(getTrgt(s.getChip()));
         const auto id         = s.getId();
         const auto bit        = s.getBit();
         const auto attnType   = s.getAttnType();

         // Look for any unit checkstop attentions from OCMBs.
         if (TYPE_OCMB == targetType)
         {
             // Any unit checkstop attentions will trigger a channel failure.
             if (libhei::ATTN_TYPE_UNIT_CS == attnType)
             {
                 o_rootCause = s;
                 return true;
             }
         }
         // Look for channel failure attentions on processors.
         else if (TYPE_PROC == targetType)
         {
             // TODO: All of these channel failure bits are configurable.
             //       Eventually, we will need some mechanism to check that
             //       config registers for a more accurate analysis. For now,
             //       simply check for all bits that could potentially be
             //       configured to channel failure.

             // Any unit checkstop bit in the MC_DSTL_FIR or MC_USTL_FIR could
             // be a channel failure.
             if (libhei::ATTN_TYPE_UNIT_CS == attnType)
             {
                 // Ignore bits MC_DSTL_FIR[0:7] because they simply indicate
                 // attentions occurred on the attached OCMBs.
                 if ((mc_dstl_fir == id && 8 <= bit) || (mc_ustl_fir == id))
                 {
                     o_rootCause = s;
                     return true;
                 }
             }

             // All bits in MC_OMI_DL_ERR_RPT eventually feed into
             // MC_OMI_DL_FIR[0,20] which are configurable to channel failure.
             if (mc_omi_dl_err_rpt == id)
             {
                 o_rootCause = s;
                 return true;
             }
         }
     }

     return false; // default, nothing found
 }

 //------------------------------------------------------------------------------

 // Will query if a signature is a potential system checkstop root cause.
 // attention. Note that this function excludes memory channel failure attentions
 // and core unit checkstop attentions.
 bool __findCsRootCause(const libhei::Signature& i_signature)
 {
     using namespace util::pdbg;

     // PROC registers
     static const auto eq_core_fir      = __hash(2, "EQ_CORE_FIR");
     static const auto eq_l2_fir        = __hash(2, "EQ_L2_FIR");
     static const auto eq_l3_fir        = __hash(2, "EQ_L3_FIR");
     static const auto eq_ncu_fir       = __hash(2, "EQ_NCU_FIR");
     static const auto iohs_dlp_fir_oc  = __hash(2, "IOHS_DLP_FIR_OC");
     static const auto iohs_dlp_fir_smp = __hash(2, "IOHS_DLP_FIR_SMP");
     static const auto nx_cq_fir        = __hash(2, "NX_CQ_FIR");
     static const auto nx_dma_eng_fir   = __hash(2, "NX_DMA_ENG_FIR");
     static const auto pau_fir_0        = __hash(2, "PAU_FIR_0");
     static const auto pau_fir_1        = __hash(2, "PAU_FIR_1");
     static const auto pau_fir_2        = __hash(2, "PAU_FIR_2");
     static const auto pau_ptl_fir      = __hash(2, "PAU_PTL_FIR");

     // OCMB registers
     static const auto rdffir = __hash(2, "RDFFIR");

     const auto targetType = getTrgtType(getTrgt(i_signature.getChip()));
     const auto id         = i_signature.getId();
     const auto bit        = i_signature.getBit();

     if (TYPE_PROC == targetType)
     {
         if (eq_core_fir == id &&
             (3 == bit || 5 == bit || 8 == bit || 12 == bit || 22 == bit ||
              25 == bit || 32 == bit || 36 == bit || 38 == bit || 46 == bit ||
              47 == bit || 57 == bit))
         {
             return true;
         }

         if (eq_l2_fir == id &&
             (1 == bit || 12 == bit || 13 == bit || 17 == bit || 18 == bit ||
              20 == bit || 27 == bit))
         {
             return true;
         }

         if (eq_l3_fir == id &&
             (2 == bit || 5 == bit || 8 == bit || 11 == bit || 17 == bit))
         {
             return true;
         }

         if (eq_ncu_fir == id && (3 == bit || 4 == bit || 5 == bit || 7 == bit ||
                                  8 == bit || 10 == bit || 17 == bit))
         {
             return true;
         }

         if (iohs_dlp_fir_oc == id && (54 <= bit && bit <= 61))
         {
             return true;
         }

         if (iohs_dlp_fir_smp == id && (54 <= bit && bit <= 61))
         {
             return true;
         }

         if (nx_cq_fir == id && (7 == bit || 16 == bit || 21 == bit))
         {
             return true;
         }

         if (nx_dma_eng_fir == id && (0 == bit))
         {
             return true;
         }

         if (pau_fir_0 == id &&
             (15 == bit || 18 == bit || 19 == bit || 25 == bit || 26 == bit ||
              29 == bit || 33 == bit || 34 == bit || 35 == bit || 40 == bit ||
              42 == bit || 44 == bit || 45 == bit))
         {
             return true;
         }

         if (pau_fir_1 == id &&
             (13 == bit || 14 == bit || 15 == bit || 37 == bit || 39 == bit ||
              40 == bit || 41 == bit || 42 == bit))
         {
             return true;
         }

         if (pau_fir_2 == id &&
             ((4 <= bit && bit <= 18) || (20 <= bit && bit <= 31) ||
              (36 <= bit && bit <= 41) || 45 == bit || 47 == bit || 48 == bit ||
              50 == bit || 51 == bit || 52 == bit))
         {
             return true;
         }

         if (pau_ptl_fir == id && (4 == bit || 8 == bit))
         {
             return true;
         }
     }
     else if (TYPE_OCMB == targetType)
     {
         if (rdffir == id && (14 == bit || 15 == bit || 17 == bit || 37 == bit))
         {
             return true;
         }
     }

     return false; // default, nothing found
 }

 //------------------------------------------------------------------------------

 bool __findCsRootCause_RE(const std::vector<libhei::Signature>& i_list,
                           libhei::Signature& o_rootCause)
 {
     for (const auto s : i_list)
     {
         // Only looking for recoverable attentions.
         if (libhei::ATTN_TYPE_RECOVERABLE != s.getAttnType())
         {
             continue;
         }

         if (__findCsRootCause(s))
         {
             o_rootCause = s;
             return true;
         }
     }

     return false; // default, nothing found
 }

 //------------------------------------------------------------------------------

 bool __findCsRootCause_UCS(const std::vector<libhei::Signature>& i_list,
                            libhei::Signature& o_rootCause)
 {
     for (const auto s : i_list)
     {
         // Only looking for unit checkstop attentions.
         if (libhei::ATTN_TYPE_UNIT_CS != s.getAttnType())
         {
             continue;
         }

         if (__findCsRootCause(s))
         {
             o_rootCause = s;
             return true;
         }
     }

     return false; // default, nothing found
 }

 //------------------------------------------------------------------------------

 bool __findNonExternalCs(const std::vector<libhei::Signature>& i_list,
                          libhei::Signature& o_rootCause)
 {
     using namespace util::pdbg;

     static const auto pb_ext_fir = __hash(2, "PB_EXT_FIR");

     for (const auto s : i_list)
     {
         const auto targetType = getTrgtType(getTrgt(s.getChip()));
         const auto id         = s.getId();
         const auto attnType   = s.getAttnType();

         // Find any processor with system checkstop attention that did not
         // originate from the PB_EXT_FIR.
         if ((TYPE_PROC == targetType) &&
             (libhei::ATTN_TYPE_CHECKSTOP == attnType) && (pb_ext_fir != id))
         {
             o_rootCause = s;
             return true;
         }
     }

     return false; // default, nothing found
 }

 //------------------------------------------------------------------------------

 bool filterRootCause(const libhei::IsolationData& i_isoData,
                      libhei::Signature& o_rootCause)
 {
     // We'll need to make a copy of the list so that the original list is
     // maintained for the log.
     std::vector<libhei::Signature> list{i_isoData.getSignatureList()};

     // START WORKAROUND
     // TODO: Filtering should be data driven. Until that support is available,
     //       use the following isolation rules.

     // Special and host attentions are not supported by this user application.
     auto itr = std::remove_if(list.begin(), list.end(), [&](const auto& t) {
         return (libhei::ATTN_TYPE_SP_ATTN == t.getAttnType() ||
                 libhei::ATTN_TYPE_HOST_ATTN == t.getAttnType());
     });
     list.resize(std::distance(list.begin(), itr));

     if (list.empty())
     {
         return false; // the list is empty, nothing more to do
     }

     // First, look for any RCS OSC errors. This must always be first because
     // they can cause downstream PLL unlock attentions.
     if (__findRcsOscError(list, o_rootCause))
     {
         return true;
     }

     // Second, look for any PLL unlock attentions. This must always be second
     // because PLL unlock attentions can cause any number of downstream
     // attentions, including a system checkstop.
     if (__findPllUnlock(list, o_rootCause))
     {
         return true;
     }

     // Memory channel failure attentions will produce SUEs and likely cause
     // downstream attentions, including a system checkstop.
     if (__findMemoryChannelFailure(list, o_rootCause))
     {
         return true;
     }

     // Look for any recoverable attentions that have been identified as a
     // potential root cause of a system checkstop attention. These would include
     // any attention that would generate an SUE. Note that is it possible for
     // recoverables to generate unit checkstop attentions so we must check them
     // first.
     if (__findCsRootCause_RE(list, o_rootCause))
     {
         return true;
     }

     // Look for any unit checkstop attentions (other than memory channel
     // failures) that have been identified as a potential root cause of a
     // system checkstop attention. These would include any attention that would
     // generate an SUE.
     if (__findCsRootCause_UCS(list, o_rootCause))
     {
         return true;
     }

     // Look for any system checkstop attentions that originated from within the
     // chip that reported the attention. In other words, no external checkstop
     // attentions.
     if (__findNonExternalCs(list, o_rootCause))
     {
         return true;
     }

     if (!list.empty())
     {
         // TODO: At this point, we have not found any known errors that could be
         //       attributed to a system checkstop attention. This would be an
         //       isolation error if this function is called specifically for
         //       checkstop analysis, but this function currently is called for
         //       TIs and manual analysis as well. For now, we'll just sort the
         //       remaining list (recoverable, unit checkstop, and then system
         //       checkstop) and return the first element in the list. Later,
         //       we'll change this to properly handle error path scenarios.

         // Fortunately, we just need to sort the list by the greater attention
         // type value.
         std::sort(list.begin(), list.end(), [&](const auto& a, const auto& b) {
             return a.getAttnType() > b.getAttnType();
         });

         // The entry at the front of the list will be the root cause.
         o_rootCause = list.front();
         return true;
     }

     // END WORKAROUND

     return false; // default, no active attentions found.
 }

 //------------------------------------------------------------------------------

 } // namespace analyzer
	#include <assert.h>

	#include <hei_main.hpp>
	#include <util/pdbg.hpp>

	#include <algorithm>
	#include <limits>
	#include <string>

	namespace analyzer
	{

	//------------------------------------------------------------------------------

	uint64_t __hash(unsigned int i_bytes, const std::string& i_str)
	{
	// This hash is a simple "ns[0] + (n-1)s[1] + ... + s[n-1]" algorithm,
	// where s[i] is a chunk from the input string the length of i_bytes.

	// Currently only supporting 1-8 byte hashes.
	assert(1 <= i_bytes && i_bytes <= sizeof(uint64_t));

	// Start hashing each chunk.
	uint64_t sumA = 0;
	uint64_t sumB = 0;

	// Iterate one chunk at a time.
	for (unsigned int i = 0; i < i_str.size(); i += i_bytes)
	{
	// Combine each chunk into a single integer value. If we reach the end
	// of the string, pad with null characters.
	uint64_t chunk = 0;
	for (unsigned int j = 0; j < i_bytes; j++)
	{
	chunk <<= 8;
	chunk \|= (i + j < i_str.size()) ? i_str[i + j] : '\0';
	}

	// Apply the simple hash.
	sumA += chunk;
	sumB += sumA;
	}

	// Mask off everything except the target number of bytes.
	auto mask = std::numeric_limits<uint64_t>::max();
	sumB &= mask >> ((sizeof(uint64_t) - i_bytes) * 8);

	return sumB;
	}

	//------------------------------------------------------------------------------

	bool __findRcsOscError(const std::vector<libhei::Signature>& i_list,
	libhei::Signature& o_rootCause)
	{
	// TODO: Consider returning all of them instead of one as root cause.
	auto itr = std::find_if(i_list.begin(), i_list.end(), [&](const auto& t) {
	return (__hash(2, "TP_LOCAL_FIR") == t.getId() &&
	(42 == t.getBit() \|\| 43 == t.getBit()));
	});

	if (i_list.end() != itr)
	{
	o_rootCause = *itr;
	return true;
	}

	return false;
	}

	//------------------------------------------------------------------------------

	bool __findPllUnlock(const std::vector<libhei::Signature>& i_list,
	libhei::Signature& o_rootCause)
	{
	// TODO: Consider returning all of them instead of one as root cause.
	auto itr = std::find_if(i_list.begin(), i_list.end(), [&](const auto& t) {
	return (__hash(2, "PLL_UNLOCK") == t.getId() &&
	(0 == t.getBit() \|\| 1 == t.getBit()));
	});

	if (i_list.end() != itr)
	{
	o_rootCause = *itr;
	return true;
	}

	return false;
	}

	//------------------------------------------------------------------------------

	bool __findMemoryChannelFailure(const std::vector<libhei::Signature>& i_list,
	libhei::Signature& o_rootCause)
	{
	using namespace util::pdbg;

	static const auto mc_dstl_fir = __hash(2, "MC_DSTL_FIR");
	static const auto mc_ustl_fir = __hash(2, "MC_USTL_FIR");
	static const auto mc_omi_dl_err_rpt = __hash(2, "MC_OMI_DL_ERR_RPT");

	for (const auto s : i_list)
	{
	const auto targetType = getTrgtType(getTrgt(s.getChip()));
	const auto id = s.getId();
	const auto bit = s.getBit();
	const auto attnType = s.getAttnType();

	// Look for any unit checkstop attentions from OCMBs.
	if (TYPE_OCMB == targetType)
	{
	// Any unit checkstop attentions will trigger a channel failure.
	if (libhei::ATTN_TYPE_UNIT_CS == attnType)
	{
	o_rootCause = s;
	return true;
	}
	}
	// Look for channel failure attentions on processors.
	else if (TYPE_PROC == targetType)
	{
	// TODO: All of these channel failure bits are configurable.
	// Eventually, we will need some mechanism to check that
	// config registers for a more accurate analysis. For now,
	// simply check for all bits that could potentially be
	// configured to channel failure.

	// Any unit checkstop bit in the MC_DSTL_FIR or MC_USTL_FIR could
	// be a channel failure.
	if (libhei::ATTN_TYPE_UNIT_CS == attnType)
	{
	// Ignore bits MC_DSTL_FIR[0:7] because they simply indicate
	// attentions occurred on the attached OCMBs.
	if ((mc_dstl_fir == id && 8 <= bit) \|\| (mc_ustl_fir == id))
	{
	o_rootCause = s;
	return true;
	}
	}

	// All bits in MC_OMI_DL_ERR_RPT eventually feed into
	// MC_OMI_DL_FIR[0,20] which are configurable to channel failure.
	if (mc_omi_dl_err_rpt == id)
	{
	o_rootCause = s;
	return true;
	}
	}
	}

	return false; // default, nothing found
	}

	//------------------------------------------------------------------------------

	// Will query if a signature is a potential system checkstop root cause.
	// attention. Note that this function excludes memory channel failure attentions
	// and core unit checkstop attentions.
	bool __findCsRootCause(const libhei::Signature& i_signature)
	{
	using namespace util::pdbg;

	// PROC registers
	static const auto eq_core_fir = __hash(2, "EQ_CORE_FIR");
	static const auto eq_l2_fir = __hash(2, "EQ_L2_FIR");
	static const auto eq_l3_fir = __hash(2, "EQ_L3_FIR");
	static const auto eq_ncu_fir = __hash(2, "EQ_NCU_FIR");
	static const auto iohs_dlp_fir_oc = __hash(2, "IOHS_DLP_FIR_OC");
	static const auto iohs_dlp_fir_smp = __hash(2, "IOHS_DLP_FIR_SMP");
	static const auto nx_cq_fir = __hash(2, "NX_CQ_FIR");
	static const auto nx_dma_eng_fir = __hash(2, "NX_DMA_ENG_FIR");
	static const auto pau_fir_0 = __hash(2, "PAU_FIR_0");
	static const auto pau_fir_1 = __hash(2, "PAU_FIR_1");
	static const auto pau_fir_2 = __hash(2, "PAU_FIR_2");
	static const auto pau_ptl_fir = __hash(2, "PAU_PTL_FIR");

	// OCMB registers
	static const auto rdffir = __hash(2, "RDFFIR");

	const auto targetType = getTrgtType(getTrgt(i_signature.getChip()));
	const auto id = i_signature.getId();
	const auto bit = i_signature.getBit();

	if (TYPE_PROC == targetType)
	{
	if (eq_core_fir == id &&
	(3 == bit \|\| 5 == bit \|\| 8 == bit \|\| 12 == bit \|\| 22 == bit \|\|
	25 == bit \|\| 32 == bit \|\| 36 == bit \|\| 38 == bit \|\| 46 == bit \|\|
	47 == bit \|\| 57 == bit))
	{
	return true;
	}

	if (eq_l2_fir == id &&
	(1 == bit \|\| 12 == bit \|\| 13 == bit \|\| 17 == bit \|\| 18 == bit \|\|
	20 == bit \|\| 27 == bit))
	{
	return true;
	}

	if (eq_l3_fir == id &&
	(2 == bit \|\| 5 == bit \|\| 8 == bit \|\| 11 == bit \|\| 17 == bit))
	{
	return true;
	}

	if (eq_ncu_fir == id && (3 == bit \|\| 4 == bit \|\| 5 == bit \|\| 7 == bit \|\|
	8 == bit \|\| 10 == bit \|\| 17 == bit))
	{
	return true;
	}

	if (iohs_dlp_fir_oc == id && (54 <= bit && bit <= 61))
	{
	return true;
	}

	if (iohs_dlp_fir_smp == id && (54 <= bit && bit <= 61))
	{
	return true;
	}

	if (nx_cq_fir == id && (7 == bit \|\| 16 == bit \|\| 21 == bit))
	{
	return true;
	}

	if (nx_dma_eng_fir == id && (0 == bit))
	{
	return true;
	}

	if (pau_fir_0 == id &&
	(15 == bit \|\| 18 == bit \|\| 19 == bit \|\| 25 == bit \|\| 26 == bit \|\|
	29 == bit \|\| 33 == bit \|\| 34 == bit \|\| 35 == bit \|\| 40 == bit \|\|
	42 == bit \|\| 44 == bit \|\| 45 == bit))
	{
	return true;
	}

	if (pau_fir_1 == id &&
	(13 == bit \|\| 14 == bit \|\| 15 == bit \|\| 37 == bit \|\| 39 == bit \|\|
	40 == bit \|\| 41 == bit \|\| 42 == bit))
	{
	return true;
	}

	if (pau_fir_2 == id &&
	((4 <= bit && bit <= 18) \|\| (20 <= bit && bit <= 31) \|\|
	(36 <= bit && bit <= 41) \|\| 45 == bit \|\| 47 == bit \|\| 48 == bit \|\|
	50 == bit \|\| 51 == bit \|\| 52 == bit))
	{
	return true;
	}

	if (pau_ptl_fir == id && (4 == bit \|\| 8 == bit))
	{
	return true;
	}
	}
	else if (TYPE_OCMB == targetType)
	{
	if (rdffir == id && (14 == bit \|\| 15 == bit \|\| 17 == bit \|\| 37 == bit))
	{
	return true;
	}
	}

	return false; // default, nothing found
	}

	//------------------------------------------------------------------------------

	bool __findCsRootCause_RE(const std::vector<libhei::Signature>& i_list,
	libhei::Signature& o_rootCause)
	{
	for (const auto s : i_list)
	{
	// Only looking for recoverable attentions.
	if (libhei::ATTN_TYPE_RECOVERABLE != s.getAttnType())
	{
	continue;
	}

	if (__findCsRootCause(s))
	{
	o_rootCause = s;
	return true;
	}
	}

	return false; // default, nothing found
	}

	//------------------------------------------------------------------------------

	bool __findCsRootCause_UCS(const std::vector<libhei::Signature>& i_list,
	libhei::Signature& o_rootCause)
	{
	for (const auto s : i_list)
	{
	// Only looking for unit checkstop attentions.
	if (libhei::ATTN_TYPE_UNIT_CS != s.getAttnType())
	{
	continue;
	}

	if (__findCsRootCause(s))
	{
	o_rootCause = s;
	return true;
	}
	}

	return false; // default, nothing found
	}

	//------------------------------------------------------------------------------

	bool __findNonExternalCs(const std::vector<libhei::Signature>& i_list,
	libhei::Signature& o_rootCause)
	{
	using namespace util::pdbg;

	static const auto pb_ext_fir = __hash(2, "PB_EXT_FIR");

	for (const auto s : i_list)
	{
	const auto targetType = getTrgtType(getTrgt(s.getChip()));
	const auto id = s.getId();
	const auto attnType = s.getAttnType();

	// Find any processor with system checkstop attention that did not
	// originate from the PB_EXT_FIR.
	if ((TYPE_PROC == targetType) &&
	(libhei::ATTN_TYPE_CHECKSTOP == attnType) && (pb_ext_fir != id))
	{
	o_rootCause = s;
	return true;
	}
	}

	return false; // default, nothing found
	}

	//------------------------------------------------------------------------------

	bool filterRootCause(const libhei::IsolationData& i_isoData,
	libhei::Signature& o_rootCause)
	{
	// We'll need to make a copy of the list so that the original list is
	// maintained for the log.
	std::vector<libhei::Signature> list{i_isoData.getSignatureList()};

	// START WORKAROUND
	// TODO: Filtering should be data driven. Until that support is available,
	// use the following isolation rules.

	// Special and host attentions are not supported by this user application.
	auto itr = std::remove_if(list.begin(), list.end(), [&](const auto& t) {
	return (libhei::ATTN_TYPE_SP_ATTN == t.getAttnType() \|\|
	libhei::ATTN_TYPE_HOST_ATTN == t.getAttnType());
	});
	list.resize(std::distance(list.begin(), itr));

	if (list.empty())
	{
	return false; // the list is empty, nothing more to do
	}

	// First, look for any RCS OSC errors. This must always be first because
	// they can cause downstream PLL unlock attentions.
	if (__findRcsOscError(list, o_rootCause))
	{
	return true;
	}

	// Second, look for any PLL unlock attentions. This must always be second
	// because PLL unlock attentions can cause any number of downstream
	// attentions, including a system checkstop.
	if (__findPllUnlock(list, o_rootCause))
	{
	return true;
	}

	// Memory channel failure attentions will produce SUEs and likely cause
	// downstream attentions, including a system checkstop.
	if (__findMemoryChannelFailure(list, o_rootCause))
	{
	return true;
	}

	// Look for any recoverable attentions that have been identified as a
	// potential root cause of a system checkstop attention. These would include
	// any attention that would generate an SUE. Note that is it possible for
	// recoverables to generate unit checkstop attentions so we must check them
	// first.
	if (__findCsRootCause_RE(list, o_rootCause))
	{
	return true;
	}

	// Look for any unit checkstop attentions (other than memory channel
	// failures) that have been identified as a potential root cause of a
	// system checkstop attention. These would include any attention that would
	// generate an SUE.
	if (__findCsRootCause_UCS(list, o_rootCause))
	{
	return true;
	}

	// Look for any system checkstop attentions that originated from within the
	// chip that reported the attention. In other words, no external checkstop
	// attentions.
	if (__findNonExternalCs(list, o_rootCause))
	{
	return true;
	}

	if (!list.empty())
	{
	// TODO: At this point, we have not found any known errors that could be
	// attributed to a system checkstop attention. This would be an
	// isolation error if this function is called specifically for
	// checkstop analysis, but this function currently is called for
	// TIs and manual analysis as well. For now, we'll just sort the
	// remaining list (recoverable, unit checkstop, and then system
	// checkstop) and return the first element in the list. Later,
	// we'll change this to properly handle error path scenarios.

	// Fortunately, we just need to sort the list by the greater attention
	// type value.
	std::sort(list.begin(), list.end(), [&](const auto& a, const auto& b) {
	return a.getAttnType() > b.getAttnType();
	});

	// The entry at the front of the list will be the root cause.
	o_rootCause = list.front();
	return true;
	}

	// END WORKAROUND

	return false; // default, no active attentions found.
	}

	//------------------------------------------------------------------------------

	} // namespace analyzer