DPRINTF(Fetch, "[tid:%u] Waking up from cache miss.\n",tid);
+ assert(!pkt->wasNacked());
+
// Only change the status if it's still waiting on the icache access
// to return.
if (fetchStatus[tid] != IcacheWaitResponse ||
bool
LSQ<Impl>::DcachePort::recvTiming(PacketPtr pkt)
{
+ if (pkt->isError())
+ DPRINTF(LSQ, "Got error packet back for address: %#X\n", pkt->getAddr());
if (pkt->isResponse()) {
lsq->thread[pkt->req->getThreadNum()].completeDataAccess(pkt);
}
//iewStage->ldstQueue.removeMSHR(inst->threadNumber,inst->seqNum);
+ assert(!pkt->wasNacked());
+
if (isSwitchedOut() || inst->isSquashed()) {
iewStage->decrWb(inst->seqNum);
} else {
dcache_latency += dcachePort.sendAtomic(&pkt);
}
dcache_access = true;
+
assert(!pkt.isError());
if (req->isLocked()) {
else
icache_latency = icachePort.sendAtomic(&ifetch_pkt);
+ assert(!ifetch_pkt.isError());
// ifetch_req is initialized to read the instruction directly
// into the CPU object's inst field.
bool
TimingSimpleCPU::IcachePort::recvTiming(PacketPtr pkt)
{
- if (pkt->isResponse()) {
+ if (pkt->isResponse() && !pkt->wasNacked()) {
// delay processing of returned data until next CPU clock edge
Tick next_tick = cpu->nextCycle(curTick);
bool
TimingSimpleCPU::DcachePort::recvTiming(PacketPtr pkt)
{
- if (pkt->isResponse()) {
+ if (pkt->isResponse() && !pkt->wasNacked()) {
// delay processing of returned data until next CPU clock edge
Tick next_tick = cpu->nextCycle(curTick);
Addr daddr = pkt->getAddr() - pioAddr;
pkt->allocate();
+ pkt->makeAtomicResponse();
switch (pkt->getSize())
{
default:
pkt->setBadAddress();
}
- pkt->makeAtomicResponse();
return pioDelay;
}
IGbE::IGbE(const Params *p)
: EtherDevice(p), etherInt(NULL), drainEvent(NULL), useFlowControl(p->use_flow_control),
rxFifo(p->rx_fifo_size), txFifo(p->tx_fifo_size), rxTick(false),
- txTick(false), txFifoTick(false), rdtrEvent(this), radvEvent(this),
+ txTick(false), txFifoTick(false), rxDmaPacket(false), rdtrEvent(this), radvEvent(this),
tadvEvent(this), tidvEvent(this), tickEvent(this), interEvent(this),
rxDescCache(this, name()+".RxDesc", p->rx_desc_cache_size),
txDescCache(this, name()+".TxDesc", p->tx_desc_cache_size), clock(p->clock)
IGbE::getEthPort(const std::string &if_name, int idx)
{
- if (if_name == "interface" && !etherInt) {
+ if (if_name == "interface") {
if (etherInt->getPeer())
panic("Port already connected to\n");
return etherInt;
break;
case REG_RDT:
regs.rdt = val;
- rxTick = true;
- restartClock();
+ DPRINTF(EthernetSM, "RXS: RDT Updated.\n");
+ if (getState() == SimObject::Running) {
+ DPRINTF(EthernetSM, "RXS: RDT Fetching Descriptors!\n");
+ rxDescCache.fetchDescriptors();
+ } else {
+ DPRINTF(EthernetSM, "RXS: RDT NOT Fetching Desc b/c draining!\n");
+ }
break;
case REG_RDTR:
regs.rdtr = val;
break;
case REG_TDT:
regs.tdt = val;
- txTick = true;
- restartClock();
+ DPRINTF(EthernetSM, "TXS: TX Tail pointer updated\n");
+ if (getState() == SimObject::Running) {
+ DPRINTF(EthernetSM, "TXS: TDT Fetching Descriptors!\n");
+ txDescCache.fetchDescriptors();
+ } else {
+ DPRINTF(EthernetSM, "TXS: TDT NOT Fetching Desc b/c draining!\n");
+ }
break;
case REG_TIDV:
regs.tidv = val;
assert(t);
// Interrupt is already pending
- if (t & regs.icr())
+ if (t & regs.icr() && !now)
return;
- if (regs.icr() & regs.imr)
- {
- regs.icr = regs.icr() | t;
- if (!interEvent.scheduled())
- interEvent.schedule(curTick + Clock::Int::ns * 256 *
- regs.itr.interval());
- } else {
- regs.icr = regs.icr() | t;
- if (regs.itr.interval() == 0 || now) {
- if (interEvent.scheduled())
- interEvent.deschedule();
- cpuPostInt();
- } else {
- DPRINTF(EthernetIntr, "EINT: Scheduling timer interrupt for %d ticks\n",
- Clock::Int::ns * 256 * regs.itr.interval());
- if (!interEvent.scheduled())
- interEvent.schedule(curTick + Clock::Int::ns * 256 * regs.itr.interval());
+ regs.icr = regs.icr() | t;
+ if (regs.itr.interval() == 0 || now) {
+ if (interEvent.scheduled()) {
+ interEvent.deschedule();
}
+ cpuPostInt();
+ } else {
+ DPRINTF(EthernetIntr, "EINT: Scheduling timer interrupt for %d ticks\n",
+ Clock::Int::ns * 256 * regs.itr.interval());
+ if (!interEvent.scheduled()) {
+ interEvent.schedule(curTick + Clock::Int::ns * 256 * regs.itr.interval());
+ }
}
}
+void
+IGbE::delayIntEvent()
+{
+ cpuPostInt();
+}
+
+
void
IGbE::cpuPostInt()
{
+
+ if (!(regs.icr() & regs.imr)) {
+ DPRINTF(Ethernet, "Interrupt Masked. Not Posting\n");
+ return;
+ }
+
+ DPRINTF(Ethernet, "Posting Interrupt\n");
+
+
+ if (interEvent.scheduled()) {
+ interEvent.deschedule();
+ }
+
if (rdtrEvent.scheduled()) {
regs.icr.rxt0(1);
rdtrEvent.deschedule();
regs.icr.int_assert(1);
DPRINTF(EthernetIntr, "EINT: Posting interrupt to CPU now. Vector %#x\n",
regs.icr());
+
intrPost();
+
}
void
void
IGbE::chkInterrupt()
{
+ DPRINTF(Ethernet, "Checking interrupts icr: %#x imr: %#x\n", regs.icr(),
+ regs.imr);
// Check if we need to clear the cpu interrupt
if (!(regs.icr() & regs.imr)) {
+ DPRINTF(Ethernet, "Mask cleaned all interrupts\n");
if (interEvent.scheduled())
interEvent.deschedule();
if (regs.icr.int_assert())
cpuClearInt();
}
+ DPRINTF(Ethernet, "ITR = %#X itr.interval = %#X\n", regs.itr(), regs.itr.interval());
if (regs.icr() & regs.imr) {
if (regs.itr.interval() == 0) {
cpuPostInt();
} else {
- if (!interEvent.scheduled())
+ DPRINTF(Ethernet, "Possibly scheduling interrupt because of imr write\n");
+ if (!interEvent.scheduled()) {
+ DPRINTF(Ethernet, "Scheduling for %d\n", curTick + Clock::Int::ns
+ * 256 * regs.itr.interval());
interEvent.schedule(curTick + Clock::Int::ns * 256 * regs.itr.interval());
+ }
}
}
RxDesc *desc;
desc = unusedCache.front();
+
uint16_t crcfixup = igbe->regs.rctl.secrc() ? 0 : 4 ;
desc->len = htole((uint16_t)(pktPtr->length + crcfixup));
DPRINTF(EthernetDesc, "pktPtr->length: %d stripcrc offset: %d value written: %d %d\n",
if (igbe->regs.radv.idv() && igbe->regs.rdtr.delay()) {
DPRINTF(EthernetSM, "RXS: Scheduling ADV for %d\n",
igbe->regs.radv.idv() * igbe->intClock());
- if (!igbe->radvEvent.scheduled())
+ if (!igbe->radvEvent.scheduled()) {
igbe->radvEvent.schedule(curTick + igbe->regs.radv.idv() *
igbe->intClock());
+ }
}
// if neither radv or rdtr, maybe itr is set...
DPRINTF(EthernetDesc, "Processing of this descriptor complete\n");
unusedCache.pop_front();
usedCache.push_back(desc);
+
+
pktPtr = NULL;
enableSm();
pktDone = true;
igbe->checkDrain();
+
}
void
// I think we can just ignore these for now?
desc = unusedCache.front();
+ DPRINTF(EthernetDesc, "Descriptor upper: %#x lower: %#X\n", desc->d1,
+ desc->d2);
// is this going to be a tcp or udp packet?
isTcp = TxdOp::tcp(desc) ? true : false;
// make sure it's ipv4
- assert(TxdOp::ip(desc));
+ //assert(TxdOp::ip(desc));
TxdOp::setDd(desc);
unusedCache.pop_front();
DPRINTF(EthernetDesc, "DMA of packet complete\n");
-
desc = unusedCache.front();
assert((TxdOp::isLegacy(desc) || TxdOp::isData(desc)) && TxdOp::getLen(desc));
ip->sum(cksum(ip));
DPRINTF(EthernetDesc, "Calculated IP checksum\n");
}
- if (TxdOp::txsm(desc)) {
- if (isTcp) {
- TcpPtr tcp(ip);
- assert(tcp);
- tcp->sum(0);
- tcp->sum(cksum(tcp));
- DPRINTF(EthernetDesc, "Calculated TCP checksum\n");
- } else {
- UdpPtr udp(ip);
- assert(udp);
- udp->sum(0);
- udp->sum(cksum(udp));
- DPRINTF(EthernetDesc, "Calculated UDP checksum\n");
- }
+ if (TxdOp::txsm(desc)) {
+ TcpPtr tcp(ip);
+ UdpPtr udp(ip);
+ if (tcp) {
+ tcp->sum(0);
+ tcp->sum(cksum(tcp));
+ DPRINTF(EthernetDesc, "Calculated TCP checksum\n");
+ } else if (udp) {
+ assert(udp);
+ udp->sum(0);
+ udp->sum(cksum(udp));
+ DPRINTF(EthernetDesc, "Calculated UDP checksum\n");
+ } else {
+ panic("Told to checksum, but don't know how\n");
+ }
}
}
if (igbe->regs.tadv.idv() && igbe->regs.tidv.idv()) {
DPRINTF(EthernetDesc, "setting tadv\n");
- if (!igbe->tadvEvent.scheduled())
+ if (!igbe->tadvEvent.scheduled()) {
igbe->tadvEvent.schedule(curTick + igbe->regs.tadv.idv() *
igbe->intClock());
+ }
}
}
if (!drainEvent)
return;
- if (rxDescCache.hasOutstandingEvents() ||
- txDescCache.hasOutstandingEvents()) {
+ txFifoTick = false;
+ txTick = false;
+ rxTick = false;
+ if (!rxDescCache.hasOutstandingEvents() &&
+ !txDescCache.hasOutstandingEvents()) {
drainEvent->process();
drainEvent = NULL;
}
// iteration we'll get the rest of the data
if (txPacket && txDescCache.packetAvailable() && txPacket->length) {
bool success;
+
DPRINTF(EthernetSM, "TXS: packet placed in TX FIFO\n");
success = txFifo.push(txPacket);
txFifoTick = true;
if (!txDescCache.packetWaiting()) {
if (txDescCache.descLeft() == 0) {
+ postInterrupt(IT_TXQE);
+ txDescCache.writeback(0);
DPRINTF(EthernetSM, "TXS: No descriptors left in ring, forcing "
"writeback stopping ticking and posting TXQE\n");
- txDescCache.writeback(0);
+ txDescCache.fetchDescriptors();
txTick = false;
- postInterrupt(IT_TXQE, true);
return;
}
txFifo.reserve(size);
txDescCache.getPacketData(txPacket);
} else if (size <= 0) {
+ DPRINTF(EthernetSM, "TXS: getPacketSize returned: %d\n", size);
DPRINTF(EthernetSM, "TXS: No packets to get, writing back used descriptors\n");
txDescCache.writeback(0);
} else {
+ txDescCache.writeback((cacheBlockSize()-1)>>4);
DPRINTF(EthernetSM, "TXS: FIFO full, stopping ticking until space "
"available in FIFO\n");
- txDescCache.writeback((cacheBlockSize()-1)>>4);
txTick = false;
}
IGbE::ethRxPkt(EthPacketPtr pkt)
{
DPRINTF(Ethernet, "RxFIFO: Receiving pcakte from wire\n");
+
if (!regs.rctl.en()) {
DPRINTF(Ethernet, "RxFIFO: RX not enabled, dropping\n");
return true;
}
if (descLeft == 0) {
- DPRINTF(EthernetSM, "RXS: No descriptors left in ring, forcing"
- " writeback and stopping ticking\n");
rxDescCache.writeback(0);
rxTick = false;
}
return;
}
+ if (etherInt->askBusy()) {
+ // We'll get woken up when the packet ethTxDone() gets called
+ txFifoTick = false;
+ } else {
+ if (DTRACE(EthernetSM)) {
+ IpPtr ip(txFifo.front());
+ if (ip)
+ DPRINTF(EthernetSM, "Transmitting Ip packet with Id=%d\n",
+ ip->id());
+ else
+ DPRINTF(EthernetSM, "Transmitting Non-Ip packet\n");
+ }
- if (etherInt->sendPacket(txFifo.front())) {
+ bool r = etherInt->sendPacket(txFifo.front());
+ assert(r);
+ r += 1;
DPRINTF(EthernetSM, "TxFIFO: Successful transmit, bytes available in fifo: %d\n",
txFifo.avail());
txFifo.pop();
- } else {
- // We'll get woken up when the packet ethTxDone() gets called
- txFifoTick = false;
}
-
}
void
// fifo to send another packet
// tx sm to put more data into the fifo
txFifoTick = true;
- txTick = true;
+ if (txDescCache.descLeft() != 0)
+ txTick = true;
restartClock();
DPRINTF(EthernetSM, "TxFIFO: Transmission complete\n");
SERIALIZE_SCALAR(radv_time);
if (tidvEvent.scheduled())
- rdtr_time = tidvEvent.when();
+ tidv_time = tidvEvent.when();
SERIALIZE_SCALAR(tidv_time);
if (tadvEvent.scheduled())
- rdtr_time = tadvEvent.when();
+ tadv_time = tadvEvent.when();
SERIALIZE_SCALAR(tadv_time);
if (interEvent.scheduled())
- rdtr_time = interEvent.when();
+ inter_time = interEvent.when();
SERIALIZE_SCALAR(inter_time);
nameOut(os, csprintf("%s.TxDescCache", name()));
/** Send an interrupt to the cpu
*/
+ void delayIntEvent();
void cpuPostInt();
// Event to moderate interrupts
- EventWrapper<IGbE, &IGbE::cpuPostInt> interEvent;
+ EventWrapper<IGbE, &IGbE::delayIntEvent> interEvent;
/** Clear the interupt line to the cpu
*/
virtual void updateHead(long h) = 0;
virtual void enableSm() = 0;
virtual void intAfterWb() const {}
+ virtual void fetchAfterWb() = 0;
std::deque<T*> usedCache;
std::deque<T*> unusedCache;
for (int x = 0; x < wbOut; x++)
memcpy(&wbBuf[x], usedCache[x], sizeof(T));
- for (int x = 0; x < wbOut; x++) {
- assert(usedCache.size());
- delete usedCache[0];
- usedCache.pop_front();
- };
-
assert(wbOut);
igbe->dmaWrite(igbe->platform->pciToDma(descBase() + curHead * sizeof(T)),
else
max_to_fetch = descLen() - cachePnt;
-
max_to_fetch = std::min(max_to_fetch, (size - usedCache.size() -
unusedCache.size()));
*/
void wbComplete()
{
+
long curHead = descHead();
#ifndef NDEBUG
long oldHead = curHead;
#endif
+ for (int x = 0; x < wbOut; x++) {
+ assert(usedCache.size());
+ delete usedCache[0];
+ usedCache.pop_front();
+ };
curHead += wbOut;
wbOut = 0;
oldHead, curHead);
// If we still have more to wb, call wb now
+ bool oldMoreToWb = moreToWb;
if (moreToWb) {
DPRINTF(EthernetDesc, "Writeback has more todo\n");
writeback(wbAlignment);
}
+
intAfterWb();
- igbe->checkDrain();
+ if (!oldMoreToWb) {
+ igbe->checkDrain();
+ }
+ fetchAfterWb();
}
virtual long descTail() const { return igbe->regs.rdt(); }
virtual void updateHead(long h) { igbe->regs.rdh(h); }
virtual void enableSm();
+ virtual void fetchAfterWb() {
+ if (!igbe->rxTick && igbe->getState() == SimObject::Running)
+ fetchDescriptors();
+ }
bool pktDone;
virtual long descLen() const { return igbe->regs.tdlen() >> 4; }
virtual void updateHead(long h) { igbe->regs.tdh(h); }
virtual void enableSm();
- virtual void intAfterWb() const { igbe->postInterrupt(iGbReg::IT_TXDW);}
+ virtual void intAfterWb() const {
+ igbe->postInterrupt(iGbReg::IT_TXDW);
+ }
+ virtual void fetchAfterWb() {
+ if (!igbe->txTick && igbe->getState() == SimObject::Running)
+ fetchDescriptors();
+ }
bool pktDone;
bool isTcp;
IsaFake::read(PacketPtr pkt)
{
+ pkt->makeAtomicResponse();
if (params()->warn_access != "")
warn("Device %s accessed by read to address %#x size=%d\n",
name(), pkt->getAddr(), pkt->getSize());
default:
panic("invalid access size!\n");
}
- pkt->makeAtomicResponse();
}
return pioDelay;
}
Tick
IsaFake::write(PacketPtr pkt)
{
+ pkt->makeAtomicResponse();
if (params()->warn_access != "") {
uint64_t data;
switch (pkt->getSize()) {
panic("invalid access size!\n");
}
}
- pkt->makeAtomicResponse();
}
return pioDelay;
}
DPRINTF(BusBridge, "Local queue size: %d outreq: %d outresp: %d\n",
sendQueue.size(), queuedRequests, outstandingResponses);
- DPRINTF(BusBridge, "Remove queue size: %d outreq: %d outresp: %d\n",
+ DPRINTF(BusBridge, "Remote queue size: %d outreq: %d outresp: %d\n",
otherPort->sendQueue.size(), otherPort->queuedRequests,
otherPort->outstandingResponses);
- if (pkt->isRequest() && otherPort->reqQueueFull() && !pkt->wasNacked()) {
+ if (pkt->isRequest() && otherPort->reqQueueFull()) {
DPRINTF(BusBridge, "Remote queue full, nacking\n");
nackRequest(pkt);
return true;
}
- if (pkt->needsResponse() && !pkt->wasNacked())
+ if (pkt->needsResponse())
if (respQueueFull()) {
DPRINTF(BusBridge, "Local queue full, no space for response, nacking\n");
DPRINTF(BusBridge, "queue size: %d outreq: %d outstanding resp: %d\n",
Bridge::BridgePort::nackRequest(PacketPtr pkt)
{
// Nack the packet
+ pkt->makeTimingResponse();
pkt->setNacked();
- pkt->setDest(pkt->getSrc());
//put it on the list to send
Tick readyTime = curTick + nackDelay;
void
Bridge::BridgePort::queueForSendTiming(PacketPtr pkt)
{
- if (pkt->isResponse() || pkt->wasNacked()) {
+ if (pkt->isResponse()) {
// This is a response for a request we forwarded earlier. The
// corresponding PacketBuffer should be stored in the packet's
// senderState field.
+
PacketBuffer *buf = dynamic_cast<PacketBuffer*>(pkt->senderState);
assert(buf != NULL);
// set up new packet dest & senderState based on values saved
// from original request
buf->fixResponse(pkt);
- // Check if this packet was expecting a response and it's a nacked
- // packet, in which case we will never being seeing it
- if (buf->expectResponse && pkt->wasNacked())
- --outstandingResponses;
-
DPRINTF(BusBridge, "response, new dest %d\n", pkt->getDest());
delete buf;
}
- if (pkt->isRequest() && !pkt->wasNacked()) {
+ if (pkt->isRequest()) {
++queuedRequests;
}
buf->origSrc, pkt->getDest(), pkt->getAddr());
bool wasReq = pkt->isRequest();
- bool wasNacked = pkt->wasNacked();
+ bool was_nacked_here = buf->nackedHere;
+
+ // If the send was successful, make sure sender state was set to NULL
+ // otherwise we could get a NACK back of a packet that didn't expect a
+ // response and we would try to use freed memory.
+
+ Packet::SenderState *old_sender_state = pkt->senderState;
+ if (pkt->isRequest() && !buf->expectResponse)
+ pkt->senderState = NULL;
if (sendTiming(pkt)) {
// send successful
delete buf;
}
- if (!wasNacked) {
- if (wasReq)
- --queuedRequests;
- else
- --outstandingResponses;
- }
+ if (wasReq)
+ --queuedRequests;
+ else if (!was_nacked_here)
+ --outstandingResponses;
// If there are more packets to send, schedule event to try again.
if (!sendQueue.empty()) {
}
} else {
DPRINTF(BusBridge, " unsuccessful\n");
+ pkt->senderState = old_sender_state;
inRetry = true;
}
+
DPRINTF(BusBridge, "trySend: queue size: %d outreq: %d outstanding resp: %d\n",
sendQueue.size(), queuedRequests, outstandingResponses);
}
public:
Tick ready;
PacketPtr pkt;
+ bool nackedHere;
Packet::SenderState *origSenderState;
short origSrc;
bool expectResponse;
PacketBuffer(PacketPtr _pkt, Tick t, bool nack = false)
- : ready(t), pkt(_pkt),
- origSenderState(_pkt->senderState), origSrc(_pkt->getSrc()),
+ : ready(t), pkt(_pkt), nackedHere(nack),
+ origSenderState(_pkt->senderState),
+ origSrc(nack ? _pkt->getDest() : _pkt->getSrc() ),
expectResponse(_pkt->needsResponse() && !nack)
{
- if (!pkt->isResponse() && !nack && !pkt->wasNacked())
+ if (!pkt->isResponse() && !nack)
pkt->senderState = this;
}
if (dest_port_id == src) {
// Must be forwarded snoop up from below...
assert(dest == Packet::Broadcast);
+ assert(src != defaultId); // catch infinite loops
} else {
// send to actual target
if (!dest_port->sendTiming(pkt)) {
DPRINTF(Cache, "Receive response: %s for addr %x in state %i\n",
busPkt->cmdString(), busPkt->getAddr(), old_state);
- if (isCacheFill) {
+ bool is_error = busPkt->isError();
+ assert(!busPkt->wasNacked());
+
+ if (is_error && pkt->needsResponse()) {
+ pkt->makeAtomicResponse();
+ pkt->copyError(busPkt);
+ } else if (isCacheFill && !is_error) {
PacketList writebacks;
blk = handleFill(busPkt, blk, writebacks);
satisfyCpuSideRequest(pkt, blk);
{
Tick time = curTick + hitLatency;
MSHR *mshr = dynamic_cast<MSHR*>(pkt->senderState);
+ bool is_error = pkt->isError();
+
assert(mshr);
if (pkt->wasNacked()) {
"not implemented\n");
return;
}
- assert(!pkt->isError());
+ if (is_error) {
+ DPRINTF(Cache, "Cache received packet with error for address %x, "
+ "cmd: %s\n", pkt->getAddr(), pkt->cmdString());
+ }
+
DPRINTF(Cache, "Handling response to %x\n", pkt->getAddr());
MSHRQueue *mq = mshr->queue;
miss_latency;
}
- if (mshr->isCacheFill) {
+ if (mshr->isCacheFill && !is_error) {
DPRINTF(Cache, "Block for addr %x being updated in Cache\n",
pkt->getAddr());
} else {
// not a cache fill, just forwarding response
completion_time = tags->getHitLatency() + pkt->finishTime;
- if (pkt->isRead()) {
+ if (pkt->isRead() && !is_error) {
target->pkt->setData(pkt->getPtr<uint8_t>());
}
}
target->pkt->makeTimingResponse();
+ // if this packet is an error copy that to the new packet
+ if (is_error)
+ target->pkt->copyError(pkt);
cpuSidePort->respond(target->pkt, completion_time);
} else {
+ // I don't believe that a snoop can be in an error state
+ assert(!is_error);
// response to snoop request
DPRINTF(Cache, "processing deferred snoop...\n");
handleSnoop(target->pkt, blk, true, true);
{ SET5(IsRead, IsWrite, NeedsExclusive, IsResponse, HasData),
InvalidCmd, "SwapResp" },
/* NetworkNackError -- nacked at network layer (not by protocol) */
- { SET2(IsRequest, IsError), InvalidCmd, "NetworkNackError" },
+ { SET2(IsResponse, IsError), InvalidCmd, "NetworkNackError" },
/* InvalidDestError -- packet dest field invalid */
- { SET2(IsRequest, IsError), InvalidCmd, "InvalidDestError" },
+ { SET2(IsResponse, IsError), InvalidCmd, "InvalidDestError" },
/* BadAddressError -- memory address invalid */
- { SET2(IsRequest, IsError), InvalidCmd, "BadAddressError" }
+ { SET2(IsResponse, IsError), InvalidCmd, "BadAddressError" }
};
// Network error conditions... encapsulate them as methods since
// their encoding keeps changing (from result field to command
// field, etc.)
- void setNacked() { origCmd = cmd; cmd = MemCmd::NetworkNackError; }
- void setBadAddress() { origCmd = cmd; cmd = MemCmd::BadAddressError; }
+ void setNacked() { assert(isResponse()); cmd = MemCmd::NetworkNackError; }
+ void setBadAddress() { assert(isResponse()); cmd = MemCmd::BadAddressError; }
bool wasNacked() { return cmd == MemCmd::NetworkNackError; }
bool hadBadAddress() { return cmd == MemCmd::BadAddressError; }
+ void copyError(Packet *pkt) { assert(pkt->isError()); cmd = pkt->cmd; }
bool nic_pkt() { panic("Unimplemented"); M5_DUMMY_RETURN }
{
assert(needsResponse());
assert(isRequest());
+ origCmd = cmd;
cmd = cmd.responseCommand();
dest = src;
destValid = srcValid;
projects / gem5.git / commitdiff