packet.cc revision 10570
1/* 2 * Copyright (c) 2011-2014 ARM Limited 3 * All rights reserved 4 * 5 * The license below extends only to copyright in the software and shall 6 * not be construed as granting a license to any other intellectual 7 * property including but not limited to intellectual property relating 8 * to a hardware implementation of the functionality of the software 9 * licensed hereunder. You may use the software subject to the license 10 * terms below provided that you ensure that this notice is replicated 11 * unmodified and in its entirety in all distributions of the software, 12 * modified or unmodified, in source code or in binary form. 13 * 14 * Copyright (c) 2006 The Regents of The University of Michigan 15 * Copyright (c) 2010 Advanced Micro Devices, Inc. 16 * All rights reserved. 17 * 18 * Redistribution and use in source and binary forms, with or without 19 * modification, are permitted provided that the following conditions are 20 * met: redistributions of source code must retain the above copyright 21 * notice, this list of conditions and the following disclaimer; 22 * redistributions in binary form must reproduce the above copyright 23 * notice, this list of conditions and the following disclaimer in the 24 * documentation and/or other materials provided with the distribution; 25 * neither the name of the copyright holders nor the names of its 26 * contributors may be used to endorse or promote products derived from 27 * this software without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 40 * 41 * Authors: Ali Saidi 42 * Steve Reinhardt 43 */ 44 45/** 46 * @file 47 * Definition of the Packet Class, a packet is a transaction occuring 48 * between a single level of the memory heirarchy (ie L1->L2). 49 */ 50 51#include <cstring> 52#include <iostream> 53 54#include "base/cprintf.hh" 55#include "base/misc.hh" 56#include "base/trace.hh" 57#include "mem/packet.hh" 58 59using namespace std; 60 61// The one downside to bitsets is that static initializers can get ugly. 62#define SET1(a1) (1 << (a1)) 63#define SET2(a1, a2) (SET1(a1) | SET1(a2)) 64#define SET3(a1, a2, a3) (SET2(a1, a2) | SET1(a3)) 65#define SET4(a1, a2, a3, a4) (SET3(a1, a2, a3) | SET1(a4)) 66#define SET5(a1, a2, a3, a4, a5) (SET4(a1, a2, a3, a4) | SET1(a5)) 67#define SET6(a1, a2, a3, a4, a5, a6) (SET5(a1, a2, a3, a4, a5) | SET1(a6)) 68 69const MemCmd::CommandInfo 70MemCmd::commandInfo[] = 71{ 72 /* InvalidCmd */ 73 { 0, InvalidCmd, "InvalidCmd" }, 74 /* ReadReq */ 75 { SET3(IsRead, IsRequest, NeedsResponse), ReadResp, "ReadReq" }, 76 /* ReadResp */ 77 { SET3(IsRead, IsResponse, HasData), InvalidCmd, "ReadResp" }, 78 /* ReadRespWithInvalidate */ 79 { SET4(IsRead, IsResponse, HasData, IsInvalidate), 80 InvalidCmd, "ReadRespWithInvalidate" }, 81 /* WriteReq */ 82 { SET5(IsWrite, NeedsExclusive, IsRequest, NeedsResponse, HasData), 83 WriteResp, "WriteReq" }, 84 /* WriteResp */ 85 { SET3(IsWrite, NeedsExclusive, IsResponse), InvalidCmd, "WriteResp" }, 86 /* Writeback */ 87 { SET4(IsWrite, NeedsExclusive, IsRequest, HasData), 88 InvalidCmd, "Writeback" }, 89 /* SoftPFReq */ 90 { SET4(IsRead, IsRequest, IsSWPrefetch, NeedsResponse), 91 SoftPFResp, "SoftPFReq" }, 92 /* HardPFReq */ 93 { SET4(IsRead, IsRequest, IsHWPrefetch, NeedsResponse), 94 HardPFResp, "HardPFReq" }, 95 /* SoftPFResp */ 96 { SET4(IsRead, IsResponse, IsSWPrefetch, HasData), 97 InvalidCmd, "SoftPFResp" }, 98 /* HardPFResp */ 99 { SET4(IsRead, IsResponse, IsHWPrefetch, HasData), 100 InvalidCmd, "HardPFResp" }, 101 /* WriteInvalidateReq */ 102 { SET6(IsWrite, NeedsExclusive, IsInvalidate, 103 IsRequest, HasData, NeedsResponse), 104 WriteInvalidateResp, "WriteInvalidateReq" }, 105 /* WriteInvalidateResp */ 106 { SET3(IsWrite, NeedsExclusive, IsResponse), 107 InvalidCmd, "WriteInvalidateResp" }, 108 /* UpgradeReq */ 109 { SET5(IsInvalidate, NeedsExclusive, IsUpgrade, IsRequest, NeedsResponse), 110 UpgradeResp, "UpgradeReq" }, 111 /* SCUpgradeReq: response could be UpgradeResp or UpgradeFailResp */ 112 { SET6(IsInvalidate, NeedsExclusive, IsUpgrade, IsLlsc, 113 IsRequest, NeedsResponse), 114 UpgradeResp, "SCUpgradeReq" }, 115 /* UpgradeResp */ 116 { SET3(NeedsExclusive, IsUpgrade, IsResponse), 117 InvalidCmd, "UpgradeResp" }, 118 /* SCUpgradeFailReq: generates UpgradeFailResp but still gets the data */ 119 { SET6(IsRead, NeedsExclusive, IsInvalidate, 120 IsLlsc, IsRequest, NeedsResponse), 121 UpgradeFailResp, "SCUpgradeFailReq" }, 122 /* UpgradeFailResp - Behaves like a ReadExReq, but notifies an SC 123 * that it has failed, acquires line as Dirty*/ 124 { SET4(IsRead, NeedsExclusive, IsResponse, HasData), 125 InvalidCmd, "UpgradeFailResp" }, 126 /* ReadExReq */ 127 { SET5(IsRead, NeedsExclusive, IsInvalidate, IsRequest, NeedsResponse), 128 ReadExResp, "ReadExReq" }, 129 /* ReadExResp */ 130 { SET4(IsRead, NeedsExclusive, IsResponse, HasData), 131 InvalidCmd, "ReadExResp" }, 132 /* LoadLockedReq: note that we use plain ReadResp as response, so that 133 * we can also use ReadRespWithInvalidate when needed */ 134 { SET4(IsRead, IsLlsc, IsRequest, NeedsResponse), 135 ReadResp, "LoadLockedReq" }, 136 /* StoreCondReq */ 137 { SET6(IsWrite, NeedsExclusive, IsLlsc, 138 IsRequest, NeedsResponse, HasData), 139 StoreCondResp, "StoreCondReq" }, 140 /* StoreCondFailReq: generates failing StoreCondResp */ 141 { SET6(IsWrite, NeedsExclusive, IsLlsc, 142 IsRequest, NeedsResponse, HasData), 143 StoreCondResp, "StoreCondFailReq" }, 144 /* StoreCondResp */ 145 { SET4(IsWrite, NeedsExclusive, IsLlsc, IsResponse), 146 InvalidCmd, "StoreCondResp" }, 147 /* SwapReq -- for Swap ldstub type operations */ 148 { SET6(IsRead, IsWrite, NeedsExclusive, IsRequest, HasData, NeedsResponse), 149 SwapResp, "SwapReq" }, 150 /* SwapResp -- for Swap ldstub type operations */ 151 { SET5(IsRead, IsWrite, NeedsExclusive, IsResponse, HasData), 152 InvalidCmd, "SwapResp" }, 153 /* IntReq -- for interrupts */ 154 { SET4(IsWrite, IsRequest, NeedsResponse, HasData), 155 MessageResp, "MessageReq" }, 156 /* IntResp -- for interrupts */ 157 { SET2(IsWrite, IsResponse), InvalidCmd, "MessageResp" }, 158 /* InvalidDestError -- packet dest field invalid */ 159 { SET2(IsResponse, IsError), InvalidCmd, "InvalidDestError" }, 160 /* BadAddressError -- memory address invalid */ 161 { SET2(IsResponse, IsError), InvalidCmd, "BadAddressError" }, 162 /* FunctionalReadError */ 163 { SET3(IsRead, IsResponse, IsError), InvalidCmd, "FunctionalReadError" }, 164 /* FunctionalWriteError */ 165 { SET3(IsWrite, IsResponse, IsError), InvalidCmd, "FunctionalWriteError" }, 166 /* PrintReq */ 167 { SET2(IsRequest, IsPrint), InvalidCmd, "PrintReq" }, 168 /* Flush Request */ 169 { SET3(IsRequest, IsFlush, NeedsExclusive), InvalidCmd, "FlushReq" }, 170 /* Invalidation Request */ 171 { SET3(NeedsExclusive, IsInvalidate, IsRequest), 172 InvalidCmd, "InvalidationReq" }, 173}; 174 175bool 176Packet::checkFunctional(Printable *obj, Addr addr, bool is_secure, int size, 177 uint8_t *_data) 178{ 179 Addr func_start = getAddr(); 180 Addr func_end = getAddr() + getSize() - 1; 181 Addr val_start = addr; 182 Addr val_end = val_start + size - 1; 183 184 if (is_secure != _isSecure || func_start > val_end || 185 val_start > func_end) { 186 // no intersection 187 return false; 188 } 189 190 // check print first since it doesn't require data 191 if (isPrint()) { 192 assert(!_data); 193 safe_cast<PrintReqState*>(senderState)->printObj(obj); 194 return false; 195 } 196 197 // we allow the caller to pass NULL to signify the other packet 198 // has no data 199 if (!_data) { 200 return false; 201 } 202 203 // offset of functional request into supplied value (could be 204 // negative if partial overlap) 205 int offset = func_start - val_start; 206 207 if (isRead()) { 208 if (func_start >= val_start && func_end <= val_end) { 209 memcpy(getPtr<uint8_t>(), _data + offset, getSize()); 210 // complete overlap, and as the current packet is a read 211 // we are done 212 return true; 213 } else { 214 // Offsets and sizes to copy in case of partial overlap 215 int func_offset; 216 int val_offset; 217 int overlap_size; 218 219 // calculate offsets and copy sizes for the two byte arrays 220 if (val_start < func_start && val_end <= func_end) { 221 val_offset = func_start - val_start; 222 func_offset = 0; 223 overlap_size = val_end - func_start; 224 } else if (val_start >= func_start && val_end > func_end) { 225 val_offset = 0; 226 func_offset = val_start - func_start; 227 overlap_size = func_end - val_start; 228 } else if (val_start >= func_start && val_end <= func_end) { 229 val_offset = 0; 230 func_offset = val_start - func_start; 231 overlap_size = size; 232 } else { 233 panic("BUG: Missed a case for a partial functional request"); 234 } 235 236 // Figure out how much of the partial overlap should be copied 237 // into the packet and not overwrite previously found bytes. 238 if (bytesValidStart == 0 && bytesValidEnd == 0) { 239 // No bytes have been copied yet, just set indices 240 // to found range 241 bytesValidStart = func_offset; 242 bytesValidEnd = func_offset + overlap_size; 243 } else { 244 // Some bytes have already been copied. Use bytesValid 245 // indices and offset values to figure out how much data 246 // to copy and where to copy it to. 247 248 // Indice overlap conditions to check 249 int a = func_offset - bytesValidStart; 250 int b = (func_offset + overlap_size) - bytesValidEnd; 251 int c = func_offset - bytesValidEnd; 252 int d = (func_offset + overlap_size) - bytesValidStart; 253 254 if (a >= 0 && b <= 0) { 255 // bytes already in pkt data array are superset of 256 // found bytes, will not copy any bytes 257 overlap_size = 0; 258 } else if (a < 0 && d >= 0 && b <= 0) { 259 // found bytes will move bytesValidStart towards 0 260 overlap_size = bytesValidStart - func_offset; 261 bytesValidStart = func_offset; 262 } else if (b > 0 && c <= 0 && a >= 0) { 263 // found bytes will move bytesValidEnd 264 // towards end of pkt data array 265 overlap_size = 266 (func_offset + overlap_size) - bytesValidEnd; 267 val_offset += bytesValidEnd - func_offset; 268 func_offset = bytesValidEnd; 269 bytesValidEnd += overlap_size; 270 } else if (a < 0 && b > 0) { 271 // Found bytes are superset of copied range. Will move 272 // bytesValidStart towards 0 and bytesValidEnd towards 273 // end of pkt data array. Need to break copy into two 274 // pieces so as to not overwrite previously found data. 275 276 // copy the first half 277 uint8_t *dest = getPtr<uint8_t>() + func_offset; 278 uint8_t *src = _data + val_offset; 279 memcpy(dest, src, (bytesValidStart - func_offset)); 280 281 // re-calc the offsets and indices to do the copy 282 // required for the second half 283 val_offset += (bytesValidEnd - func_offset); 284 bytesValidStart = func_offset; 285 overlap_size = 286 (func_offset + overlap_size) - bytesValidEnd; 287 func_offset = bytesValidEnd; 288 bytesValidEnd += overlap_size; 289 } else if ((c > 0 && b > 0) 290 || (a < 0 && d < 0)) { 291 // region to be copied is discontiguous! Not supported. 292 panic("BUG: Discontiguous bytes found" 293 "for functional copying!"); 294 } 295 } 296 assert(bytesValidEnd <= getSize()); 297 298 // copy partial data into the packet's data array 299 uint8_t *dest = getPtr<uint8_t>() + func_offset; 300 uint8_t *src = _data + val_offset; 301 memcpy(dest, src, overlap_size); 302 303 // check if we're done filling the functional access 304 bool done = (bytesValidStart == 0) && (bytesValidEnd == getSize()); 305 return done; 306 } 307 } else if (isWrite()) { 308 if (offset >= 0) { 309 memcpy(_data + offset, getConstPtr<uint8_t>(), 310 (min(func_end, val_end) - func_start) + 1); 311 } else { 312 // val_start > func_start 313 memcpy(_data, getConstPtr<uint8_t>() - offset, 314 (min(func_end, val_end) - val_start) + 1); 315 } 316 } else { 317 panic("Don't know how to handle command %s\n", cmdString()); 318 } 319 320 // keep going with request by default 321 return false; 322} 323 324void 325Packet::pushSenderState(Packet::SenderState *sender_state) 326{ 327 assert(sender_state != NULL); 328 sender_state->predecessor = senderState; 329 senderState = sender_state; 330} 331 332Packet::SenderState * 333Packet::popSenderState() 334{ 335 assert(senderState != NULL); 336 SenderState *sender_state = senderState; 337 senderState = sender_state->predecessor; 338 sender_state->predecessor = NULL; 339 return sender_state; 340} 341 342void 343Packet::print(ostream &o, const int verbosity, const string &prefix) const 344{ 345 ccprintf(o, "%s[%x:%x] %s\n", prefix, 346 getAddr(), getAddr() + getSize() - 1, cmdString()); 347} 348 349std::string 350Packet::print() const { 351 ostringstream str; 352 print(str); 353 return str.str(); 354} 355 356Packet::PrintReqState::PrintReqState(ostream &_os, int _verbosity) 357 : curPrefixPtr(new string("")), os(_os), verbosity(_verbosity) 358{ 359 labelStack.push_back(LabelStackEntry("", curPrefixPtr)); 360} 361 362Packet::PrintReqState::~PrintReqState() 363{ 364 labelStack.pop_back(); 365 assert(labelStack.empty()); 366 delete curPrefixPtr; 367} 368 369Packet::PrintReqState:: 370LabelStackEntry::LabelStackEntry(const string &_label, string *_prefix) 371 : label(_label), prefix(_prefix), labelPrinted(false) 372{ 373} 374 375void 376Packet::PrintReqState::pushLabel(const string &lbl, const string &prefix) 377{ 378 labelStack.push_back(LabelStackEntry(lbl, curPrefixPtr)); 379 curPrefixPtr = new string(*curPrefixPtr); 380 *curPrefixPtr += prefix; 381} 382 383void 384Packet::PrintReqState::popLabel() 385{ 386 delete curPrefixPtr; 387 curPrefixPtr = labelStack.back().prefix; 388 labelStack.pop_back(); 389 assert(!labelStack.empty()); 390} 391 392void 393Packet::PrintReqState::printLabels() 394{ 395 if (!labelStack.back().labelPrinted) { 396 LabelStack::iterator i = labelStack.begin(); 397 LabelStack::iterator end = labelStack.end(); 398 while (i != end) { 399 if (!i->labelPrinted) { 400 ccprintf(os, "%s%s\n", *(i->prefix), i->label); 401 i->labelPrinted = true; 402 } 403 i++; 404 } 405 } 406} 407 408 409void 410Packet::PrintReqState::printObj(Printable *obj) 411{ 412 printLabels(); 413 obj->print(os, verbosity, curPrefix()); 414} 415