434 lines
17 KiB
C++
434 lines
17 KiB
C++
#include "sys_task_req.h"
|
|
#include "cray_mainframe.h"
|
|
#include "cray_cpu.h"
|
|
|
|
struct SysCallEntry_s {
|
|
char Name[16];
|
|
uint32_t Flags;
|
|
uint32_t ArgCnt;
|
|
uint64_t HandlerAddr;
|
|
uint64_t NumCalls;
|
|
uint64_t TotalTime;
|
|
uint64_t MaxTime;
|
|
uint64_t MinTime;
|
|
};
|
|
|
|
static CAddr_t SysCallTableBase;
|
|
static size_t SysCallTableSize;
|
|
|
|
void SetupSystaskParser(const Configuration_c &aConfig) {
|
|
SysCallTableBase = aConfig.get<CAddr_t>("SysCallTableBase");
|
|
CAddr_t SysCallTableEnd = aConfig.get<CAddr_t>("SysCallTableEnd");
|
|
SysCallTableSize = (size_t(SysCallTableEnd) - size_t(SysCallTableBase)) / sizeof(SysCallEntry_s) * 8;
|
|
}
|
|
|
|
#if defined(PARTIAL_DEBUG) && defined(_MSC_VER)
|
|
#pragma optimize ("", off)
|
|
#endif
|
|
|
|
SysCallEntry_s GetSysCallEntry(size_t aSysCallNumber, const class Mainframe_c &aMainframe) {
|
|
SysCallEntry_s Entry;
|
|
const size_t SysCallEntrySize = sizeof(SysCallEntry_s);
|
|
for (size_t Idx = 0; Idx < SysCallEntrySize / sizeof(uint64_t); ++Idx) {
|
|
((uint64_t*)(&Entry))[Idx] = aMainframe.MemReadNoWatchpoint<uint64_t>(CAddr_t(SysCallTableBase + (8 * aSysCallNumber + Idx)));
|
|
if (Idx > 1) ((uint64_t*)(&Entry))[Idx] = SwapBytes(((uint64_t*)(&Entry))[Idx]);
|
|
}
|
|
return Entry;
|
|
}
|
|
|
|
void DumpSyscallStats(std::ostream &aLogger, const class Mainframe_c &aMainframe, OsTypes_e aOsType) {
|
|
if (aOsType != OsTypes_e::UNICOS) return;
|
|
for (size_t SysCall = 0; SysCall < SysCallTableSize; ++SysCall) {
|
|
try {
|
|
SysCallEntry_s Entry = GetSysCallEntry(SysCall, aMainframe);
|
|
if (Entry.NumCalls > 0) {
|
|
aLogger << "SYSCALL: " << DecPrinter(SysCall) << " " << Entry.Name << " # calls: " << DecPrinter(Entry.NumCalls);
|
|
aLogger << " total time: " << DecPrinter(Entry.TotalTime);
|
|
aLogger << " max time: " << DecPrinter(Entry.MaxTime);
|
|
aLogger << " min time: " << DecPrinter(Entry.MinTime);
|
|
aLogger << std::endl;
|
|
}
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
}
|
|
}
|
|
|
|
void PrintString(std::ostream &aLogger, CAddr_t aAddr, const Mainframe_c &aMainframe) {
|
|
aLogger << "\"";
|
|
try {
|
|
bool Done = false;
|
|
while (!Done) {
|
|
uint64_t Data = aMainframe.MemReadNoWatchpoint<uint64_t>(aAddr);
|
|
char *Str = (char *)(&Data);
|
|
for (size_t Idx = 0; Idx < 8; ++Idx) {
|
|
if (Str[Idx] == 0) {
|
|
Done = true;
|
|
break;
|
|
}
|
|
aLogger << Str[Idx];
|
|
}
|
|
aAddr = aAddr + 1;
|
|
};
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
aLogger << "\"";
|
|
}
|
|
|
|
void PrintMemDump(std::ostream &aLogger, CAddr_t aAddr, size_t aSize, const Mainframe_c &aMainframe) {
|
|
aLogger << "\"";
|
|
try {
|
|
for (size_t i = 0; i < aSize;) {
|
|
uint64_t Data = aMainframe.MemReadNoWatchpoint<uint64_t>(aAddr);
|
|
char *Str = (char *)(&Data);
|
|
for (size_t Idx = 0; Idx < 8; ++Idx, ++i) {
|
|
aLogger << PrintableChar(Str[Idx]);
|
|
if (i >= aSize) break;
|
|
}
|
|
aAddr = aAddr + 1;
|
|
};
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
aLogger << "\" ";
|
|
bool Done = false;
|
|
try {
|
|
for (size_t i = 0; i < aSize;) {
|
|
uint64_t Data = aMainframe.MemReadNoWatchpoint<uint64_t>(aAddr);
|
|
char *Str = (char *)(&Data);
|
|
for (size_t Idx = 0; Idx < 8; ++Idx, ++i) {
|
|
aLogger << HexPrinter(Str[Idx], 2) << " ";
|
|
if (i >= aSize) break;
|
|
}
|
|
aAddr = aAddr + 1;
|
|
};
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
}
|
|
|
|
void PrintMemArrayArg(std::ostream &aLogger, size_t aArg, size_t aSizeArg, const ExchangePacket_c &aExchangePacket, const Mainframe_c &aMainframe) {
|
|
CInt_t S1 = aExchangePacket.GetS(1);
|
|
CAddr_t DataBase = aExchangePacket.GetDataBaseAddr();
|
|
CAddr_t Args = CAddr_t(S1) + DataBase;
|
|
|
|
try {
|
|
CAddr_t Addr = CAddr_t(SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(CAddr_t(Args + aArg))));
|
|
CAddr_t Size = CAddr_t(SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(CAddr_t(Args + aSizeArg))));
|
|
aLogger << HexPrinter(Addr) << " (" << HexPrinter(Addr + DataBase) << "), len: " << DecPrinter(Size);
|
|
if (Size < 256) {
|
|
aLogger << " content: ";
|
|
PrintMemDump(aLogger, Addr + DataBase, Size, aMainframe);
|
|
}
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
}
|
|
|
|
void PrintStringArg(std::ostream &aLogger, size_t aArg, const ExchangePacket_c &aExchangePacket, const Mainframe_c &aMainframe) {
|
|
CInt_t S1 = aExchangePacket.GetS(1);
|
|
CAddr_t DataBase = aExchangePacket.GetDataBaseAddr();
|
|
CAddr_t Args = CAddr_t(S1) + DataBase;
|
|
|
|
try {
|
|
CAddr_t Addr = CAddr_t(SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(CAddr_t(Args + aArg))));
|
|
aLogger << HexPrinter(Addr) << " (" << HexPrinter(Addr + DataBase) << ") ";
|
|
PrintString(aLogger, Addr + DataBase, aMainframe);
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
}
|
|
|
|
void PrintStringArrayArg(std::ostream &aLogger, size_t aArg, const ExchangePacket_c &aExchangePacket, const Mainframe_c &aMainframe) {
|
|
CInt_t S1 = aExchangePacket.GetS(1);
|
|
CAddr_t DataBase = aExchangePacket.GetDataBaseAddr();
|
|
CAddr_t Args = CAddr_t(S1) + DataBase;
|
|
|
|
try {
|
|
CAddr_t ArrAddr = CAddr_t(SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(CAddr_t(Args + aArg))));
|
|
aLogger << HexPrinter(ArrAddr) << " (" << HexPrinter(ArrAddr + DataBase) << ") ";
|
|
|
|
if (ArrAddr != 0) {
|
|
aLogger << " [ ";
|
|
bool First = true;
|
|
CAddr_t Ptr = CAddr_t(SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(ArrAddr + DataBase)));
|
|
while (Ptr != 0) {
|
|
if (!First) aLogger << " , ";
|
|
First = false;
|
|
aLogger << HexPrinter(Ptr) << " (" << HexPrinter(Ptr + DataBase) << ") ";
|
|
PrintString(aLogger, Ptr + DataBase, aMainframe);
|
|
++ArrAddr;
|
|
Ptr = CAddr_t(SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(ArrAddr + DataBase)));
|
|
}
|
|
aLogger << " ]";
|
|
}
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
}
|
|
|
|
void PrintPtrArg(std::ostream &aLogger, size_t aArg, const ExchangePacket_c &aExchangePacket, const Mainframe_c &aMainframe) {
|
|
CInt_t S1 = aExchangePacket.GetS(1);
|
|
CAddr_t DataBase = aExchangePacket.GetDataBaseAddr();
|
|
CAddr_t Args = CAddr_t(S1) + DataBase;
|
|
|
|
try {
|
|
CAddr_t Addr = CAddr_t(SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(CAddr_t(Args + aArg))));
|
|
aLogger << HexPrinter(Addr) << " (" << HexPrinter(Addr + DataBase) << ") --> " << HexPrinter(SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(Addr + DataBase)));
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
}
|
|
|
|
void PrintIntArg(std::ostream &aLogger, size_t aArg, const ExchangePacket_c &aExchangePacket, const Mainframe_c &aMainframe) {
|
|
CInt_t S1 = aExchangePacket.GetS(1);
|
|
CAddr_t DataBase = aExchangePacket.GetDataBaseAddr();
|
|
CAddr_t Args = CAddr_t(S1) + DataBase;
|
|
|
|
try {
|
|
CInt_t Data = (SwapBytes(aMainframe.MemReadNoWatchpoint<uint64_t>(CAddr_t(Args + aArg))));
|
|
aLogger << HexPrinter(Data) << " (" << DecPrinter(Data) << ")";
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
}
|
|
|
|
void ParseUnicosExchangePacket(const ExchangePacket_c &aCurrentEP, const ExchangePacket_c &aNewEP, std::ostream &aLogger, const Cpu_c &aCpu) {
|
|
static size_t LastSysCall = SIZE_MAX;
|
|
const Mainframe_c &Mainframe = aCpu.GetMainframe();
|
|
if (aCurrentEP.GetMode().IsMonitorMode()) {
|
|
CInt_t S[8];
|
|
for (size_t Idx = 0; Idx<sizeof(S) / sizeof(S[0]); ++Idx) S[Idx] = aNewEP.GetS(Idx);
|
|
CInt_t A[8];
|
|
for (size_t Idx = 0; Idx<sizeof(A) / sizeof(A[0]); ++Idx) A[Idx] = aNewEP.GetA(Idx);
|
|
|
|
// Swapping out from monitor mode - parse it as a reply
|
|
if (LastSysCall < SysCallTableSize) {
|
|
try {
|
|
SysCallEntry_s Entry = GetSysCallEntry(LastSysCall, Mainframe);
|
|
aLogger << "SYSCALL: " << DecPrinter(LastSysCall) << " " << Entry.Name << " returning " << HexPrinter(S[1]) << " (" << DecPrinter(S[1]) << ")";
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << "SYSCALL: ~~~ invalid ~~~ ";
|
|
}
|
|
} else {
|
|
// aLogger << "GOING OUT OF MONITOR MODE";
|
|
}
|
|
LastSysCall = SIZE_MAX;
|
|
} else {
|
|
CInt_t S[8];
|
|
for (size_t Idx = 0; Idx<sizeof(S) / sizeof(S[0]); ++Idx) S[Idx] = aCurrentEP.GetS(Idx);
|
|
CInt_t A[8];
|
|
for (size_t Idx = 0; Idx<sizeof(A) / sizeof(A[0]); ++Idx) A[Idx] = aCurrentEP.GetA(Idx);
|
|
|
|
LastSysCall = SIZE_MAX;
|
|
if (aCurrentEP.GetFlag().IsNormalExit()) {
|
|
// Swapping in to monitor mode - parse it as a request
|
|
size_t SysCall = size_t(S[0]);
|
|
if (SysCall < SysCallTableSize && aCurrentEP.GetInstBaseAddr() != 0) {
|
|
aLogger << "XA: " << HexPrinter(aCpu.GetExchangePacketAddress()) << " " << "IBA: " << HexPrinter(aCurrentEP.GetInstBaseAddr()) << " ";
|
|
LastSysCall = SysCall;
|
|
CAddr_t DataBase = aCurrentEP.GetDataBaseAddr();
|
|
CAddr_t Args = CAddr_t(S[1]) + DataBase;
|
|
try {
|
|
SysCallEntry_s Entry = GetSysCallEntry(SysCall, Mainframe);
|
|
aLogger << "SYSCALL: " << DecPrinter(SysCall) << " " << Entry.Name << "(";
|
|
switch (SysCall) {
|
|
case 4: // write
|
|
PrintIntArg(aLogger, 0, aCurrentEP, Mainframe);
|
|
aLogger << " , ";
|
|
PrintMemArrayArg(aLogger, 1, 2, aCurrentEP, Mainframe);
|
|
case 5: // open
|
|
PrintStringArg(aLogger, 0, aCurrentEP, Mainframe);
|
|
aLogger << " , ";
|
|
PrintIntArg(aLogger, 1, aCurrentEP, Mainframe);
|
|
break;
|
|
case 0x3b: // exece
|
|
PrintStringArg(aLogger, 0, aCurrentEP, Mainframe);
|
|
aLogger << " , ";
|
|
PrintStringArrayArg(aLogger, 1, aCurrentEP, Mainframe);
|
|
aLogger << " , ";
|
|
PrintStringArrayArg(aLogger, 2, aCurrentEP, Mainframe);
|
|
break;
|
|
default:
|
|
for (uint32_t ArgIdx = 0; ArgIdx < std::min(Entry.ArgCnt, uint32_t(10)); ++ArgIdx) {
|
|
if (ArgIdx != 0) aLogger << " , ";
|
|
try {
|
|
aLogger << HexPrinter(
|
|
SwapBytes(
|
|
Mainframe.MemReadNoWatchpoint<uint64_t>(Args + ArgIdx)
|
|
)
|
|
);
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << " ~~~ invalid ~~~ ";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
aLogger << ")";
|
|
}
|
|
catch (Mainframe_c::ReadOutOfBoundsError_x &) {
|
|
aLogger << "SYSCALL: ~~~ invalid ~~~ ";
|
|
}
|
|
} else {
|
|
//aLogger << "XA: " << HexPrinter(aCpu.GetExchangePacketAddress()) << " " << "IBA: " << HexPrinter(aCurrentEP.GetInstBaseAddr()) << " ";
|
|
//aLogger << "unknown SYSCALL with S0 = " << HexPrinter(S[0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(PARTIAL_DEBUG) && defined(_MSC_VER)
|
|
#pragma optimize ("", on)
|
|
#endif
|
|
|
|
void ParseCosExchangePacket(const ExchangePacket_c &aExchangePacket, std::ostream &aLogger, const class Mainframe_c &aMainframe) {
|
|
CInt_t S[8];
|
|
for(size_t Idx=0;Idx<sizeof(S)/sizeof(S[0]);++Idx) S[Idx] = aExchangePacket.GetS(Idx);
|
|
/* CInt_t A[8];
|
|
for(size_t Idx=0;Idx<sizeof(A)/sizeof(A[0]);++Idx) A[Idx] = aExchangePacket.GetA(Idx);*/
|
|
if (aExchangePacket.GetMode().IsMonitorMode()) {
|
|
// Swapping out from monitor mode - parse it as a reply
|
|
aLogger << "GOING OUT OF MONITOR MODE";
|
|
} else {
|
|
// Swapping in to monitor mode - parse it as a request
|
|
uint8_t RequestCode = uint8_t(GetBitsReverse(S[7],55,63));
|
|
switch (RequestCode) {
|
|
case 001: { // Create Task
|
|
char TaskName[9];
|
|
CInt_t Tmp = SwapBytes(S[5]);
|
|
memcpy(TaskName,&Tmp,sizeof(Tmp));
|
|
TaskName[8] = 0;
|
|
uint8_t Priority = uint8_t(GetBitsReverse(S[6],48,55));
|
|
uint8_t Id = uint8_t(GetBitsReverse(S[6],56,63));
|
|
CProgramAddr_t StartAddr = CProgramAddr_t(GetBitsReverse(S[7], 16, 39));
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - CREATE_TASK - TASK NAME: " << TaskName << " PRIORITY: " << DecPrinter(Priority,0) << " ID: " << DecPrinter(Id,0) << " START ADDRESS: " << InstAddr(StartAddr);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 002: { // Ready system task
|
|
bool T = bool(GetBitsReverse(S[7],0,0) != 0);
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - READY_SYSTEM_TASK - T: " << (T ? "yes":"no") << " - S1: " << HexPrinter(S[1]) << " - S2: " << HexPrinter(S[2]) << " - TASK: " << OctPrinter(S[6]);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 003: { // Self-suspend
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - SELF-SUSPEND";
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 005: { // Front-end driver request
|
|
uint8_t RequestKind = uint8_t(GetBitsReverse(S[6],0,3));
|
|
CAddr_t Lxt = CAddr_t(GetBitsReverse(S[6],16,19));
|
|
CAddr_t Lit = CAddr_t(GetBitsReverse(S[6],40,63));
|
|
uint8_t Cht = uint8_t(GetBitsReverse(S[7],37,40));
|
|
uint8_t Cho = uint8_t(GetBitsReverse(S[7],41,48));
|
|
uint8_t Chn = uint8_t(GetBitsReverse(S[7],49,54));
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - FRONT-END DRIVER REQUEST - REQ: " << DecPrinter(RequestKind,0) << " LXT: " << Addr(Lxt) << " LIT: " << Addr(Lit) << " CHT: " << DecPrinter(Cht,0) << " CHO: " << DecPrinter(Cho,0) << " CHN: " << DecPrinter(Chn,0);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 006: { // Task-delay
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - TASK-DELAY - RT: " << HexPrinter(S[6]) << " - clock cycles from now: " << DecPrinter(S[6] - aMainframe.GetRealTimeClock(),0);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 010: { // Start second CPU
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - START_SECOND_CPU";
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 011: { // Disk blok I/O request
|
|
CAddr_t EQT = CAddr_t(GetBitsReverse(S[6],40,63));
|
|
CAddr_t DCT = CAddr_t(GetBitsReverse(S[7],16,39));
|
|
CAddr_t CHT = CAddr_t(GetBitsReverse(S[7],40,54));
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - DISK_BLOCK_IO - EQT: " << Addr(EQT) << " - DCT: " << Addr(DCT) << " - CHT: " << Addr(CHT);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 014: { // Ready system task and self-syspend
|
|
bool T = bool(GetBitsReverse(S[7],0,0) != 0);
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - READY_SYSTEM_TASK_AND-SELF_SUSPEND (RTSS) - T: " << (T ? "yes":"no") << " - S1: " << HexPrinter(S[1]) << " - S2: " << HexPrinter(S[2]) << " - TASK: " << OctPrinter(S[6]);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 016: { // Connect user task tp CPU
|
|
bool RCLDCL = bool(GetBitsReverse(S[6],0,0) != 0);
|
|
uint8_t RCCLN = uint8_t(GetBitsReverse(S[6],1,5));
|
|
uint32_t RCTXT = uint32_t(GetBitsReverse(S[6],32,63));
|
|
uint64_t RCTS = uint64_t(GetBitsReverse(S[7],0,54));
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - CONNECT_TASK_TO_CPU (RCP) - RCLDCL: " << (RCLDCL ? "yes":"no") << " - RCCLN: " << DecPrinter(RCCLN) << " - RCTXT: " << HexPrinter(RCTXT) << " RCTS: " << DecPrinter(RCTS);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 017: { // Disconnect user task tp CPU
|
|
bool DSCTCL = bool(GetBitsReverse(S[6],0,0) != 0);
|
|
uint32_t DCTXT = uint32_t(GetBitsReverse(S[6],32,63));
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - DISCONNECT_TASK_FROM_CPU (DCP) - DSCTCL: " << (DSCTCL ? "yes":"no") << " - DCTXT: " << HexPrinter(DCTXT);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 020: { // Post message in history buffer
|
|
uint8_t FirstS = uint8_t(GetBitsReverse(S[7],42,44));
|
|
uint8_t SecondS = uint8_t(GetBitsReverse(S[7],45,47));
|
|
uint32_t DebugFnCode = uint32_t(GetBitsReverse(S[7],48,54));
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - POST - FirstS: " << DecPrinter(FirstS) << " [" << HexPrinter(S[FirstS]) << "]" << " - SecondS: " << DecPrinter(SecondS) << " [" << HexPrinter(S[SecondS]) << "]" << " - DebugFnCode: " << OctPrinter(DebugFnCode);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 022: { // Packet I/O request
|
|
CAddr_t SCT = CAddr_t(GetBitsReverse(S[6],40,63));
|
|
uint8_t PFC = uint8_t(GetBitsReverse(S[7],52,54));
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - PACKET_IO (PIO) - SCT : " << Addr(SCT) << " - PFC: " << DecPrinter(PFC);
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
case 025: { // System Stop
|
|
std::stringstream Event;
|
|
Event << "SYS_TASK_REQ - STOP";
|
|
aLogger << Event.str() << std::endl;
|
|
aMainframe.GetEventDispatcher().Fire(Event.str());
|
|
} break;
|
|
default:
|
|
aLogger << "UNKNOWN EXCHANGE PACKET - REQUEST CODE: " << DecPrinter(RequestCode,0) << " - S6: " << HexPrinter(S[6]) << " - S7: " << HexPrinter(S[7]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParseExchangePacket(const ExchangePacket_c &aCurrentEP, const ExchangePacket_c &aNewEP, std::ostream &aLogger, const class Cpu_c &aCpu, OsTypes_e aOsType) {
|
|
switch (aOsType) {
|
|
case OsTypes_e::None: break;
|
|
case OsTypes_e::COS:
|
|
ParseCosExchangePacket(aCurrentEP, aLogger, aCpu.GetMainframe());
|
|
break;
|
|
case OsTypes_e::UNICOS:
|
|
ParseUnicosExchangePacket(aCurrentEP, aNewEP, aLogger, aCpu);
|
|
break;
|
|
}
|
|
}
|
|
|