diff --git a/src/dev/net/etherswitch.cc b/src/dev/net/etherswitch.cc
--- a/src/dev/net/etherswitch.cc
+++ b/src/dev/net/etherswitch.cc
@@ -75,23 +75,23 @@
 bool
 EtherSwitch::Interface::PortFifo::push(EthPacketPtr ptr, unsigned senderId)
 {
-    assert(ptr->length);
+    assert(ptr->dataLength);
 
-    _size += ptr->length;
+    _size += ptr->dataLength;
     fifo.emplace_hint(fifo.end(), ptr, curTick(), senderId);
 
     // Drop the extra pushed packets from end of the fifo
     while (avail() < 0) {
         DPRINTF(Ethernet, "Fifo is full. Drop packet: len=%d\n",
-                std::prev(fifo.end())->packet->length);
+                std::prev(fifo.end())->packet->dataLength);
 
-        _size -= std::prev(fifo.end())->packet->length;
+        _size -= std::prev(fifo.end())->packet->dataLength;
         fifo.erase(std::prev(fifo.end()));
     }
 
     if (empty()) {
         warn("EtherSwitch: Packet length (%d) exceeds the maximum storage "
-             "capacity of port fifo (%d)", ptr->length, _maxsize);
+             "capacity of port fifo (%d)", ptr->dataLength, _maxsize);
     }
 
     // Return true if the newly pushed packet gets inserted
@@ -110,9 +110,9 @@
     if (empty())
         return;
 
-    assert(_size >= fifo.begin()->packet->length);
+    assert(_size >= fifo.begin()->packet->dataLength);
     // Erase the packet at the head of the queue
-    _size -= fifo.begin()->packet->length;
+    _size -= fifo.begin()->packet->dataLength;
     fifo.erase(fifo.begin());
 }
 
@@ -187,7 +187,8 @@
         if (!txEvent.scheduled())
             parent->schedule(txEvent, curTick() + retryTime);
     } else {
-        DPRINTF(Ethernet, "packet sent: len=%d\n", outputFifo.front()->length);
+        DPRINTF(Ethernet, "packet sent: len=%d\n",
+                outputFifo.front()->dataLength);
         outputFifo.pop();
         // schedule an event to send the pkt at
         // the head of queue, if there is any
@@ -200,7 +201,7 @@
 Tick
 EtherSwitch::Interface::switchingDelay()
 {
-    Tick delay = (Tick)ceil(((double)outputFifo.front()->length
+    Tick delay = (Tick)ceil(((double)outputFifo.front()->simLength
                                      * ticksPerByte) + 1.0);
     if (delayVar != 0)
                 delay += random_mt.random<Tick>(0, delayVar);
diff --git a/src/dev/net/ethertap.cc b/src/dev/net/ethertap.cc
--- a/src/dev/net/ethertap.cc
+++ b/src/dev/net/ethertap.cc
@@ -188,14 +188,14 @@
     if (dump)
         dump->dump(packet);
 
-    DPRINTF(Ethernet, "EtherTap output len=%d\n", packet->length);
-    DDUMP(EthernetData, packet->data, packet->length);
-    uint32_t len = htonl(packet->length);
+    DPRINTF(Ethernet, "EtherTap output len=%d\n", packet->dataLength);
+    DDUMP(EthernetData, packet->data, packet->dataLength);
+    uint32_t len = htonl(packet->dataLength);
     ssize_t ret = write(socket, &len, sizeof(len));
     if (ret != sizeof(len))
         return false;
-    ret = write(socket, packet->data, packet->length);
-    if (ret != packet->length)
+    ret = write(socket, packet->data, packet->dataLength);
+    if (ret != packet->dataLength)
         return false;
 
     interface->recvDone();
@@ -238,7 +238,8 @@
     while (data_len != 0 && buffer_offset >= data_len + sizeof(uint32_t)) {
         EthPacketPtr packet;
         packet = make_shared<EthPacketData>(data_len);
-        packet->length = data_len;
+        packet->dataLength = data_len;
+        packet->simLength = data_len;
         memcpy(packet->data, data, data_len);
 
         assert(buffer_offset >= data_len + sizeof(uint32_t));
@@ -249,8 +250,8 @@
         } else
             data_len = 0;
 
-        DPRINTF(Ethernet, "EtherTap input len=%d\n", packet->length);
-        DDUMP(EthernetData, packet->data, packet->length);
+        DPRINTF(Ethernet, "EtherTap input len=%d\n", packet->dataLength);
+        DDUMP(EthernetData, packet->data, packet->dataLength);
         if (!interface->sendPacket(packet)) {
             DPRINTF(Ethernet, "bus busy...buffer for retransmission\n");
             packetBuffer.push(packet);
diff --git a/src/dev/net/i8254xGBe.cc b/src/dev/net/i8254xGBe.cc
--- a/src/dev/net/i8254xGBe.cc
+++ b/src/dev/net/i8254xGBe.cc
@@ -1235,28 +1235,28 @@
     switch (igbe->regs.srrctl.desctype()) {
       case RXDT_LEGACY:
         assert(pkt_offset == 0);
-        bytesCopied = packet->length;
+        bytesCopied = packet->dataLength;
         DPRINTF(EthernetDesc, "Packet Length: %d Desc Size: %d\n",
-                packet->length, igbe->regs.rctl.descSize());
-        assert(packet->length < igbe->regs.rctl.descSize());
+                packet->dataLength, igbe->regs.rctl.descSize());
+        assert(packet->dataLength < igbe->regs.rctl.descSize());
         igbe->dmaWrite(pciToDma(desc->legacy.buf),
-                       packet->length, &pktEvent, packet->data,
+                       packet->dataLength, &pktEvent, packet->data,
                        igbe->rxWriteDelay);
         break;
       case RXDT_ADV_ONEBUF:
         assert(pkt_offset == 0);
-        bytesCopied = packet->length;
+        bytesCopied = packet->dataLength;
         buf_len = igbe->regs.rctl.lpe() ? igbe->regs.srrctl.bufLen() :
             igbe->regs.rctl.descSize();
         DPRINTF(EthernetDesc, "Packet Length: %d srrctl: %#x Desc Size: %d\n",
-                packet->length, igbe->regs.srrctl(), buf_len);
-        assert(packet->length < buf_len);
+                packet->dataLength, igbe->regs.srrctl(), buf_len);
+        assert(packet->dataLength < buf_len);
         igbe->dmaWrite(pciToDma(desc->adv_read.pkt),
-                       packet->length, &pktEvent, packet->data,
+                       packet->dataLength, &pktEvent, packet->data,
                        igbe->rxWriteDelay);
         desc->adv_wb.header_len = htole(0);
         desc->adv_wb.sph = htole(0);
-        desc->adv_wb.pkt_len = htole((uint16_t)(pktPtr->length));
+        desc->adv_wb.pkt_len = htole((uint16_t)(pktPtr->dataLength));
         break;
       case RXDT_ADV_SPLIT_A:
         int split_point;
@@ -1267,20 +1267,20 @@
         DPRINTF(EthernetDesc,
                 "lpe: %d Packet Length: %d offset: %d srrctl: %#x "
                 "hdr addr: %#x Hdr Size: %d desc addr: %#x Desc Size: %d\n",
-                igbe->regs.rctl.lpe(), packet->length, pkt_offset,
+                igbe->regs.rctl.lpe(), packet->dataLength, pkt_offset,
                 igbe->regs.srrctl(), desc->adv_read.hdr, hdr_len,
                 desc->adv_read.pkt, buf_len);
 
         split_point = hsplit(pktPtr);
 
-        if (packet->length <= hdr_len) {
-            bytesCopied = packet->length;
+        if (packet->dataLength <= hdr_len) {
+            bytesCopied = packet->dataLength;
             assert(pkt_offset == 0);
             DPRINTF(EthernetDesc, "Hdr split: Entire packet in header\n");
             igbe->dmaWrite(pciToDma(desc->adv_read.hdr),
-                           packet->length, &pktEvent, packet->data,
+                           packet->dataLength, &pktEvent, packet->data,
                            igbe->rxWriteDelay);
-            desc->adv_wb.header_len = htole((uint16_t)packet->length);
+            desc->adv_wb.header_len = htole((uint16_t)packet->dataLength);
             desc->adv_wb.sph = htole(0);
             desc->adv_wb.pkt_len = htole(0);
         } else if (split_point) {
@@ -1288,7 +1288,7 @@
                 // we are only copying some data, header/data has already been
                 // copied
                 int max_to_copy =
-                    std::min(packet->length - pkt_offset, buf_len);
+                    std::min(packet->dataLength - pkt_offset, buf_len);
                 bytesCopied += max_to_copy;
                 DPRINTF(EthernetDesc,
                         "Hdr split: Continuing data buffer copy\n");
@@ -1300,7 +1300,7 @@
                 desc->adv_wb.sph = htole(0);
             } else {
                 int max_to_copy =
-                    std::min(packet->length - split_point, buf_len);
+                    std::min(packet->dataLength - split_point, buf_len);
                 bytesCopied += max_to_copy + split_point;
 
                 DPRINTF(EthernetDesc, "Hdr split: splitting at %d\n",
@@ -1340,9 +1340,9 @@
     uint16_t crcfixup = igbe->regs.rctl.secrc() ? 0 : 4 ;
     DPRINTF(EthernetDesc, "pktPtr->length: %d bytesCopied: %d "
             "stripcrc offset: %d value written: %d %d\n",
-            pktPtr->length, bytesCopied, crcfixup,
-            htole((uint16_t)(pktPtr->length + crcfixup)),
-            (uint16_t)(pktPtr->length + crcfixup));
+            pktPtr->dataLength, bytesCopied, crcfixup,
+            htole((uint16_t)(pktPtr->dataLength + crcfixup)),
+            (uint16_t)(pktPtr->dataLength + crcfixup));
 
     // no support for anything but starting at 0
     assert(igbe->regs.rxcsum.pcss() == 0);
@@ -1356,8 +1356,8 @@
     uint16_t ptype = 0;
     uint16_t ip_id = 0;
 
-    assert(bytesCopied <= pktPtr->length);
-    if (bytesCopied == pktPtr->length)
+    assert(bytesCopied <= pktPtr->dataLength);
+    if (bytesCopied == pktPtr->dataLength)
         status |= RXDS_EOP;
 
     IpPtr ip(pktPtr);
@@ -1411,7 +1411,7 @@
 
     switch (igbe->regs.srrctl.desctype()) {
       case RXDT_LEGACY:
-        desc->legacy.len = htole((uint16_t)(pktPtr->length + crcfixup));
+        desc->legacy.len = htole((uint16_t)(pktPtr->dataLength + crcfixup));
         desc->legacy.status = htole(status);
         desc->legacy.errors = htole(err);
         // No vlan support at this point... just set it to 0
@@ -1441,7 +1441,7 @@
     DPRINTF(EthernetDesc, "Descriptor complete w0: %#x w1: %#x\n",
             desc->adv_read.pkt, desc->adv_read.hdr);
 
-    if (bytesCopied == pktPtr->length) {
+    if (bytesCopied == pktPtr->dataLength) {
         DPRINTF(EthernetDesc,
                 "Packet completely written to descriptor buffers\n");
         // Deal with the rx timer interrupts
@@ -1468,7 +1468,7 @@
 
         // If the packet is small enough, interrupt appropriately
         // I wonder if this is delayed or not?!
-        if (pktPtr->length <= igbe->regs.rsrpd.idv()) {
+        if (pktPtr->dataLength <= igbe->regs.rsrpd.idv()) {
             DPRINTF(EthernetSM,
                     "RXS: Posting IT_SRPD beacuse small packet received\n");
             igbe->postInterrupt(IT_SRPD);
@@ -1677,7 +1677,7 @@
                 tsoTotalLen, tsoUsedLen, tsoLoadedHeader);
 
         if (tsoPktHasHeader)
-            tsoCopyBytes =  std::min((tsoMss + tsoHeaderLen) - p->length,
+            tsoCopyBytes =  std::min((tsoMss + tsoHeaderLen) - p->dataLength,
                                      TxdOp::getLen(desc) - tsoDescBytesUsed);
         else
             tsoCopyBytes =  std::min(tsoMss,
@@ -1715,7 +1715,8 @@
 
     pktWaiting = true;
 
-    DPRINTF(EthernetDesc, "Starting DMA of packet at offset %d\n", p->length);
+    DPRINTF(EthernetDesc, "Starting DMA of packet at offset %d\n",
+            p->dataLength);
 
     if (useTso) {
         assert(tsoLoadedHeader);
@@ -1724,7 +1725,7 @@
                     "Loading TSO header (%d bytes) into start of packet\n",
                     tsoHeaderLen);
             memcpy(p->data, &tsoHeader,tsoHeaderLen);
-            p->length +=tsoHeaderLen;
+            p->dataLength +=tsoHeaderLen;
             tsoPktHasHeader = true;
         }
     }
@@ -1732,16 +1733,16 @@
     if (useTso) {
         DPRINTF(EthernetDesc,
                 "Starting DMA of packet at offset %d length: %d\n",
-                p->length, tsoCopyBytes);
+                p->dataLength, tsoCopyBytes);
         igbe->dmaRead(pciToDma(TxdOp::getBuf(desc))
                       + tsoDescBytesUsed,
-                      tsoCopyBytes, &pktEvent, p->data + p->length,
+                      tsoCopyBytes, &pktEvent, p->data + p->dataLength,
                       igbe->txReadDelay);
         tsoDescBytesUsed += tsoCopyBytes;
         assert(tsoDescBytesUsed <= TxdOp::getLen(desc));
     } else {
         igbe->dmaRead(pciToDma(TxdOp::getBuf(desc)),
-                      TxdOp::getLen(desc), &pktEvent, p->data + p->length,
+                      TxdOp::getLen(desc), &pktEvent, p->data + p->dataLength,
                       igbe->txReadDelay);
     }
 }
@@ -1771,17 +1772,19 @@
         DPRINTF(EthernetDesc, "TSO: use: %d hdrlen: %d mss: %d total: %d "
             "used: %d loaded hdr: %d\n", useTso, tsoHeaderLen, tsoMss,
             tsoTotalLen, tsoUsedLen, tsoLoadedHeader);
-        pktPtr->length += tsoCopyBytes;
+        pktPtr->simLength += tsoCopyBytes;
+        pktPtr->dataLength += tsoCopyBytes;
         tsoUsedLen += tsoCopyBytes;
         DPRINTF(EthernetDesc, "TSO: descBytesUsed: %d copyBytes: %d\n",
             tsoDescBytesUsed, tsoCopyBytes);
-    } else
-        pktPtr->length += TxdOp::getLen(desc);
-
+    } else {
+        pktPtr->simLength += TxdOp::getLen(desc);
+        pktPtr->dataLength += TxdOp::getLen(desc);
+    }
 
 
     if ((!TxdOp::eop(desc) && !useTso) ||
-        (pktPtr->length < ( tsoMss + tsoHeaderLen) &&
+        (pktPtr->dataLength < ( tsoMss + tsoHeaderLen) &&
          tsoTotalLen != tsoUsedLen && useTso)) {
         assert(!useTso || (tsoDescBytesUsed == TxdOp::getLen(desc)));
         igbe->anDq("TXS", annUnusedCacheQ);
@@ -1795,7 +1798,7 @@
         pktMultiDesc = true;
 
         DPRINTF(EthernetDesc, "Partial Packet Descriptor of %d bytes Done\n",
-                pktPtr->length);
+                pktPtr->dataLength);
         pktPtr = NULL;
 
         enableSm();
@@ -1825,7 +1828,7 @@
             DPRINTF(EthernetDesc, "TSO: Modifying IP header. Id + %d\n",
                     tsoPkts);
             ip->id(ip->id() + tsoPkts++);
-            ip->len(pktPtr->length - EthPtr(pktPtr)->size());
+            ip->len(pktPtr->dataLength - EthPtr(pktPtr)->size());
 
             TcpPtr tcp(ip);
             if (tcp) {
@@ -1839,7 +1842,7 @@
             UdpPtr udp(ip);
             if (udp) {
                 DPRINTF(EthernetDesc, "TSO: Modifying UDP header.\n");
-                udp->len(pktPtr->length - EthPtr(pktPtr)->size());
+                udp->len(pktPtr->dataLength - EthPtr(pktPtr)->size());
             }
         }
         tsoPrevSeq = tsoUsedLen;
@@ -1919,7 +1922,7 @@
 
     DPRINTF(EthernetDesc,
             "------Packet of %d bytes ready for transmission-------\n",
-            pktPtr->length);
+            pktPtr->dataLength);
     pktDone = true;
     pktWaiting = false;
     pktPtr = NULL;
@@ -2120,7 +2123,7 @@
     // a multidescriptor packet) put it in the fifo, otherwise an the next
     // iteration we'll get the rest of the data
     if (txPacket && txDescCache.packetAvailable()
-        && !txDescCache.packetMultiDesc() && txPacket->length) {
+        && !txDescCache.packetMultiDesc() && txPacket->dataLength) {
         anQ("TXS", "TX FIFO Q");
         DPRINTF(EthernetSM, "TXS: packet placed in TX FIFO\n");
 #ifndef NDEBUG
@@ -2212,7 +2215,7 @@
 bool
 IGbE::ethRxPkt(EthPacketPtr pkt)
 {
-    rxBytes += pkt->length;
+    rxBytes += pkt->dataLength;
     rxPackets++;
 
     DPRINTF(Ethernet, "RxFIFO: Receiving pcakte from wire\n");
@@ -2361,7 +2364,7 @@
 
     pktOffset = rxDescCache.writePacket(pkt, pktOffset);
     DPRINTF(EthernetSM, "RXS: Writing packet into memory\n");
-    if (pktOffset == pkt->length) {
+    if (pktOffset == pkt->dataLength) {
         anBegin( "RXS", "FIFO Dequeue");
         DPRINTF(EthernetSM, "RXS: Removing packet from FIFO\n");
         pktOffset = 0;
@@ -2402,7 +2405,7 @@
                 "TxFIFO: Successful transmit, bytes available in fifo: %d\n",
                 txFifo.avail());
 
-        txBytes += txFifo.front()->length;
+        txBytes += txFifo.front()->dataLength;
         txPackets++;
         txFifoTick = false;
 
@@ -2519,7 +2522,7 @@
     bool txPktExists;
     UNSERIALIZE_SCALAR(txPktExists);
     if (txPktExists) {
-        txPacket = std::make_shared<EthPacketData>(16384);
+        txPacket = std::make_shared<EthPacketData>();
         txPacket->unserialize("txpacket", cp);
     }
 
diff --git a/src/dev/net/ns_gige.cc b/src/dev/net/ns_gige.cc
--- a/src/dev/net/ns_gige.cc
+++ b/src/dev/net/ns_gige.cc
@@ -1249,7 +1249,7 @@
 
             // If we don't have a packet, grab a new one from the fifo.
             rxPacket = rxFifo.front();
-            rxPktBytes = rxPacket->length;
+            rxPktBytes = rxPacket->dataLength;
             rxPacketBufPtr = rxPacket->data;
 
 #if TRACING_ON
@@ -1301,7 +1301,7 @@
             cmdsts &= ~CMDSTS_MORE;
             cmdsts |= CMDSTS_OK;
             cmdsts &= 0xffff0000;
-            cmdsts += rxPacket->length;   //i.e. set CMDSTS_SIZE
+            cmdsts += rxPacket->dataLength;   //i.e. set CMDSTS_SIZE
 
 #if 0
             /*
@@ -1485,8 +1485,8 @@
         }
 #endif
 
-        DDUMP(EthernetData, txFifo.front()->data, txFifo.front()->length);
-        txBytes += txFifo.front()->length;
+        DDUMP(EthernetData, txFifo.front()->data, txFifo.front()->dataLength);
+        txBytes += txFifo.front()->dataLength;
         txPackets++;
 
         DPRINTF(Ethernet, "Successful Xmit! now txFifoAvail is %d\n",
@@ -1738,12 +1738,13 @@
                     }
                 }
 
-                txPacket->length = txPacketBufPtr - txPacket->data;
+                txPacket->simLength = txPacketBufPtr - txPacket->data;
+                txPacket->dataLength = txPacketBufPtr - txPacket->data;
                 // this is just because the receive can't handle a
                 // packet bigger want to make sure
-                if (txPacket->length > 1514)
+                if (txPacket->dataLength > 1514)
                     panic("transmit packet too large, %s > 1514\n",
-                          txPacket->length);
+                          txPacket->dataLength);
 
 #ifndef NDEBUG
                 bool success =
@@ -2048,7 +2049,7 @@
 
     if (drop) {
         DPRINTF(Ethernet, "rxFilter drop\n");
-        DDUMP(EthernetData, packet->data, packet->length);
+        DDUMP(EthernetData, packet->data, packet->dataLength);
     }
 
     return drop;
@@ -2057,7 +2058,7 @@
 bool
 NSGigE::recvPacket(EthPacketPtr packet)
 {
-    rxBytes += packet->length;
+    rxBytes += packet->dataLength;
     rxPackets++;
 
     DPRINTF(Ethernet, "Receiving packet from wire, rxFifoAvail=%d\n",
@@ -2079,7 +2080,7 @@
         return true;
     }
 
-    if (rxFifo.avail() < packet->length) {
+    if (rxFifo.avail() < packet->dataLength) {
 #if TRACING_ON
         IpPtr ip(packet);
         TcpPtr tcp(ip);
@@ -2186,7 +2187,8 @@
     bool txPacketExists = txPacket != nullptr;
     SERIALIZE_SCALAR(txPacketExists);
     if (txPacketExists) {
-        txPacket->length = txPacketBufPtr - txPacket->data;
+        txPacket->simLength = txPacketBufPtr - txPacket->data;
+        txPacket->dataLength = txPacketBufPtr - txPacket->data;
         txPacket->serialize("txPacket", cp);
         uint32_t txPktBufPtr = (uint32_t) (txPacketBufPtr - txPacket->data);
         SERIALIZE_SCALAR(txPktBufPtr);
@@ -2350,7 +2352,7 @@
     bool txPacketExists;
     UNSERIALIZE_SCALAR(txPacketExists);
     if (txPacketExists) {
-        txPacket = make_shared<EthPacketData>(16384);
+        txPacket = make_shared<EthPacketData>();
         txPacket->unserialize("txPacket", cp);
         uint32_t txPktBufPtr;
         UNSERIALIZE_SCALAR(txPktBufPtr);
@@ -2362,7 +2364,7 @@
     UNSERIALIZE_SCALAR(rxPacketExists);
     rxPacket = 0;
     if (rxPacketExists) {
-        rxPacket = make_shared<EthPacketData>(16384);
+        rxPacket = make_shared<EthPacketData>();
         rxPacket->unserialize("rxPacket", cp);
         uint32_t rxPktBufPtr;
         UNSERIALIZE_SCALAR(rxPktBufPtr);
diff --git a/src/dev/net/pktfifo.hh b/src/dev/net/pktfifo.hh
--- a/src/dev/net/pktfifo.hh
+++ b/src/dev/net/pktfifo.hh
@@ -121,12 +121,12 @@
 
     bool push(EthPacketPtr ptr)
     {
-        assert(ptr->length);
-        assert(_reserved <= ptr->length);
-        if (avail() < ptr->length - _reserved)
+        assert(ptr->dataLength);
+        assert(_reserved <= ptr->dataLength);
+        if (avail() < ptr->dataLength - _reserved)
             return false;
 
-        _size += ptr->length;
+        _size += ptr->dataLength;
 
         PacketFifoEntry entry;
         entry.packet = ptr;
@@ -142,7 +142,7 @@
             return;
 
         iterator entry = fifo.begin();
-        _size -= entry->packet->length;
+        _size -= entry->packet->dataLength;
         _size -= entry->slack;
         entry->packet = NULL;
         fifo.pop_front();
@@ -163,10 +163,10 @@
             iterator prev = i;
             --prev;
             assert(prev != fifo.end());
-            prev->slack += i->packet->length;
+            prev->slack += i->packet->dataLength;
             prev->slack += i->slack;
         } else {
-            _size -= i->packet->length;
+            _size -= i->packet->dataLength;
             _size -= i->slack;
         }
 
@@ -195,7 +195,7 @@
     {
         unsigned total = 0;
         for (auto i = begin(); i != end(); ++i)
-            total += i->packet->length + i->slack;
+            total += i->packet->dataLength + i->slack;
 
         if (total != _size)
             panic("total (%d) is not == to size (%d)\n", total, _size);
diff --git a/src/dev/net/pktfifo.cc b/src/dev/net/pktfifo.cc
--- a/src/dev/net/pktfifo.cc
+++ b/src/dev/net/pktfifo.cc
@@ -45,15 +45,15 @@
     iterator end = fifo.end();
     while (len > 0) {
         EthPacketPtr &pkt = i->packet;
-        while (offset >= pkt->length) {
-            offset -= pkt->length;
+        while (offset >= pkt->dataLength) {
+            offset -= pkt->dataLength;
             ++i;
         }
 
         if (i == end)
             panic("invalid fifo");
 
-        unsigned size = min(pkt->length - offset, len);
+        unsigned size = min(pkt->dataLength - offset, len);
         memcpy(data, pkt->data, size);
         offset = 0;
         len -= size;
@@ -77,7 +77,7 @@
 void
 PacketFifoEntry::unserialize(const string &base, CheckpointIn &cp)
 {
-    packet = make_shared<EthPacketData>(16384);
+    packet = make_shared<EthPacketData>();
     packet->unserialize(base + ".packet", cp);
     paramIn(cp, base + ".slack", slack);
     paramIn(cp, base + ".number", number);
diff --git a/src/dev/net/sinic.cc b/src/dev/net/sinic.cc
--- a/src/dev/net/sinic.cc
+++ b/src/dev/net/sinic.cc
@@ -827,7 +827,7 @@
         vnic->rxIndex = rxFifoPtr++;
         vnic->rxIndex->priv = rxActive;
         vnic->rxPacketOffset = 0;
-        vnic->rxPacketBytes = vnic->rxIndex->packet->length;
+        vnic->rxPacketBytes = vnic->rxIndex->packet->dataLength;
         assert(vnic->rxPacketBytes);
         rxMappedCount++;
 
@@ -1016,8 +1016,8 @@
     }
 #endif
 
-    DDUMP(EthernetData, packet->data, packet->length);
-    txBytes += packet->length;
+    DDUMP(EthernetData, packet->data, packet->dataLength);
+    txBytes += packet->dataLength;
     txPackets++;
 
     DPRINTF(Ethernet, "Packet Transmit: successful txFifo Available %d\n",
@@ -1058,7 +1058,7 @@
             txPacketOffset = 0;
         }
 
-        if (txFifo.avail() - txPacket->length <
+        if (txFifo.avail() - txPacket->dataLength <
             Regs::get_TxData_Len(vnic->TxData)) {
             DPRINTF(EthernetSM, "transmit fifo full.  Nothing to do.\n");
             goto exit;
@@ -1085,7 +1085,8 @@
 
       case txCopyDone:
         vnic->TxDone = txDmaLen | Regs::TxDone_Complete;
-        txPacket->length += txDmaLen;
+        txPacket->simLength += txDmaLen;
+        txPacket->dataLength += txDmaLen;
         if ((vnic->TxData & Regs::TxData_More)) {
             txPacketOffset += txDmaLen;
             txState = txIdle;
@@ -1093,7 +1094,7 @@
             break;
         }
 
-        assert(txPacket->length <= txFifo.avail());
+        assert(txPacket->dataLength <= txFifo.avail());
         if ((vnic->TxData & Regs::TxData_Checksum)) {
             IpPtr ip(txPacket);
             if (ip) {
@@ -1207,7 +1208,7 @@
 bool
 Device::recvPacket(EthPacketPtr packet)
 {
-    rxBytes += packet->length;
+    rxBytes += packet->dataLength;
     rxPackets++;
 
     DPRINTF(Ethernet, "Receiving packet from wire, rxFifo Available is %d\n",
@@ -1495,7 +1496,7 @@
     UNSERIALIZE_SCALAR(txPacketExists);
     txPacket = 0;
     if (txPacketExists) {
-        txPacket = make_shared<EthPacketData>(16384);
+        txPacket = make_shared<EthPacketData>();
         txPacket->unserialize("txPacket", cp);
         UNSERIALIZE_SCALAR(txPacketOffset);
         UNSERIALIZE_SCALAR(txPacketBytes);
diff --git a/src/dev/net/tcp_iface.cc b/src/dev/net/tcp_iface.cc
--- a/src/dev/net/tcp_iface.cc
+++ b/src/dev/net/tcp_iface.cc
@@ -300,7 +300,7 @@
 TCPIface::sendPacket(const Header &header, const EthPacketPtr &packet)
 {
     sendTCP(sock, &header, sizeof(header));
-    sendTCP(sock, packet->data, packet->length);
+    sendTCP(sock, packet->data, packet->dataLength);
 }
 
 void
@@ -327,10 +327,11 @@
 void
 TCPIface::recvPacket(const Header &header, EthPacketPtr &packet)
 {
-    packet = make_shared<EthPacketData>(header.dataPacketLength);
-    bool ret = recvTCP(sock, packet->data, header.dataPacketLength);
+    packet = make_shared<EthPacketData>(header.dataLength);
+    bool ret = recvTCP(sock, packet->data, header.dataLength);
     panic_if(!ret, "Error while reading socket");
-    packet->length = header.dataPacketLength;
+    packet->simLength = header.simLength;
+    packet->dataLength = header.dataLength;
 }
 
 void
diff --git a/src/dev/net/etherbus.cc b/src/dev/net/etherbus.cc
--- a/src/dev/net/etherbus.cc
+++ b/src/dev/net/etherbus.cc
@@ -61,8 +61,9 @@
     devlist_t::iterator i = devlist.begin();
     devlist_t::iterator end = devlist.end();
 
-    DPRINTF(Ethernet, "ethernet packet received: length=%d\n", packet->length);
-    DDUMP(EthernetData, packet->data, packet->length);
+    DPRINTF(Ethernet, "ethernet packet received: length=%d\n",
+            packet->dataLength);
+    DDUMP(EthernetData, packet->data, packet->dataLength);
 
     while (i != end) {
         if (loopback || *i != sender)
@@ -93,12 +94,12 @@
         return false;
     }
 
-    DPRINTF(Ethernet, "ethernet packet sent: length=%d\n", pkt->length);
-    DDUMP(EthernetData, pkt->data, pkt->length);
+    DPRINTF(Ethernet, "ethernet packet sent: length=%d\n", pkt->dataLength);
+    DDUMP(EthernetData, pkt->data, pkt->dataLength);
 
     packet = pkt;
     sender = sndr;
-    int delay = (int)ceil(((double)pkt->length * ticksPerByte) + 1.0);
+    int delay = (int)ceil(((double)pkt->simLength * ticksPerByte) + 1.0);
     DPRINTF(Ethernet, "scheduling packet: delay=%d, (rate=%f)\n",
             delay, ticksPerByte);
     schedule(event, curTick() + delay);
diff --git a/src/dev/net/etherdump.cc b/src/dev/net/etherdump.cc
--- a/src/dev/net/etherdump.cc
+++ b/src/dev/net/etherdump.cc
@@ -96,8 +96,8 @@
     pcap_pkthdr pkthdr;
     pkthdr.seconds = curTick() / SimClock::Int::s;
     pkthdr.microseconds = (curTick() / SimClock::Int::us) % ULL(1000000);
-    pkthdr.caplen = std::min(packet->length, maxlen);
-    pkthdr.len = packet->length;
+    pkthdr.caplen = std::min(packet->dataLength, maxlen);
+    pkthdr.len = packet->dataLength;
     stream->write(reinterpret_cast<char *>(&pkthdr), sizeof(pkthdr));
     stream->write(reinterpret_cast<char *>(packet->data), pkthdr.caplen);
     stream->flush();
diff --git a/src/dev/net/etherlink.cc b/src/dev/net/etherlink.cc
--- a/src/dev/net/etherlink.cc
+++ b/src/dev/net/etherlink.cc
@@ -136,8 +136,8 @@
 void
 EtherLink::Link::txComplete(EthPacketPtr packet)
 {
-    DPRINTF(Ethernet, "packet received: len=%d\n", packet->length);
-    DDUMP(EthernetData, packet->data, packet->length);
+    DPRINTF(Ethernet, "packet received: len=%d\n", packet->dataLength);
+    DDUMP(EthernetData, packet->data, packet->dataLength);
     rxint->sendPacket(packet);
 }
 
@@ -188,11 +188,11 @@
         return false;
     }
 
-    DPRINTF(Ethernet, "packet sent: len=%d\n", pkt->length);
-    DDUMP(EthernetData, pkt->data, pkt->length);
+    DPRINTF(Ethernet, "packet sent: len=%d\n", pkt->dataLength);
+    DDUMP(EthernetData, pkt->data, pkt->dataLength);
 
     packet = pkt;
-    Tick delay = (Tick)ceil(((double)pkt->length * ticksPerByte) + 1.0);
+    Tick delay = (Tick)ceil(((double)pkt->simLength * ticksPerByte) + 1.0);
     if (delayVar != 0)
         delay += random_mt.random<Tick>(0, delayVar);
 
@@ -235,7 +235,7 @@
     bool packet_exists;
     paramIn(cp, base + ".packet_exists", packet_exists);
     if (packet_exists) {
-        packet = make_shared<EthPacketData>(16384);
+        packet = make_shared<EthPacketData>();
         packet->unserialize(base + ".packet", cp);
     }
 
@@ -251,7 +251,7 @@
     if (optParamIn(cp, base + ".tx_queue_size", tx_queue_size)) {
         for (size_t idx = 0; idx < tx_queue_size; ++idx) {
             Tick tick;
-            EthPacketPtr delayed_packet = make_shared<EthPacketData>(16384);
+            EthPacketPtr delayed_packet = make_shared<EthPacketData>();
 
             paramIn(cp, csprintf("%s.txQueue[%i].tick", base, idx), tick);
             delayed_packet->unserialize(
diff --git a/src/dev/net/etherpkt.hh b/src/dev/net/etherpkt.hh
--- a/src/dev/net/etherpkt.hh
+++ b/src/dev/net/etherpkt.hh
@@ -49,33 +49,37 @@
 class EthPacketData
 {
   public:
-    /*
+    /**
      * Pointer to packet data will be deleted
      */
     uint8_t *data;
 
-    /*
-     * Length of the current packet
+    /**
+     * Amount of space occupied by the payload in the data buffer
      */
-    unsigned length;
+    unsigned dataLength;
 
-  public:
+    /**
+     * Effective length, used for modeling timing in the simulator.
+     * This could be different from dataLength if the packets are assumed
+     * to use a tightly packed or compressed format, but it's not worth
+     * the performance/complexity hit to perform that packing or compression
+     * in the simulation.
+     */
+    unsigned simLength;
+
     EthPacketData()
-        : data(NULL), length(0)
+        : data(nullptr), dataLength(0), simLength(0)
     { }
 
     explicit EthPacketData(unsigned size)
-        : data(new uint8_t[size]), length(0)
+        : data(new uint8_t[size]), dataLength(0), simLength(0)
     { }
 
     ~EthPacketData() { if (data) delete [] data; }
 
-  public:
-
     void serialize(const std::string &base, CheckpointOut &cp) const;
     void unserialize(const std::string &base, CheckpointIn &cp);
-
-    unsigned size() const { return length; }
 };
 
 typedef std::shared_ptr<EthPacketData> EthPacketPtr;
diff --git a/src/dev/net/etherpkt.cc b/src/dev/net/etherpkt.cc
--- a/src/dev/net/etherpkt.cc
+++ b/src/dev/net/etherpkt.cc
@@ -41,15 +41,20 @@
 void
 EthPacketData::serialize(const string &base, CheckpointOut &cp) const
 {
-    paramOut(cp, base + ".length", length);
-    arrayParamOut(cp, base + ".data", data, length);
+    paramOut(cp, base + ".simLength", simLength);
+    paramOut(cp, base + ".dataLength", dataLength);
+    arrayParamOut(cp, base + ".data", data, dataLength);
 }
 
 void
 EthPacketData::unserialize(const string &base, CheckpointIn &cp)
 {
-    paramIn(cp, base + ".length", length);
-    if (length)
-        arrayParamIn(cp, base + ".data", data, length);
+    paramIn(cp, base + ".simLength", simLength);
+    paramIn(cp, base + ".dataLength", dataLength);
+    if (dataLength) {
+        assert(data == nullptr);
+        data = new uint8_t[dataLength];
+        arrayParamIn(cp, base + ".data", data, dataLength);
+    }
 }
 
# Node ID 573a7d349538bbd534c68f439eb3261afa234eec
# Parent  91f58918a76abf1a1dedcaa70a9b95789da7b88c
diff --git a/src/dev/net/dist_etherlink.cc b/src/dev/net/dist_etherlink.cc
--- a/src/dev/net/dist_etherlink.cc
+++ b/src/dev/net/dist_etherlink.cc
@@ -168,8 +168,8 @@
         dump->dump(packet);
 
     DPRINTF(DistEthernetPkt, "DistEtherLink::DistLink::rxDone() "
-            "packet received: len=%d\n", packet->length);
-    DDUMP(EthernetData, packet->data, packet->length);
+            "packet received: len=%d\n", packet->dataLength);
+    DDUMP(EthernetData, packet->data, packet->dataLength);
 
     localIface->sendPacket(packet);
 
@@ -197,7 +197,7 @@
     }
 
     packet = pkt;
-    Tick delay = (Tick)ceil(((double)pkt->length * ticksPerByte) + 1.0);
+    Tick delay = (Tick)ceil(((double)pkt->simLength * ticksPerByte) + 1.0);
     if (delayVar != 0)
         delay += random_mt.random<Tick>(0, delayVar);
 
@@ -233,7 +233,7 @@
     bool packet_exists;
     UNSERIALIZE_SCALAR(packet_exists);
     if (packet_exists) {
-        packet = make_shared<EthPacketData>(16384);
+        packet = make_shared<EthPacketData>();
         packet->unserialize("packet", cp);
     }
 
diff --git a/src/dev/net/dist_iface.cc b/src/dev/net/dist_iface.cc
--- a/src/dev/net/dist_iface.cc
+++ b/src/dev/net/dist_iface.cc
@@ -407,7 +407,7 @@
         Desc d = descQueue.front();
         descQueue.pop();
         d.sendTick = curTick();
-        d.sendDelay = d.packet->size(); // assume 1 tick/byte max link speed
+        d.sendDelay = d.packet->simLength; // assume 1 tick/byte max link speed
         v.push_back(d);
     }
 
@@ -493,7 +493,7 @@
 {
         UNSERIALIZE_SCALAR(sendTick);
         UNSERIALIZE_SCALAR(sendDelay);
-        packet = std::make_shared<EthPacketData>(16384);
+        packet = std::make_shared<EthPacketData>();
         packet->unserialize("rxPacket", cp);
 }
 
@@ -582,15 +582,15 @@
     header.msgType = MsgType::dataDescriptor;
     header.sendTick  = curTick();
     header.sendDelay = send_delay;
-
-    header.dataPacketLength = pkt->size();
+    header.simLength = pkt->simLength;
+    header.dataLength = pkt->dataLength;
 
     // Send out the packet and the meta info.
     sendPacket(header, pkt);
 
     DPRINTF(DistEthernetPkt,
             "DistIface::sendDataPacket() done size:%d send_delay:%llu\n",
-            pkt->size(), send_delay);
+            pkt->dataLength, send_delay);
 }
 
 void
diff --git a/src/dev/net/dist_packet.hh b/src/dev/net/dist_packet.hh
--- a/src/dev/net/dist_packet.hh
+++ b/src/dev/net/dist_packet.hh
@@ -86,6 +86,11 @@
          */
         MsgType msgType;
         Tick sendTick;
+        /**
+         * Length used for modeling timing in the simulator.
+         * (from EthPacketData::simLength).
+         */
+        unsigned simLength;
         union {
             Tick sendDelay;
             Tick syncRepeat;
@@ -93,8 +98,9 @@
         union {
             /**
              * Actual length of the simulated Ethernet packet.
+             * (from EthPacketData::dataLength).
              */
-            unsigned dataPacketLength;
+            unsigned dataLength;
             struct {
                 ReqType needCkpt;
                 ReqType needExit;