summaryrefslogtreecommitdiffstats
path: root/src/usr/diag/attn/test
diff options
context:
space:
mode:
Diffstat (limited to 'src/usr/diag/attn/test')
-rw-r--r--src/usr/diag/attn/test/attntestproc.H465
-rw-r--r--src/usr/diag/attn/test/attnvalidate.C329
-rw-r--r--src/usr/diag/attn/test/attnvalidate.H191
-rw-r--r--src/usr/diag/attn/test/makefile3
4 files changed, 987 insertions, 1 deletions
diff --git a/src/usr/diag/attn/test/attntestproc.H b/src/usr/diag/attn/test/attntestproc.H
new file mode 100644
index 000000000..0a870b646
--- /dev/null
+++ b/src/usr/diag/attn/test/attntestproc.H
@@ -0,0 +1,465 @@
+/* IBM_PROLOG_BEGIN_TAG
+ * This is an automatically generated prolog.
+ *
+ * $Source: src/usr/diag/attn/test/attntestproc.H $
+ *
+ * IBM CONFIDENTIAL
+ *
+ * COPYRIGHT International Business Machines Corp. 2012
+ *
+ * p1
+ *
+ * Object Code Only (OCO) source materials
+ * Licensed Internal Code Source Materials
+ * IBM HostBoot Licensed Internal Code
+ *
+ * The source code for this program is not published or other-
+ * wise divested of its trade secrets, irrespective of what has
+ * been deposited with the U.S. Copyright Office.
+ *
+ * Origin: 30
+ *
+ * IBM_PROLOG_END_TAG
+ */
+#ifndef __TEST_ATTNTESTPROC_H
+#define __TEST_ATTNTESTPROC_H
+
+/**
+ * @file attntestproc.H
+ *
+ * @brief Unit test for the attnproc module.
+ */
+
+#include "../attnproc.H"
+#include "../attnsvc.H"
+#include "attnfakesys.H"
+#include "attnfakeprd.H"
+#include "attnfakegfir.H"
+#include "attnfakeipoll.H"
+#include "attnrandsource.H"
+#include "attnfaketarget.H"
+#include "attnfakepresenter.H"
+#include "attntest.H"
+#include "attnvalidate.H"
+#include <cxxtest/TestSuite.H>
+#include <sys/time.h>
+
+using namespace ATTN;
+using namespace PRDF;
+using namespace std;
+
+/**
+ * @brief AttnProcTest Unit test for the attnproc module.
+ */
+class AttnProcTest: public CxxTest::TestSuite
+{
+ public:
+
+ /**
+ * @brief testMask Unit test for the
+ * mask method.
+ */
+ void testMask(void)
+ {
+ TS_TRACE(ENTER_MRK "testMask");
+
+ static const uint64_t iterations = 100;
+ static const uint64_t targetPoolSize = 8;
+
+ errlHndl_t err = 0;
+
+ ProcOps ops;
+ AttnData d;
+
+ FakeProcTargetService targetSvc(targetPoolSize);
+ FakeSystem system;
+
+ TargetHandleList procs;
+
+ targetSvc.getAllChips(procs, TYPE_PROC);
+
+ system.installScomImpl();
+
+ for(uint64_t it = 0; it < iterations; ++it)
+ {
+ d.targetHndl = *(&procs[0] + randint(0, targetPoolSize -1));
+ d.attnType = getRandomAttentionType();
+
+ // put some random data in the mask register
+
+ uint64_t randomData = randint(0, 0xffffffff);
+ uint64_t maskbits = 0;
+
+ if(!IPOLL::getCheckbits(d.attnType, maskbits))
+ {
+ TS_FAIL("unexpected error calling getCheckbits");
+ break;
+ }
+
+ randomData = randomData & ~maskbits;
+
+ err = putScom(
+ d.targetHndl,
+ IPOLL::address,
+ randomData);
+ if(err)
+ {
+ TS_FAIL("unexpected error calling putscom");
+ break;
+ }
+
+ err = ops.mask(d);
+
+ if(err)
+ {
+ TS_FAIL("unexpected error masking attention");
+ break;
+ }
+
+ uint64_t data = 0;
+ err = getScom(d.targetHndl, IPOLL::address, data);
+ if(err)
+ {
+ TS_FAIL("unexpected error calling getscom");
+ break;
+ }
+
+ // verify that the attn was masked, and that
+ // other bits weren't touched
+
+ if(!(data & maskbits))
+ {
+ TS_FAIL("attention not masked");
+ break;
+ }
+
+ if((data & ~maskbits) != randomData)
+ {
+ TS_FAIL("unexpected data in mask register");
+ break;
+ }
+
+ // clean up by unmasking
+
+ err = ops.unmask(d);
+
+ if(err)
+ {
+ TS_FAIL("unexpected error unmasking attention");
+ break;
+ }
+ }
+
+ TS_TRACE(EXIT_MRK "testMask");
+ }
+
+ /**
+ * @brief testUnmask Unit test for the
+ * unmask method.
+ */
+ void testUnmask(void)
+ {
+ TS_TRACE(ENTER_MRK "testUnmask");
+
+ static const uint64_t iterations = 100;
+ static const uint64_t targetPoolSize = 8;
+
+ errlHndl_t err = 0;
+
+ ProcOps ops;
+ AttnData d;
+
+ FakeProcTargetService targetSvc(targetPoolSize);
+ FakeSystem system;
+
+ TargetHandleList procs;
+
+ targetSvc.getAllChips(procs, TYPE_PROC);
+
+ system.installScomImpl();
+
+ for(uint64_t it = 0; it < iterations; ++it)
+ {
+ d.targetHndl = *(&procs[0] + randint(0, targetPoolSize -1));
+ d.attnType = getRandomAttentionType();
+
+ // mask first
+
+ err = ops.mask(d);
+
+ if(err)
+ {
+ TS_FAIL("unexpected error masking attention");
+ break;
+ }
+
+ // put some random data in the mask register
+
+ uint64_t randomData = randint(0, 0xffffffff);
+ uint64_t maskbits = 0;
+
+ if(!IPOLL::getCheckbits(d.attnType, maskbits))
+ {
+ TS_FAIL("unexpected error calling getCheckbits");
+ break;
+ }
+
+ randomData = randomData | maskbits;
+
+ err = putScom(d.targetHndl, IPOLL::address, randomData);
+ if(err)
+ {
+ TS_FAIL("unexpected error calling putscom");
+ break;
+ }
+
+ err = ops.unmask(d);
+
+ if(err)
+ {
+ TS_FAIL("unexpected error masking attention");
+ break;
+ }
+
+ uint64_t data = 0;
+ err = getScom(d.targetHndl, IPOLL::address, data);
+ if(err)
+ {
+ TS_FAIL("unexpected error calling getscom");
+ break;
+ }
+
+ // verify that the attn was masked, and that
+ // other bits weren't touched
+
+ if(!(data & ~maskbits))
+ {
+ TS_FAIL("attention not unmasked");
+ break;
+ }
+
+ if((data | maskbits) != randomData)
+ {
+ TS_FAIL("unexpected data in mask register");
+ break;
+ }
+ }
+
+ TS_TRACE(EXIT_MRK "testUnmask");
+ }
+
+ /**
+ * @brief testQuery Unit test for the
+ * query method.
+ */
+ void testQuery(void)
+ {
+ static const uint64_t iterations = 100;
+ static const uint64_t targetPoolSize = 8;
+
+ TS_TRACE(ENTER_MRK "testQuery");
+
+ errlHndl_t err = 0;
+
+ ProcOps ops;
+ AttnData d;
+
+ FakeSystem system;
+ FakeProcTargetService targetSvc(targetPoolSize);
+
+ TargetHandleList procs;
+
+ targetSvc.getAllChips(procs, TYPE_PROC);
+
+ FakeGfir xstpGfir(CHECK_STOP),
+ spclGfir(SPECIAL),
+ recGfir(RECOVERABLE);
+
+ xstpGfir.install(system);
+ spclGfir.install(system);
+ recGfir.install(system);
+
+ system.installScomImpl();
+ targetSvc.installTargetService();
+
+ for(uint64_t it = 0; it < iterations; ++it)
+ {
+ bool result;
+
+ d.targetHndl = *(&procs[0] + randint(0, targetPoolSize -1));
+ d.attnType = getRandomAttentionType();
+
+ // set the error in hardware
+
+ err = system.putAttentions(AttnList(1, d));
+ if(err)
+ {
+ TS_FAIL("unexpected error calling putAttentions");
+ break;
+ }
+
+ err = ops.query(d, result);
+
+ if(err)
+ {
+ TS_FAIL("unexpected error calling query");
+ break;
+ }
+
+ if(!result)
+ {
+ TS_FAIL("expected attention");
+ break;
+ }
+
+ // clear the error in hardware
+
+ err = system.clearAttention(d);
+ if(err)
+ {
+ TS_FAIL("unexpected error calling clearAttention");
+ break;
+ }
+
+ err = ops.query(d, result);
+
+ if(err)
+ {
+ TS_FAIL("unexpected error calling query");
+ break;
+ }
+
+ if(result)
+ {
+ TS_FAIL("did not expect attention");
+ break;
+ }
+ }
+
+ TS_TRACE(EXIT_MRK "testQuery");
+ }
+
+ /**
+ * @brief testAttentions Unit test for the
+ * attnproc module.
+ */
+ void testAttentions()
+ {
+ static const uint64_t targetPoolSize = 8;
+ static const uint64_t iterations = 5;
+ static const uint64_t maxAttnsPerIteration = 5;
+
+ TS_TRACE(ENTER_MRK "testAttentions");
+
+ errlHndl_t err = 0;
+
+ Service svc;
+
+ FakePresenter presenter;
+ FakeSystem system;
+
+ FakeGfir xstpGfir(CHECK_STOP),
+ spclGfir(SPECIAL),
+ recGfir(RECOVERABLE);
+
+ xstpGfir.install(system);
+ spclGfir.install(system);
+ recGfir.install(system);
+
+ FakeIpoll xstpIpoll(CHECK_STOP, presenter),
+ spclIpoll(SPECIAL, presenter),
+ recIpoll(RECOVERABLE, presenter);
+
+ xstpIpoll.install(system);
+ spclIpoll.install(system);
+ recIpoll.install(system);
+
+ Validator v;
+
+ v.install(system);
+
+ system.installScomImpl();
+
+ FakeProcTargetService targetSvc(targetPoolSize);
+
+ TargetHandleList procs;
+
+ targetSvc.getAllChips(procs, TYPE_PROC);
+
+ RandSource source(
+ iterations,
+ maxAttnsPerIteration,
+ system,
+ &procs[0],
+ &procs[0] + procs.size());
+
+ targetSvc.installTargetService();
+
+ FakePrd prd(system);
+
+ prd.installPrd();
+
+ do
+ {
+ err = svc.start();
+
+ if(err)
+ {
+ TS_FAIL("unexpected error starting service");
+ break;
+ }
+
+ if(!presenter.start(svc.iv_intrTaskQ))
+ {
+ TS_FAIL("unexpected error starting fake presenter");
+ break;
+ }
+
+ if(!source.start())
+ {
+ TS_FAIL("unexpected error starting source");
+ break;
+ }
+
+ // wait for the testcase to finish injecting attentions
+
+ if(!source.wait())
+ {
+ TS_FAIL("unexpected error waiting for source");
+ break;
+ }
+
+ // wait for the the service to handle all the attentions
+ TS_TRACE("Waiting for attentions to be cleared.");
+
+ if(!system.wait(TEN_CTX_SWITCHES_NS * iterations * 50))
+ {
+ TS_FAIL("Attentions still present on system.");
+
+ system.dump();
+ break;
+ }
+
+ } while(0);
+
+ err = svc.stop();
+
+ if(err)
+ {
+ TS_FAIL("unexpected error stopping service");
+ delete err;
+ }
+
+ presenter.stop();
+
+ if(!v.empty())
+ {
+ TS_FAIL("unexpected result after injecting attentions");
+
+ v.dump();
+ }
+
+ TS_TRACE(EXIT_MRK "testAttentions");
+ }
+};
+#endif
diff --git a/src/usr/diag/attn/test/attnvalidate.C b/src/usr/diag/attn/test/attnvalidate.C
new file mode 100644
index 000000000..dec7766a9
--- /dev/null
+++ b/src/usr/diag/attn/test/attnvalidate.C
@@ -0,0 +1,329 @@
+/* IBM_PROLOG_BEGIN_TAG
+ * This is an automatically generated prolog.
+ *
+ * $Source: src/usr/diag/attn/test/attnvalidate.C $
+ *
+ * IBM CONFIDENTIAL
+ *
+ * COPYRIGHT International Business Machines Corp. 2012
+ *
+ * p1
+ *
+ * Object Code Only (OCO) source materials
+ * Licensed Internal Code Source Materials
+ * IBM HostBoot Licensed Internal Code
+ *
+ * The source code for this program is not published or other-
+ * wise divested of its trade secrets, irrespective of what has
+ * been deposited with the U.S. Copyright Office.
+ *
+ * Origin: 30
+ *
+ * IBM_PROLOG_END_TAG
+ */
+/**
+ * @file attnvalidate.C
+ *
+ * @brief HBATTN fake system validation class method definitions.
+ */
+
+#include "attncomp.H"
+#include "attnvalidate.H"
+#include "attnfakesys.H"
+#include "../attntarget.H"
+#include "../attntrace.H"
+
+using namespace PRDF;
+using namespace TARGETING;
+using namespace std;
+
+namespace ATTN
+{
+
+errlHndl_t Validator::processPutAttention(
+ FakeSystem & i_sys,
+ const AttnData & i_attention,
+ uint64_t i_count)
+{
+ // add this new attention to the list
+
+ Properties p;
+
+ p.targetHndl = i_attention.targetHndl;
+ p.attnType = i_attention.attnType;
+
+ TargetHandle_t target = 0;
+
+ uint64_t ipollCheckbits;
+
+ if(getTargetService().getType(i_attention.targetHndl) == TYPE_PROC)
+ {
+ IPOLL::getCheckbits(i_attention.attnType, ipollCheckbits);
+ target = i_attention.targetHndl;
+ }
+ else
+ {
+ IPOLL::getCheckbits(HOST, ipollCheckbits);
+
+ target = getTargetService().getProc(i_attention.targetHndl);
+ }
+
+ bool masked = i_sys.getReg(target, IPOLL::address) & ipollCheckbits;
+
+ if(!masked)
+ {
+ p.next = MASK;
+ }
+ else
+ {
+ p.next = CLEAR;
+ }
+
+ iv_properties.push_back(p);
+
+ return 0;
+}
+
+errlHndl_t Validator::processClearAttention(
+ FakeSystem & i_sys,
+ const AttnData & i_attention,
+ uint64_t i_count)
+{
+ do {
+
+ AttnDataEq comp(i_attention);
+
+ // there should be at least one matching
+ // attention ready to be cleared
+
+ vector<Properties>::iterator it = find_if(
+ iv_properties.begin(),
+ iv_properties.end(),
+ comp);
+
+ while(it != iv_properties.end())
+ {
+ if(it->next == CLEAR)
+ {
+ // this attention now ready to be unmasked
+
+ it->next = UNMASK;
+ break;
+ }
+
+ it = find_if(++it, iv_properties.end(), comp);
+ }
+
+ if(it == iv_properties.end())
+ {
+ ATTN_ERR("Validator: tgt: %p, type %d not ready to be cleared",
+ i_attention.targetHndl, i_attention.attnType);
+ }
+ }
+ while(0);
+
+ return 0;
+}
+
+struct AppendInnerLoopArgs
+{
+ AttnList * list;
+ TargetHandleList mcsList;
+};
+
+void appendInnerLoop(
+ uint64_t i_type,
+ void * i_args)
+{
+ AppendInnerLoopArgs * args = static_cast<AppendInnerLoopArgs *>(i_args);
+
+ AttnList & list = *args->list;
+ TargetHandleList & mcsList = args->mcsList;
+
+ AttnData d;
+
+ TargetHandleList::iterator it = mcsList.begin();
+
+ while(it != mcsList.end())
+ {
+ d.attnType = static_cast<ATTENTION_VALUE_TYPE>(i_type);
+ d.targetHndl = getTargetService().getMembuf(*it);
+
+ list.push_back(d);
+
+ ++it;
+ }
+}
+
+struct AppendOuterLoopArgs
+{
+ TargetHandle_t target;
+ AttnList list;
+};
+
+
+void appendOuterLoop(
+ uint64_t i_type,
+ void * i_args)
+{
+ AppendOuterLoopArgs * args = static_cast<AppendOuterLoopArgs *>(i_args);
+
+ AttnList & list = args->list;
+
+ AttnData d;
+ uint64_t hostmask;
+
+ IPOLL::getCheckbits(HOST, hostmask);
+
+ // assemble a list of all attentions to check
+
+ if(i_type == HOST)
+ {
+ // for host attn bit changed, check any attention
+ // type on any membufs behind this proc
+
+ AppendInnerLoopArgs innerLoopArgs;
+
+ innerLoopArgs.list = &args->list;
+
+ getTargetService().getMcsList(args->target, innerLoopArgs.mcsList);
+
+ IPOLL::forEach(
+ 0xffffffffffffffffull & ~hostmask,
+ &innerLoopArgs,
+ &appendInnerLoop);
+ }
+ else
+ {
+ // for other attn types, just check the proc
+
+ d.attnType = static_cast<ATTENTION_VALUE_TYPE>(i_type);
+ d.targetHndl = args->target;
+
+ list.push_back(d);
+ }
+}
+
+errlHndl_t Validator::processPutReg(
+ FakeSystem & i_sys,
+ TargetHandle_t i_target,
+ uint64_t i_address,
+ uint64_t i_new,
+ uint64_t i_old)
+{
+ AppendOuterLoopArgs args;
+
+ args.target = i_target;
+
+ // these bits turned off
+
+ IPOLL::forEach(i_old & ~i_new, &args, &appendOuterLoop);
+
+ AttnList::iterator it = args.list.begin();
+
+ while(it != args.list.end())
+ {
+ processUnmask(*it);
+ ++it;
+ }
+
+ args.list.clear();
+
+ // these bits turned on
+
+ IPOLL::forEach(i_new & ~i_old, &args, &appendOuterLoop);
+
+ it = args.list.begin();
+
+ while(it != args.list.end())
+ {
+ processMask(*it);
+ ++it;
+ }
+
+ return 0;
+}
+
+
+void Validator::processUnmask(const AttnData & i_data)
+{
+ AttnDataEq comp(i_data);
+
+ vector<Properties>::iterator pit = find_if(
+ iv_properties.begin(),
+ iv_properties.end(),
+ comp);
+
+ while(pit != iv_properties.end())
+ {
+ if(pit->next == UNMASK)
+ {
+ // finished with this attention
+
+ ATTN_DBG("Validator: tgt: %p, type: %d done.",
+ pit->targetHndl, pit->attnType);
+
+ pit = iv_properties.erase(pit);
+ }
+ else
+ {
+ ++pit;
+ }
+
+ pit = find_if(pit,
+ iv_properties.end(),
+ comp);
+ }
+}
+
+void Validator::processMask(const AttnData & i_data)
+{
+ AttnDataEq comp(i_data);
+
+ vector<Properties>::iterator pit = find_if(
+ iv_properties.begin(),
+ iv_properties.end(),
+ comp);
+
+ while(pit != iv_properties.end())
+ {
+ if(pit->next == MASK)
+ {
+ // this attention now ready to be cleared
+
+ pit->next = CLEAR;
+ }
+
+ pit = find_if(++pit,
+ iv_properties.end(),
+ comp);
+ }
+}
+
+void Validator::install(FakeSystem & i_sys)
+{
+ i_sys.addSource(TYPE_NA, INVALID_ATTENTION_TYPE, *this);
+
+ // monitor changes to ipoll
+ i_sys.addReg(IPOLL::address, *this);
+}
+
+bool Validator::empty() const
+{
+ return iv_properties.empty();
+}
+
+void Validator::dump() const
+{
+ vector<Properties>::const_iterator it =
+ iv_properties.begin();
+
+ while(it != iv_properties.end())
+ {
+ ATTN_DBG("target: %p, type: %d, next: %d",
+ it->targetHndl, it->attnType, it->next);
+
+ ++it;
+ }
+}
+}
diff --git a/src/usr/diag/attn/test/attnvalidate.H b/src/usr/diag/attn/test/attnvalidate.H
new file mode 100644
index 000000000..f962297ea
--- /dev/null
+++ b/src/usr/diag/attn/test/attnvalidate.H
@@ -0,0 +1,191 @@
+/* IBM_PROLOG_BEGIN_TAG
+ * This is an automatically generated prolog.
+ *
+ * $Source: src/usr/diag/attn/test/attnvalidate.H $
+ *
+ * IBM CONFIDENTIAL
+ *
+ * COPYRIGHT International Business Machines Corp. 2012
+ *
+ * p1
+ *
+ * Object Code Only (OCO) source materials
+ * Licensed Internal Code Source Materials
+ * IBM HostBoot Licensed Internal Code
+ *
+ * The source code for this program is not published or other-
+ * wise divested of its trade secrets, irrespective of what has
+ * been deposited with the U.S. Copyright Office.
+ *
+ * Origin: 30
+ *
+ * IBM_PROLOG_END_TAG
+ */
+#ifndef __TEST_ATTNVALIDATE_H
+#define __TEST_ATTNVALIDATE_H
+
+/**
+ * @file attnvalidate.H
+ *
+ * @brief HBATTN fake system validation class definitions.
+ */
+
+#include "attnfakeelement.H"
+
+namespace ATTN
+{
+
+/**
+ * @brief Validator
+ *
+ * Fake system validation class definition.
+ *
+ * Monitors attention state changes and ipoll mask
+ * changes.
+ *
+ * Accumulates attentions injected on the system and
+ * tracks attention mask -> clear -> unmask lifeccyle.
+ */
+class Validator : public FakeReg, public FakeSource
+{
+ public:
+
+ /**
+ * @brief ctor
+ */
+ Validator() {};
+
+ /**
+ * @brief dtor
+ */
+ ~Validator() {}
+
+ /**
+ * @brief install
+ *
+ * Register this object with the provided system for
+ * the appropriate callbacks.
+ *
+ * @param[in] i_system The system in which to register callbacks.
+ */
+ void install(FakeSystem & i_sys);
+
+ /**
+ * @brief processPutReg Process modified register content.
+ *
+ * @param[in] i_sys System that modified register content.
+ * @param[in] i_target Target whose registers were modified.
+ * @param[in] i_address Address of register that was modified.
+ * @param[in] i_new Register content after modification.
+ * @param[in] i_old Register content before modification.
+ *
+ * @retval[0] No error occurred.
+ * @retval[!0] Unexpected error occurred.
+ */
+ errlHndl_t processPutReg(
+ FakeSystem & i_sys,
+ TARGETING::TargetHandle_t i_target,
+ uint64_t i_address,
+ uint64_t i_new,
+ uint64_t i_old);
+
+ /**
+ * @brief processPutAttention Process injected attention.
+ *
+ * @param[in] i_sys System that modified register content.
+ * @param[in] i_attn Attention that was injected.
+ * @param[in] i_count number of attentions currently present.
+ *
+ * @retval[0] No error occurred.
+ * @retval[!0] Unexpected error occurred.
+ */
+ errlHndl_t processPutAttention(
+ FakeSystem & i_sys,
+ const PRDF::AttnData & i_attn,
+ uint64_t i_count);
+
+ /**
+ * @brief processClearAttention Process cleared attention.
+ *
+ * @param[in] i_sys System that modified register content.
+ * @param[in] i_attn Attention that was cleared.
+ * @param[in] i_count number of attentions currently present.
+ *
+ * @retval[0] No error occurred.
+ * @retval[!0] Unexpected error occurred.
+ */
+ errlHndl_t processClearAttention(
+ FakeSystem & i_sys,
+ const PRDF::AttnData & i_attn,
+ uint64_t i_count);
+
+ /**
+ * @brief empty
+ *
+ * Indicates whether or not all attentions successfully
+ * completed the mask -> clear -> unmask lifecycle.
+ *
+ * @return[true] All lifecycles completed.
+ * @return[false] One or more lifecycles incomplete.
+ */
+ bool empty() const;
+
+ /**
+ * @brief dump
+ *
+ * Dump the list of attentions with incomplete lifecycles.
+ */
+ void dump() const;
+
+ private:
+
+ /**
+ * @brief processUnmask
+ *
+ * Unmask specific handling for ipoll mask register changes.
+ *
+ * @param[in] i_data The attention type that was unmasked.
+ */
+ void processUnmask(const PRDF::AttnData & i_data);
+
+ /**
+ * @brief processMask
+ *
+ * Mask specific handling for ipoll mask register changes.
+ *
+ * @param[in] i_data The attention type that was masked.
+ */
+ void processMask(const PRDF::AttnData & i_data);
+
+ /**
+ * @brief Attention lifecycle enumeration.
+ */
+ enum
+ {
+ MASK = 1,
+ UNMASK,
+ CLEAR,
+ DONE,
+ };
+
+ /**
+ * @brief Properties
+ *
+ * Adds an additional attribute to an AttnData struct.
+ */
+ struct Properties : public PRDF::AttnData
+ {
+ /**
+ * @brief next The expected next state for this attention
+ * in the mask -> clear -> unmask lifecycle.
+ */
+ uint64_t next;
+ };
+
+ /**
+ * @brief Attnetion type status association list.
+ */
+ std::vector<Properties> iv_properties;
+};
+}
+#endif
diff --git a/src/usr/diag/attn/test/makefile b/src/usr/diag/attn/test/makefile
index bb47c41db..905760162 100644
--- a/src/usr/diag/attn/test/makefile
+++ b/src/usr/diag/attn/test/makefile
@@ -25,7 +25,8 @@ ROOTPATH = ../../../../..
EXTRAINCDIR += ${ROOTPATH}/src/include/usr/diag
OBJS = attnfakesys.o attntest.o attnrand.o attnfakepresenter.o attnfakeprd.o \
- attnfaketarget.o attnrandsource.o attnfakegfir.o attnfakeipoll.o
+ attnfaketarget.o attnrandsource.o attnfakegfir.o attnfakeipoll.o \
+ attnvalidate.o
MODULE = testattn
OpenPOWER on IntegriCloud