}
void serialize(EventManager *em, std::ostream &os)
- {}
+ {
+ DPRINTF(Checkpoint, "Serializing Arm Misc Registers\n");
+ SERIALIZE_ARRAY(miscRegs, NumMiscRegs);
+ }
void unserialize(EventManager *em, Checkpoint *cp,
const std::string §ion)
- {}
+ {
+ DPRINTF(Checkpoint, "Unserializing Arm Misc Registers\n");
+ UNSERIALIZE_ARRAY(miscRegs, NumMiscRegs);
+ CPSR tmp_cpsr = miscRegs[MISCREG_CPSR];
+ updateRegMap(tmp_cpsr);
+ }
ISA()
{
}
void
-LinuxArmSystem::startup()
+LinuxArmSystem::initState()
{
- ArmSystem::startup();
+ ArmSystem::initState();
ThreadContext *tc = threadContexts[0];
// Set the initial PC to be at start of the kernel code
{
}
-
LinuxArmSystem *
LinuxArmSystemParams::create()
{
LinuxArmSystem(Params *p);
~LinuxArmSystem();
- /** Initialize the CPU for booting */
- void startup();
+ void initState();
+
private:
#ifndef NDEBUG
/** Event to halt the simulator if the kernel calls panic() */
#include "arch/arm/vtophys.hh"
#include "config/full_system.hh"
+#include "sim/serialize.hh"
+
namespace ArmISA {
struct VAddr
};
-struct TlbRange
-{
- Addr va;
- Addr size;
- int contextId;
- bool global;
-
- inline bool
- operator<(const TlbRange &r2) const
- {
- if (!(global || r2.global)) {
- if (contextId < r2.contextId)
- return true;
- else if (contextId > r2.contextId)
- return false;
- }
-
- if (va < r2.va)
- return true;
- return false;
- }
-
- inline bool
- operator==(const TlbRange &r2) const
- {
- return va == r2.va &&
- size == r2.size &&
- contextId == r2.contextId &&
- global == r2.global;
- }
-};
-
-
// ITB/DTB table entry
struct TlbEntry
{
// Access permissions
bool xn; // Execute Never
- uint8_t ap:3; // Access permissions bits
- uint8_t domain:4; // Access Domain
-
- TlbRange range; // For fast TLB searching
+ uint8_t ap; // Access permissions bits
+ uint8_t domain; // Access Domain
//Construct an entry that maps to physical address addr for SE mode
TlbEntry(Addr _asn, Addr _vaddr, Addr _paddr)
return (pfn << N) | (va & size);
}
- void serialize(std::ostream &os) { panic("Need to Implement\n"); }
- void unserialize(Checkpoint *cp, const std::string §ion)
- { panic("Need to Implement\n");}
+ void
+ serialize(std::ostream &os)
+ {
+ SERIALIZE_SCALAR(pfn);
+ SERIALIZE_SCALAR(size);
+ SERIALIZE_SCALAR(vpn);
+ SERIALIZE_SCALAR(asid);
+ SERIALIZE_SCALAR(N);
+ SERIALIZE_SCALAR(global);
+ SERIALIZE_SCALAR(valid);
+ SERIALIZE_SCALAR(nonCacheable);
+ SERIALIZE_SCALAR(sNp);
+ SERIALIZE_ENUM(mtype);
+ SERIALIZE_SCALAR(innerAttrs);
+ SERIALIZE_SCALAR(outerAttrs);
+ SERIALIZE_SCALAR(shareable);
+ SERIALIZE_SCALAR(attributes);
+ SERIALIZE_SCALAR(xn);
+ SERIALIZE_SCALAR(ap);
+ SERIALIZE_SCALAR(domain);
+ }
+ void
+ unserialize(Checkpoint *cp, const std::string §ion)
+ {
+ UNSERIALIZE_SCALAR(pfn);
+ UNSERIALIZE_SCALAR(size);
+ UNSERIALIZE_SCALAR(vpn);
+ UNSERIALIZE_SCALAR(asid);
+ UNSERIALIZE_SCALAR(N);
+ UNSERIALIZE_SCALAR(global);
+ UNSERIALIZE_SCALAR(valid);
+ UNSERIALIZE_SCALAR(nonCacheable);
+ UNSERIALIZE_SCALAR(sNp);
+ UNSERIALIZE_ENUM(mtype);
+ UNSERIALIZE_SCALAR(innerAttrs);
+ UNSERIALIZE_SCALAR(outerAttrs);
+ UNSERIALIZE_SCALAR(shareable);
+ UNSERIALIZE_SCALAR(attributes);
+ UNSERIALIZE_SCALAR(xn);
+ UNSERIALIZE_SCALAR(ap);
+ UNSERIALIZE_SCALAR(domain);
+ }
+
};
}
-unsigned int
-drain(Event *de)
+unsigned int TableWalker::drain(Event *de)
{
- panic("Not implemented\n");
+ if (stateQueueL1.size() != 0 || stateQueueL2.size() != 0)
+ {
+ changeState(Draining);
+ DPRINTF(Checkpoint, "TableWalker busy, wait to drain\n");
+ return 1;
+ }
+ else
+ {
+ changeState(Drained);
+ DPRINTF(Checkpoint, "TableWalker free, no need to drain\n");
+ return 0;
+ }
}
Port*
return dynamic_cast<const Params *>(_params);
}
- virtual unsigned int drain(Event *de) { panic("write me\n"); }
+ virtual unsigned int drain(Event *de);
virtual Port *getPort(const std::string &if_name, int idx = -1);
Fault walk(RequestPtr req, ThreadContext *tc, uint8_t cid, TLB::Mode mode,
void
TLB::serialize(ostream &os)
{
- panic("Implement Serialize\n");
+ DPRINTF(Checkpoint, "Serializing Arm TLB\n");
+
+ SERIALIZE_SCALAR(_attr);
+ for(int i = 0; i < size; i++){
+ nameOut(os, csprintf("%s.TlbEntry%d", name(), i));
+ table[i].serialize(os);
+ }
}
void
TLB::unserialize(Checkpoint *cp, const string §ion)
{
+ DPRINTF(Checkpoint, "Unserializing Arm TLB\n");
- panic("Need to properly unserialize TLB\n");
+ UNSERIALIZE_SCALAR(_attr);
+ for(int i = 0; i < size; i++){
+ table[i].unserialize(cp, csprintf("%s.TlbEntry%d", section, i));
+ }
}
void
MustBeOne = 0x80
};
protected:
- typedef std::multimap<Addr, int> PageTable;
- PageTable lookupTable; // Quick lookup into page table
TlbEntry *table; // the Page Table
int size; // TLB Size
void
Gic::serialize(std::ostream &os)
{
- panic("Need to implement serialization\n");
+ DPRINTF(Checkpoint, "Serializing Arm GIC\n");
+
+ SERIALIZE_SCALAR(distAddr);
+ SERIALIZE_SCALAR(cpuAddr);
+ SERIALIZE_SCALAR(distPioDelay);
+ SERIALIZE_SCALAR(cpuPioDelay);
+ SERIALIZE_SCALAR(enabled);
+ SERIALIZE_SCALAR(itLines);
+ SERIALIZE_SCALAR(itLinesLog2);
+ SERIALIZE_ARRAY(intEnabled, 32);
+ SERIALIZE_ARRAY(pendingInt, 32);
+ SERIALIZE_ARRAY(activeInt, 32);
+ SERIALIZE_ARRAY(iccrpr, 8);
+ SERIALIZE_ARRAY(intPriority, 1020);
+ SERIALIZE_ARRAY(cpuTarget, 1020);
+ SERIALIZE_ARRAY(intConfig, 64);
+ SERIALIZE_ARRAY(cpuEnabled, 8);
+ SERIALIZE_ARRAY(cpuPriority, 8);
+ SERIALIZE_ARRAY(cpuBpr, 8);
+ SERIALIZE_ARRAY(cpuHighestInt, 8);
+ SERIALIZE_SCALAR(irqEnable);
}
void
Gic::unserialize(Checkpoint *cp, const std::string §ion)
{
- panic("Need to implement serialization\n");
+ DPRINTF(Checkpoint, "Unserializing Arm GIC\n");
+
+ UNSERIALIZE_SCALAR(distAddr);
+ UNSERIALIZE_SCALAR(cpuAddr);
+ UNSERIALIZE_SCALAR(distPioDelay);
+ UNSERIALIZE_SCALAR(cpuPioDelay);
+ UNSERIALIZE_SCALAR(enabled);
+ UNSERIALIZE_SCALAR(itLines);
+ UNSERIALIZE_SCALAR(itLinesLog2);
+ UNSERIALIZE_ARRAY(intEnabled, 32);
+ UNSERIALIZE_ARRAY(pendingInt, 32);
+ UNSERIALIZE_ARRAY(activeInt, 32);
+ UNSERIALIZE_ARRAY(iccrpr, 8);
+ UNSERIALIZE_ARRAY(intPriority, 1020);
+ UNSERIALIZE_ARRAY(cpuTarget, 1020);
+ UNSERIALIZE_ARRAY(intConfig, 64);
+ UNSERIALIZE_ARRAY(cpuEnabled, 8);
+ UNSERIALIZE_ARRAY(cpuPriority, 8);
+ UNSERIALIZE_ARRAY(cpuBpr, 8);
+ UNSERIALIZE_ARRAY(cpuHighestInt, 8);
+ UNSERIALIZE_SCALAR(irqEnable);
}
Gic *
void
Pl011::serialize(std::ostream &os)
{
- panic("Need to implement serialization\n");
+ DPRINTF(Checkpoint, "Serializing Arm PL011\n");
+ SERIALIZE_SCALAR(control);
+ SERIALIZE_SCALAR(fbrd);
+ SERIALIZE_SCALAR(ibrd);
+ SERIALIZE_SCALAR(lcrh);
+ SERIALIZE_SCALAR(ifls);
+
+ uint16_t imsc_serial = imsc;
+ SERIALIZE_SCALAR(imsc_serial);
+
+ uint16_t rawInt_serial = rawInt;
+ SERIALIZE_SCALAR(rawInt_serial);
+
+ uint16_t maskInt_serial = maskInt;
+ SERIALIZE_SCALAR(maskInt_serial);
+
+ SERIALIZE_SCALAR(endOnEOT);
+ SERIALIZE_SCALAR(intDelay);
}
void
Pl011::unserialize(Checkpoint *cp, const std::string §ion)
{
- panic("Need to implement serialization\n");
+ DPRINTF(Checkpoint, "Unserializing Arm PL011\n");
+
+ UNSERIALIZE_SCALAR(control);
+ UNSERIALIZE_SCALAR(fbrd);
+ UNSERIALIZE_SCALAR(ibrd);
+ UNSERIALIZE_SCALAR(lcrh);
+ UNSERIALIZE_SCALAR(ifls);
+
+ uint16_t imsc_serial;
+ UNSERIALIZE_SCALAR(imsc_serial);
+ imsc = imsc_serial;
+
+ uint16_t rawInt_serial;
+ UNSERIALIZE_SCALAR(rawInt_serial);
+ rawInt = rawInt_serial;
+
+ uint16_t maskInt_serial;
+ UNSERIALIZE_SCALAR(maskInt_serial);
+ maskInt = maskInt_serial;
+
+ UNSERIALIZE_SCALAR(endOnEOT);
+ UNSERIALIZE_SCALAR(intDelay);
}
Pl011 *
void
RealViewCtrl::serialize(std::ostream &os)
{
- panic("Need to implement serialization\n");
}
void
RealViewCtrl::unserialize(Checkpoint *cp, const std::string §ion)
{
- panic("Need to implement serialization\n");
}
RealViewCtrl *
restartCounter(loadValue);
}
+void
+Sp804::Timer::serialize(std::ostream &os)
+{
+ DPRINTF(Checkpoint, "Serializing Arm Sp804\n");
+ SERIALIZE_SCALAR(intNum);
+ SERIALIZE_SCALAR(clock);
+
+ uint32_t control_serial = control;
+ SERIALIZE_SCALAR(control_serial);
+
+ SERIALIZE_SCALAR(rawInt);
+ SERIALIZE_SCALAR(pendingInt);
+ SERIALIZE_SCALAR(loadValue);
+
+ bool is_in_event = zeroEvent.scheduled();
+ SERIALIZE_SCALAR(is_in_event);
+
+ Tick event_time;
+ if (is_in_event){
+ event_time = zeroEvent.when();
+ SERIALIZE_SCALAR(event_time);
+ }
+}
+
+void
+Sp804::Timer::unserialize(Checkpoint *cp, const std::string §ion)
+{
+ DPRINTF(Checkpoint, "Unserializing Arm Sp804\n");
+
+ UNSERIALIZE_SCALAR(intNum);
+ UNSERIALIZE_SCALAR(clock);
+
+ uint32_t control_serial;
+ UNSERIALIZE_SCALAR(control_serial);
+ control = control_serial;
+
+ UNSERIALIZE_SCALAR(rawInt);
+ UNSERIALIZE_SCALAR(pendingInt);
+ UNSERIALIZE_SCALAR(loadValue);
+
+ bool is_in_event;
+ UNSERIALIZE_SCALAR(is_in_event);
+
+ Tick event_time;
+ if (is_in_event){
+ UNSERIALIZE_SCALAR(event_time);
+ parent->schedule(zeroEvent, event_time);
+ }
+}
+
+
void
Sp804::serialize(std::ostream &os)
{
- panic("Need to implement serialization\n");
+ nameOut(os, csprintf("%s.timer0", name()));
+ timer0.serialize(os);
+ nameOut(os, csprintf("%s.timer1", name()));
+ timer1.serialize(os);
}
void
Sp804::unserialize(Checkpoint *cp, const std::string §ion)
{
- panic("Need to implement serialization\n");
+ timer0.unserialize(cp, csprintf("%s.timer0", section));
+ timer1.unserialize(cp, csprintf("%s.timer1", section));
}
Sp804 *
/** Handle write for a single timer */
void write(PacketPtr pkt, Addr daddr);
+
+ void serialize(std::ostream &os);
+ void unserialize(Checkpoint *cp, const std::string §ion);
+
};
/** Pointer to the GIC for causing an interrupt */
/*
+ * Copyright (c) 2010 ARM Limited
+ * All rights reserved
+ *
+ * The license below extends only to copyright in the software and shall
+ * not be construed as granting a license to any other intellectual
+ * property including but not limited to intellectual property relating
+ * to a hardware implementation of the functionality of the software
+ * licensed hereunder. You may use the software subject to the license
+ * terms below provided that you ensure that this notice is replicated
+ * unmodified and in its entirety in all distributions of the software,
+ * modified or unmodified, in source code or in binary form.
+ *
* Copyright (c) 2001-2005 The Regents of The University of Michigan
* All rights reserved.
*
if (gzclose(compressedMem))
fatal("Close failed on physical memory checkpoint file '%s'\n",
filename);
+
+ list<LockedAddr>::iterator i = lockedAddrList.begin();
+
+ vector<Addr> lal_addr;
+ vector<int> lal_cid;
+ while (i != lockedAddrList.end()) {
+ lal_addr.push_back(i->addr);
+ lal_cid.push_back(i->contextId);
+ i++;
+ }
+ arrayParamOut(os, "lal_addr", lal_addr);
+ arrayParamOut(os, "lal_cid", lal_cid);
}
void
fatal("Close failed on physical memory checkpoint file '%s'\n",
filename);
+ vector<Addr> lal_addr;
+ vector<int> lal_cid;
+ arrayParamIn(cp, section, "lal_addr", lal_addr);
+ arrayParamIn(cp, section, "lal_cid", lal_cid);
+ for(int i = 0; i < lal_addr.size(); i++)
+ lockedAddrList.push_front(LockedAddr(lal_addr[i], lal_cid[i]));
}
PhysicalMemory *
contextId(req->contextId())
{
}
+ // constructor for unserialization use
+ LockedAddr(Addr _addr, int _cid)
+ : addr(_addr), contextId(_cid)
+ {
+ }
};
std::list<LockedAddr> lockedAddrList;
Source('process.cc')
Source('syscall_emul.cc')
+TraceFlag('Checkpoint')
TraceFlag('Config')
TraceFlag('Event')
TraceFlag('Fault')
}
void
-System::startup()
+System::initState()
{
#if FULL_SYSTEM
int i;
System(Params *p);
~System();
- void startup();
+ void initState();
const Params *params() const { return (const Params *)_params; }
projects / gem5.git / commitdiff