table_walker.cc revision 10367:bf52480abd01
1/* 2 * Copyright (c) 2010, 2012-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 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions are 16 * met: redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer; 18 * redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution; 21 * neither the name of the copyright holders nor the names of its 22 * contributors may be used to endorse or promote products derived from 23 * this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36 * 37 * Authors: Ali Saidi 38 * Giacomo Gabrielli 39 */ 40 41#include "arch/arm/faults.hh" 42#include "arch/arm/stage2_mmu.hh" 43#include "arch/arm/system.hh" 44#include "arch/arm/table_walker.hh" 45#include "arch/arm/tlb.hh" 46#include "cpu/base.hh" 47#include "cpu/thread_context.hh" 48#include "debug/Checkpoint.hh" 49#include "debug/Drain.hh" 50#include "debug/TLB.hh" 51#include "debug/TLBVerbose.hh" 52#include "sim/system.hh" 53 54using namespace ArmISA; 55 56TableWalker::TableWalker(const Params *p) 57 : MemObject(p), port(this, p->sys), drainManager(NULL), 58 stage2Mmu(NULL), isStage2(p->is_stage2), tlb(NULL), 59 currState(NULL), pending(false), masterId(p->sys->getMasterId(name())), 60 numSquashable(p->num_squash_per_cycle), 61 doL1DescEvent(this), doL2DescEvent(this), 62 doL0LongDescEvent(this), doL1LongDescEvent(this), doL2LongDescEvent(this), 63 doL3LongDescEvent(this), 64 doProcessEvent(this) 65{ 66 sctlr = 0; 67 68 // Cache system-level properties 69 if (FullSystem) { 70 armSys = dynamic_cast<ArmSystem *>(p->sys); 71 assert(armSys); 72 haveSecurity = armSys->haveSecurity(); 73 _haveLPAE = armSys->haveLPAE(); 74 _haveVirtualization = armSys->haveVirtualization(); 75 physAddrRange = armSys->physAddrRange(); 76 _haveLargeAsid64 = armSys->haveLargeAsid64(); 77 } else { 78 armSys = NULL; 79 haveSecurity = _haveLPAE = _haveVirtualization = false; 80 _haveLargeAsid64 = false; 81 physAddrRange = 32; 82 } 83 84} 85 86TableWalker::~TableWalker() 87{ 88 ; 89} 90 91TableWalker::WalkerState::WalkerState() : stage2Tran(NULL), l2Desc(l1Desc) 92{ 93} 94 95void 96TableWalker::completeDrain() 97{ 98 if (drainManager && stateQueues[L1].empty() && stateQueues[L2].empty() && 99 pendingQueue.empty()) { 100 setDrainState(Drainable::Drained); 101 DPRINTF(Drain, "TableWalker done draining, processing drain event\n"); 102 drainManager->signalDrainDone(); 103 drainManager = NULL; 104 } 105} 106 107unsigned int 108TableWalker::drain(DrainManager *dm) 109{ 110 unsigned int count = port.drain(dm); 111 112 bool state_queues_not_empty = false; 113 114 for (int i = 0; i < MAX_LOOKUP_LEVELS; ++i) { 115 if (!stateQueues[i].empty()) { 116 state_queues_not_empty = true; 117 break; 118 } 119 } 120 121 if (state_queues_not_empty || pendingQueue.size()) { 122 drainManager = dm; 123 setDrainState(Drainable::Draining); 124 DPRINTF(Drain, "TableWalker not drained\n"); 125 126 // return port drain count plus the table walker itself needs to drain 127 return count + 1; 128 } else { 129 setDrainState(Drainable::Drained); 130 DPRINTF(Drain, "TableWalker free, no need to drain\n"); 131 132 // table walker is drained, but its ports may still need to be drained 133 return count; 134 } 135} 136 137void 138TableWalker::drainResume() 139{ 140 Drainable::drainResume(); 141 if (params()->sys->isTimingMode() && currState) { 142 delete currState; 143 currState = NULL; 144 } 145} 146 147BaseMasterPort& 148TableWalker::getMasterPort(const std::string &if_name, PortID idx) 149{ 150 if (if_name == "port") { 151 return port; 152 } 153 return MemObject::getMasterPort(if_name, idx); 154} 155 156Fault 157TableWalker::walk(RequestPtr _req, ThreadContext *_tc, uint16_t _asid, 158 uint8_t _vmid, bool _isHyp, TLB::Mode _mode, 159 TLB::Translation *_trans, bool _timing, bool _functional, 160 bool secure, TLB::ArmTranslationType tranType) 161{ 162 assert(!(_functional && _timing)); 163 WalkerState *savedCurrState = NULL; 164 165 if (!currState && !_functional) { 166 // For atomic mode, a new WalkerState instance should be only created 167 // once per TLB. For timing mode, a new instance is generated for every 168 // TLB miss. 169 DPRINTF(TLBVerbose, "creating new instance of WalkerState\n"); 170 171 currState = new WalkerState(); 172 currState->tableWalker = this; 173 } else if (_functional) { 174 // If we are mixing functional mode with timing (or even 175 // atomic), we need to to be careful and clean up after 176 // ourselves to not risk getting into an inconsistent state. 177 DPRINTF(TLBVerbose, "creating functional instance of WalkerState\n"); 178 savedCurrState = currState; 179 currState = new WalkerState(); 180 currState->tableWalker = this; 181 } else if (_timing) { 182 // This is a translation that was completed and then faulted again 183 // because some underlying parameters that affect the translation 184 // changed out from under us (e.g. asid). It will either be a 185 // misprediction, in which case nothing will happen or we'll use 186 // this fault to re-execute the faulting instruction which should clean 187 // up everything. 188 if (currState->vaddr_tainted == _req->getVaddr()) { 189 return new ReExec; 190 } 191 } 192 193 currState->tc = _tc; 194 currState->aarch64 = opModeIs64(currOpMode(_tc)); 195 currState->el = currEL(_tc); 196 currState->transState = _trans; 197 currState->req = _req; 198 currState->fault = NoFault; 199 currState->asid = _asid; 200 currState->vmid = _vmid; 201 currState->isHyp = _isHyp; 202 currState->timing = _timing; 203 currState->functional = _functional; 204 currState->mode = _mode; 205 currState->tranType = tranType; 206 currState->isSecure = secure; 207 currState->physAddrRange = physAddrRange; 208 209 /** @todo These should be cached or grabbed from cached copies in 210 the TLB, all these miscreg reads are expensive */ 211 currState->vaddr_tainted = currState->req->getVaddr(); 212 if (currState->aarch64) 213 currState->vaddr = purifyTaggedAddr(currState->vaddr_tainted, 214 currState->tc, currState->el); 215 else 216 currState->vaddr = currState->vaddr_tainted; 217 218 if (currState->aarch64) { 219 switch (currState->el) { 220 case EL0: 221 case EL1: 222 currState->sctlr = currState->tc->readMiscReg(MISCREG_SCTLR_EL1); 223 currState->tcr = currState->tc->readMiscReg(MISCREG_TCR_EL1); 224 break; 225 // @todo: uncomment this to enable Virtualization 226 // case EL2: 227 // assert(haveVirtualization); 228 // currState->sctlr = currState->tc->readMiscReg(MISCREG_SCTLR_EL2); 229 // currState->tcr = currState->tc->readMiscReg(MISCREG_TCR_EL2); 230 // break; 231 case EL3: 232 assert(haveSecurity); 233 currState->sctlr = currState->tc->readMiscReg(MISCREG_SCTLR_EL3); 234 currState->tcr = currState->tc->readMiscReg(MISCREG_TCR_EL3); 235 break; 236 default: 237 panic("Invalid exception level"); 238 break; 239 } 240 } else { 241 currState->sctlr = currState->tc->readMiscReg(flattenMiscRegNsBanked( 242 MISCREG_SCTLR, currState->tc, !currState->isSecure)); 243 currState->ttbcr = currState->tc->readMiscReg(flattenMiscRegNsBanked( 244 MISCREG_TTBCR, currState->tc, !currState->isSecure)); 245 currState->htcr = currState->tc->readMiscReg(MISCREG_HTCR); 246 currState->hcr = currState->tc->readMiscReg(MISCREG_HCR); 247 currState->vtcr = currState->tc->readMiscReg(MISCREG_VTCR); 248 } 249 sctlr = currState->sctlr; 250 251 currState->isFetch = (currState->mode == TLB::Execute); 252 currState->isWrite = (currState->mode == TLB::Write); 253 254 // We only do a second stage of translation if we're not secure, or in 255 // hyp mode, the second stage MMU is enabled, and this table walker 256 // instance is the first stage. 257 currState->doingStage2 = false; 258 // @todo: for now disable this in AArch64 (HCR is not set) 259 currState->stage2Req = !currState->aarch64 && currState->hcr.vm && 260 !isStage2 && !currState->isSecure && !currState->isHyp; 261 262 bool long_desc_format = currState->aarch64 || 263 (_haveLPAE && currState->ttbcr.eae) || 264 _isHyp || isStage2; 265 266 if (long_desc_format) { 267 // Helper variables used for hierarchical permissions 268 currState->secureLookup = currState->isSecure; 269 currState->rwTable = true; 270 currState->userTable = true; 271 currState->xnTable = false; 272 currState->pxnTable = false; 273 } 274 275 if (!currState->timing) { 276 Fault fault = NoFault; 277 if (currState->aarch64) 278 fault = processWalkAArch64(); 279 else if (long_desc_format) 280 fault = processWalkLPAE(); 281 else 282 fault = processWalk(); 283 284 // If this was a functional non-timing access restore state to 285 // how we found it. 286 if (currState->functional) { 287 delete currState; 288 currState = savedCurrState; 289 } 290 return fault; 291 } 292 293 if (pending || pendingQueue.size()) { 294 pendingQueue.push_back(currState); 295 currState = NULL; 296 } else { 297 pending = true; 298 if (currState->aarch64) 299 return processWalkAArch64(); 300 else if (long_desc_format) 301 return processWalkLPAE(); 302 else 303 return processWalk(); 304 } 305 306 return NoFault; 307} 308 309void 310TableWalker::processWalkWrapper() 311{ 312 assert(!currState); 313 assert(pendingQueue.size()); 314 currState = pendingQueue.front(); 315 316 ExceptionLevel target_el = EL0; 317 if (currState->aarch64) 318 target_el = currEL(currState->tc); 319 else 320 target_el = EL1; 321 322 // Check if a previous walk filled this request already 323 // @TODO Should this always be the TLB or should we look in the stage2 TLB? 324 TlbEntry* te = tlb->lookup(currState->vaddr, currState->asid, 325 currState->vmid, currState->isHyp, currState->isSecure, true, false, 326 target_el); 327 328 // Check if we still need to have a walk for this request. If the requesting 329 // instruction has been squashed, or a previous walk has filled the TLB with 330 // a match, we just want to get rid of the walk. The latter could happen 331 // when there are multiple outstanding misses to a single page and a 332 // previous request has been successfully translated. 333 if (!currState->transState->squashed() && !te) { 334 // We've got a valid request, lets process it 335 pending = true; 336 pendingQueue.pop_front(); 337 if (currState->aarch64) 338 processWalkAArch64(); 339 else if ((_haveLPAE && currState->ttbcr.eae) || currState->isHyp || isStage2) 340 processWalkLPAE(); 341 else 342 processWalk(); 343 return; 344 } 345 346 347 // If the instruction that we were translating for has been 348 // squashed we shouldn't bother. 349 unsigned num_squashed = 0; 350 ThreadContext *tc = currState->tc; 351 while ((num_squashed < numSquashable) && currState && 352 (currState->transState->squashed() || te)) { 353 pendingQueue.pop_front(); 354 num_squashed++; 355 356 DPRINTF(TLB, "Squashing table walk for address %#x\n", 357 currState->vaddr_tainted); 358 359 if (currState->transState->squashed()) { 360 // finish the translation which will delete the translation object 361 currState->transState->finish(new UnimpFault("Squashed Inst"), 362 currState->req, currState->tc, currState->mode); 363 } else { 364 // translate the request now that we know it will work 365 tlb->translateTiming(currState->req, currState->tc, 366 currState->transState, currState->mode); 367 368 } 369 370 // delete the current request 371 delete currState; 372 373 // peak at the next one 374 if (pendingQueue.size()) { 375 currState = pendingQueue.front(); 376 te = tlb->lookup(currState->vaddr, currState->asid, 377 currState->vmid, currState->isHyp, currState->isSecure, true, 378 false, target_el); 379 } else { 380 // Terminate the loop, nothing more to do 381 currState = NULL; 382 } 383 } 384 385 // if we've still got pending translations schedule more work 386 nextWalk(tc); 387 currState = NULL; 388 completeDrain(); 389} 390 391Fault 392TableWalker::processWalk() 393{ 394 Addr ttbr = 0; 395 396 // If translation isn't enabled, we shouldn't be here 397 assert(currState->sctlr.m || isStage2); 398 399 DPRINTF(TLB, "Beginning table walk for address %#x, TTBCR: %#x, bits:%#x\n", 400 currState->vaddr_tainted, currState->ttbcr, mbits(currState->vaddr, 31, 401 32 - currState->ttbcr.n)); 402 403 if (currState->ttbcr.n == 0 || !mbits(currState->vaddr, 31, 404 32 - currState->ttbcr.n)) { 405 DPRINTF(TLB, " - Selecting TTBR0\n"); 406 // Check if table walk is allowed when Security Extensions are enabled 407 if (haveSecurity && currState->ttbcr.pd0) { 408 if (currState->isFetch) 409 return new PrefetchAbort(currState->vaddr_tainted, 410 ArmFault::TranslationLL + L1, 411 isStage2, 412 ArmFault::VmsaTran); 413 else 414 return new DataAbort(currState->vaddr_tainted, 415 TlbEntry::DomainType::NoAccess, currState->isWrite, 416 ArmFault::TranslationLL + L1, isStage2, 417 ArmFault::VmsaTran); 418 } 419 ttbr = currState->tc->readMiscReg(flattenMiscRegNsBanked( 420 MISCREG_TTBR0, currState->tc, !currState->isSecure)); 421 } else { 422 DPRINTF(TLB, " - Selecting TTBR1\n"); 423 // Check if table walk is allowed when Security Extensions are enabled 424 if (haveSecurity && currState->ttbcr.pd1) { 425 if (currState->isFetch) 426 return new PrefetchAbort(currState->vaddr_tainted, 427 ArmFault::TranslationLL + L1, 428 isStage2, 429 ArmFault::VmsaTran); 430 else 431 return new DataAbort(currState->vaddr_tainted, 432 TlbEntry::DomainType::NoAccess, currState->isWrite, 433 ArmFault::TranslationLL + L1, isStage2, 434 ArmFault::VmsaTran); 435 } 436 ttbr = currState->tc->readMiscReg(flattenMiscRegNsBanked( 437 MISCREG_TTBR1, currState->tc, !currState->isSecure)); 438 currState->ttbcr.n = 0; 439 } 440 441 Addr l1desc_addr = mbits(ttbr, 31, 14 - currState->ttbcr.n) | 442 (bits(currState->vaddr, 31 - currState->ttbcr.n, 20) << 2); 443 DPRINTF(TLB, " - Descriptor at address %#x (%s)\n", l1desc_addr, 444 currState->isSecure ? "s" : "ns"); 445 446 // Trickbox address check 447 Fault f; 448 f = tlb->walkTrickBoxCheck(l1desc_addr, currState->isSecure, 449 currState->vaddr, sizeof(uint32_t), currState->isFetch, 450 currState->isWrite, TlbEntry::DomainType::NoAccess, L1); 451 if (f) { 452 DPRINTF(TLB, "Trickbox check caused fault on %#x\n", currState->vaddr_tainted); 453 if (currState->timing) { 454 pending = false; 455 nextWalk(currState->tc); 456 currState = NULL; 457 } else { 458 currState->tc = NULL; 459 currState->req = NULL; 460 } 461 return f; 462 } 463 464 Request::Flags flag = 0; 465 if (currState->sctlr.c == 0) { 466 flag = Request::UNCACHEABLE; 467 } 468 469 bool delayed; 470 delayed = fetchDescriptor(l1desc_addr, (uint8_t*)&currState->l1Desc.data, 471 sizeof(uint32_t), flag, L1, &doL1DescEvent, 472 &TableWalker::doL1Descriptor); 473 if (!delayed) { 474 f = currState->fault; 475 } 476 477 return f; 478} 479 480Fault 481TableWalker::processWalkLPAE() 482{ 483 Addr ttbr, ttbr0_max, ttbr1_min, desc_addr; 484 int tsz, n; 485 LookupLevel start_lookup_level = L1; 486 487 DPRINTF(TLB, "Beginning table walk for address %#x, TTBCR: %#x\n", 488 currState->vaddr_tainted, currState->ttbcr); 489 490 Request::Flags flag = 0; 491 if (currState->isSecure) 492 flag.set(Request::SECURE); 493 494 // work out which base address register to use, if in hyp mode we always 495 // use HTTBR 496 if (isStage2) { 497 DPRINTF(TLB, " - Selecting VTTBR (long-desc.)\n"); 498 ttbr = currState->tc->readMiscReg(MISCREG_VTTBR); 499 tsz = sext<4>(currState->vtcr.t0sz); 500 start_lookup_level = currState->vtcr.sl0 ? L1 : L2; 501 } else if (currState->isHyp) { 502 DPRINTF(TLB, " - Selecting HTTBR (long-desc.)\n"); 503 ttbr = currState->tc->readMiscReg(MISCREG_HTTBR); 504 tsz = currState->htcr.t0sz; 505 } else { 506 assert(_haveLPAE && currState->ttbcr.eae); 507 508 // Determine boundaries of TTBR0/1 regions 509 if (currState->ttbcr.t0sz) 510 ttbr0_max = (1ULL << (32 - currState->ttbcr.t0sz)) - 1; 511 else if (currState->ttbcr.t1sz) 512 ttbr0_max = (1ULL << 32) - 513 (1ULL << (32 - currState->ttbcr.t1sz)) - 1; 514 else 515 ttbr0_max = (1ULL << 32) - 1; 516 if (currState->ttbcr.t1sz) 517 ttbr1_min = (1ULL << 32) - (1ULL << (32 - currState->ttbcr.t1sz)); 518 else 519 ttbr1_min = (1ULL << (32 - currState->ttbcr.t0sz)); 520 521 // The following code snippet selects the appropriate translation table base 522 // address (TTBR0 or TTBR1) and the appropriate starting lookup level 523 // depending on the address range supported by the translation table (ARM 524 // ARM issue C B3.6.4) 525 if (currState->vaddr <= ttbr0_max) { 526 DPRINTF(TLB, " - Selecting TTBR0 (long-desc.)\n"); 527 // Check if table walk is allowed 528 if (currState->ttbcr.epd0) { 529 if (currState->isFetch) 530 return new PrefetchAbort(currState->vaddr_tainted, 531 ArmFault::TranslationLL + L1, 532 isStage2, 533 ArmFault::LpaeTran); 534 else 535 return new DataAbort(currState->vaddr_tainted, 536 TlbEntry::DomainType::NoAccess, 537 currState->isWrite, 538 ArmFault::TranslationLL + L1, 539 isStage2, 540 ArmFault::LpaeTran); 541 } 542 ttbr = currState->tc->readMiscReg(flattenMiscRegNsBanked( 543 MISCREG_TTBR0, currState->tc, !currState->isSecure)); 544 tsz = currState->ttbcr.t0sz; 545 if (ttbr0_max < (1ULL << 30)) // Upper limit < 1 GB 546 start_lookup_level = L2; 547 } else if (currState->vaddr >= ttbr1_min) { 548 DPRINTF(TLB, " - Selecting TTBR1 (long-desc.)\n"); 549 // Check if table walk is allowed 550 if (currState->ttbcr.epd1) { 551 if (currState->isFetch) 552 return new PrefetchAbort(currState->vaddr_tainted, 553 ArmFault::TranslationLL + L1, 554 isStage2, 555 ArmFault::LpaeTran); 556 else 557 return new DataAbort(currState->vaddr_tainted, 558 TlbEntry::DomainType::NoAccess, 559 currState->isWrite, 560 ArmFault::TranslationLL + L1, 561 isStage2, 562 ArmFault::LpaeTran); 563 } 564 ttbr = currState->tc->readMiscReg(flattenMiscRegNsBanked( 565 MISCREG_TTBR1, currState->tc, !currState->isSecure)); 566 tsz = currState->ttbcr.t1sz; 567 if (ttbr1_min >= (1ULL << 31) + (1ULL << 30)) // Lower limit >= 3 GB 568 start_lookup_level = L2; 569 } else { 570 // Out of boundaries -> translation fault 571 if (currState->isFetch) 572 return new PrefetchAbort(currState->vaddr_tainted, 573 ArmFault::TranslationLL + L1, 574 isStage2, 575 ArmFault::LpaeTran); 576 else 577 return new DataAbort(currState->vaddr_tainted, 578 TlbEntry::DomainType::NoAccess, 579 currState->isWrite, ArmFault::TranslationLL + L1, 580 isStage2, ArmFault::LpaeTran); 581 } 582 583 } 584 585 // Perform lookup (ARM ARM issue C B3.6.6) 586 if (start_lookup_level == L1) { 587 n = 5 - tsz; 588 desc_addr = mbits(ttbr, 39, n) | 589 (bits(currState->vaddr, n + 26, 30) << 3); 590 DPRINTF(TLB, " - Descriptor at address %#x (%s) (long-desc.)\n", 591 desc_addr, currState->isSecure ? "s" : "ns"); 592 } else { 593 // Skip first-level lookup 594 n = (tsz >= 2 ? 14 - tsz : 12); 595 desc_addr = mbits(ttbr, 39, n) | 596 (bits(currState->vaddr, n + 17, 21) << 3); 597 DPRINTF(TLB, " - Descriptor at address %#x (%s) (long-desc.)\n", 598 desc_addr, currState->isSecure ? "s" : "ns"); 599 } 600 601 // Trickbox address check 602 Fault f = tlb->walkTrickBoxCheck(desc_addr, currState->isSecure, 603 currState->vaddr, sizeof(uint64_t), currState->isFetch, 604 currState->isWrite, TlbEntry::DomainType::NoAccess, 605 start_lookup_level); 606 if (f) { 607 DPRINTF(TLB, "Trickbox check caused fault on %#x\n", currState->vaddr_tainted); 608 if (currState->timing) { 609 pending = false; 610 nextWalk(currState->tc); 611 currState = NULL; 612 } else { 613 currState->tc = NULL; 614 currState->req = NULL; 615 } 616 return f; 617 } 618 619 if (currState->sctlr.c == 0) { 620 flag = Request::UNCACHEABLE; 621 } 622 623 if (currState->isSecure) 624 flag.set(Request::SECURE); 625 626 currState->longDesc.lookupLevel = start_lookup_level; 627 currState->longDesc.aarch64 = false; 628 currState->longDesc.grainSize = Grain4KB; 629 630 Event *event = start_lookup_level == L1 ? (Event *) &doL1LongDescEvent 631 : (Event *) &doL2LongDescEvent; 632 633 bool delayed = fetchDescriptor(desc_addr, (uint8_t*)&currState->longDesc.data, 634 sizeof(uint64_t), flag, start_lookup_level, 635 event, &TableWalker::doLongDescriptor); 636 if (!delayed) { 637 f = currState->fault; 638 } 639 640 return f; 641} 642 643unsigned 644TableWalker::adjustTableSizeAArch64(unsigned tsz) 645{ 646 if (tsz < 25) 647 return 25; 648 if (tsz > 48) 649 return 48; 650 return tsz; 651} 652 653bool 654TableWalker::checkAddrSizeFaultAArch64(Addr addr, int currPhysAddrRange) 655{ 656 return (currPhysAddrRange != MaxPhysAddrRange && 657 bits(addr, MaxPhysAddrRange - 1, currPhysAddrRange)); 658} 659 660Fault 661TableWalker::processWalkAArch64() 662{ 663 assert(currState->aarch64); 664 665 DPRINTF(TLB, "Beginning table walk for address %#llx, TCR: %#llx\n", 666 currState->vaddr_tainted, currState->tcr); 667 668 static const GrainSize GrainMapDefault[] = 669 { Grain4KB, Grain64KB, Grain16KB, ReservedGrain }; 670 static const GrainSize GrainMap_EL1_tg1[] = 671 { ReservedGrain, Grain16KB, Grain4KB, Grain64KB }; 672 673 // Determine TTBR, table size, granule size and phys. address range 674 Addr ttbr = 0; 675 int tsz = 0, ps = 0; 676 GrainSize tg = Grain4KB; // grain size computed from tg* field 677 bool fault = false; 678 switch (currState->el) { 679 case EL0: 680 case EL1: 681 switch (bits(currState->vaddr, 63,48)) { 682 case 0: 683 DPRINTF(TLB, " - Selecting TTBR0 (AArch64)\n"); 684 ttbr = currState->tc->readMiscReg(MISCREG_TTBR0_EL1); 685 tsz = adjustTableSizeAArch64(64 - currState->tcr.t0sz); 686 tg = GrainMapDefault[currState->tcr.tg0]; 687 if (bits(currState->vaddr, 63, tsz) != 0x0 || 688 currState->tcr.epd0) 689 fault = true; 690 break; 691 case 0xffff: 692 DPRINTF(TLB, " - Selecting TTBR1 (AArch64)\n"); 693 ttbr = currState->tc->readMiscReg(MISCREG_TTBR1_EL1); 694 tsz = adjustTableSizeAArch64(64 - currState->tcr.t1sz); 695 tg = GrainMap_EL1_tg1[currState->tcr.tg1]; 696 if (bits(currState->vaddr, 63, tsz) != mask(64-tsz) || 697 currState->tcr.epd1) 698 fault = true; 699 break; 700 default: 701 // top two bytes must be all 0s or all 1s, else invalid addr 702 fault = true; 703 } 704 ps = currState->tcr.ips; 705 break; 706 case EL2: 707 case EL3: 708 switch(bits(currState->vaddr, 63,48)) { 709 case 0: 710 DPRINTF(TLB, " - Selecting TTBR0 (AArch64)\n"); 711 if (currState->el == EL2) 712 ttbr = currState->tc->readMiscReg(MISCREG_TTBR0_EL2); 713 else 714 ttbr = currState->tc->readMiscReg(MISCREG_TTBR0_EL3); 715 tsz = adjustTableSizeAArch64(64 - currState->tcr.t0sz); 716 tg = GrainMapDefault[currState->tcr.tg0]; 717 break; 718 default: 719 // invalid addr if top two bytes are not all 0s 720 fault = true; 721 } 722 ps = currState->tcr.ips; 723 break; 724 } 725 726 if (fault) { 727 Fault f; 728 if (currState->isFetch) 729 f = new PrefetchAbort(currState->vaddr_tainted, 730 ArmFault::TranslationLL + L0, isStage2, 731 ArmFault::LpaeTran); 732 else 733 f = new DataAbort(currState->vaddr_tainted, 734 TlbEntry::DomainType::NoAccess, 735 currState->isWrite, 736 ArmFault::TranslationLL + L0, 737 isStage2, ArmFault::LpaeTran); 738 739 if (currState->timing) { 740 pending = false; 741 nextWalk(currState->tc); 742 currState = NULL; 743 } else { 744 currState->tc = NULL; 745 currState->req = NULL; 746 } 747 return f; 748 749 } 750 751 if (tg == ReservedGrain) { 752 warn_once("Reserved granule size requested; gem5's IMPLEMENTATION " 753 "DEFINED behavior takes this to mean 4KB granules\n"); 754 tg = Grain4KB; 755 } 756 757 int stride = tg - 3; 758 LookupLevel start_lookup_level = MAX_LOOKUP_LEVELS; 759 760 // Determine starting lookup level 761 // See aarch64/translation/walk in Appendix G: ARMv8 Pseudocode Library 762 // in ARM DDI 0487A. These table values correspond to the cascading tests 763 // to compute the lookup level and are of the form 764 // (grain_size + N*stride), for N = {1, 2, 3}. 765 // A value of 64 will never succeed and a value of 0 will always succeed. 766 { 767 struct GrainMap { 768 GrainSize grain_size; 769 unsigned lookup_level_cutoff[MAX_LOOKUP_LEVELS]; 770 }; 771 static const GrainMap GM[] = { 772 { Grain4KB, { 39, 30, 0, 0 } }, 773 { Grain16KB, { 47, 36, 25, 0 } }, 774 { Grain64KB, { 64, 42, 29, 0 } } 775 }; 776 777 const unsigned *lookup = NULL; // points to a lookup_level_cutoff 778 779 for (unsigned i = 0; i < 3; ++i) { // choose entry of GM[] 780 if (tg == GM[i].grain_size) { 781 lookup = GM[i].lookup_level_cutoff; 782 break; 783 } 784 } 785 assert(lookup); 786 787 for (int L = L0; L != MAX_LOOKUP_LEVELS; ++L) { 788 if (tsz > lookup[L]) { 789 start_lookup_level = (LookupLevel) L; 790 break; 791 } 792 } 793 panic_if(start_lookup_level == MAX_LOOKUP_LEVELS, 794 "Table walker couldn't find lookup level\n"); 795 } 796 797 // Determine table base address 798 int base_addr_lo = 3 + tsz - stride * (3 - start_lookup_level) - tg; 799 Addr base_addr = mbits(ttbr, 47, base_addr_lo); 800 801 // Determine physical address size and raise an Address Size Fault if 802 // necessary 803 int pa_range = decodePhysAddrRange64(ps); 804 // Clamp to lower limit 805 if (pa_range > physAddrRange) 806 currState->physAddrRange = physAddrRange; 807 else 808 currState->physAddrRange = pa_range; 809 if (checkAddrSizeFaultAArch64(base_addr, currState->physAddrRange)) { 810 DPRINTF(TLB, "Address size fault before any lookup\n"); 811 Fault f; 812 if (currState->isFetch) 813 f = new PrefetchAbort(currState->vaddr_tainted, 814 ArmFault::AddressSizeLL + start_lookup_level, 815 isStage2, 816 ArmFault::LpaeTran); 817 else 818 f = new DataAbort(currState->vaddr_tainted, 819 TlbEntry::DomainType::NoAccess, 820 currState->isWrite, 821 ArmFault::AddressSizeLL + start_lookup_level, 822 isStage2, 823 ArmFault::LpaeTran); 824 825 826 if (currState->timing) { 827 pending = false; 828 nextWalk(currState->tc); 829 currState = NULL; 830 } else { 831 currState->tc = NULL; 832 currState->req = NULL; 833 } 834 return f; 835 836 } 837 838 // Determine descriptor address 839 Addr desc_addr = base_addr | 840 (bits(currState->vaddr, tsz - 1, 841 stride * (3 - start_lookup_level) + tg) << 3); 842 843 // Trickbox address check 844 Fault f = tlb->walkTrickBoxCheck(desc_addr, currState->isSecure, 845 currState->vaddr, sizeof(uint64_t), currState->isFetch, 846 currState->isWrite, TlbEntry::DomainType::NoAccess, 847 start_lookup_level); 848 if (f) { 849 DPRINTF(TLB, "Trickbox check caused fault on %#x\n", currState->vaddr_tainted); 850 if (currState->timing) { 851 pending = false; 852 nextWalk(currState->tc); 853 currState = NULL; 854 } else { 855 currState->tc = NULL; 856 currState->req = NULL; 857 } 858 return f; 859 } 860 861 Request::Flags flag = 0; 862 if (currState->sctlr.c == 0) { 863 flag = Request::UNCACHEABLE; 864 } 865 866 currState->longDesc.lookupLevel = start_lookup_level; 867 currState->longDesc.aarch64 = true; 868 currState->longDesc.grainSize = tg; 869 870 if (currState->timing) { 871 Event *event; 872 switch (start_lookup_level) { 873 case L0: 874 event = (Event *) &doL0LongDescEvent; 875 break; 876 case L1: 877 event = (Event *) &doL1LongDescEvent; 878 break; 879 case L2: 880 event = (Event *) &doL2LongDescEvent; 881 break; 882 case L3: 883 event = (Event *) &doL3LongDescEvent; 884 break; 885 default: 886 panic("Invalid table lookup level"); 887 break; 888 } 889 port.dmaAction(MemCmd::ReadReq, desc_addr, sizeof(uint64_t), event, 890 (uint8_t*) &currState->longDesc.data, 891 currState->tc->getCpuPtr()->clockPeriod(), flag); 892 DPRINTF(TLBVerbose, 893 "Adding to walker fifo: queue size before adding: %d\n", 894 stateQueues[start_lookup_level].size()); 895 stateQueues[start_lookup_level].push_back(currState); 896 currState = NULL; 897 } else if (!currState->functional) { 898 port.dmaAction(MemCmd::ReadReq, desc_addr, sizeof(uint64_t), 899 NULL, (uint8_t*) &currState->longDesc.data, 900 currState->tc->getCpuPtr()->clockPeriod(), flag); 901 doLongDescriptor(); 902 f = currState->fault; 903 } else { 904 RequestPtr req = new Request(desc_addr, sizeof(uint64_t), flag, 905 masterId); 906 PacketPtr pkt = new Packet(req, MemCmd::ReadReq); 907 pkt->dataStatic((uint8_t*) &currState->longDesc.data); 908 port.sendFunctional(pkt); 909 doLongDescriptor(); 910 delete req; 911 delete pkt; 912 f = currState->fault; 913 } 914 915 return f; 916} 917 918void 919TableWalker::memAttrs(ThreadContext *tc, TlbEntry &te, SCTLR sctlr, 920 uint8_t texcb, bool s) 921{ 922 // Note: tc and sctlr local variables are hiding tc and sctrl class 923 // variables 924 DPRINTF(TLBVerbose, "memAttrs texcb:%d s:%d\n", texcb, s); 925 te.shareable = false; // default value 926 te.nonCacheable = false; 927 te.outerShareable = false; 928 if (sctlr.tre == 0 || ((sctlr.tre == 1) && (sctlr.m == 0))) { 929 switch(texcb) { 930 case 0: // Stongly-ordered 931 te.nonCacheable = true; 932 te.mtype = TlbEntry::MemoryType::StronglyOrdered; 933 te.shareable = true; 934 te.innerAttrs = 1; 935 te.outerAttrs = 0; 936 break; 937 case 1: // Shareable Device 938 te.nonCacheable = true; 939 te.mtype = TlbEntry::MemoryType::Device; 940 te.shareable = true; 941 te.innerAttrs = 3; 942 te.outerAttrs = 0; 943 break; 944 case 2: // Outer and Inner Write-Through, no Write-Allocate 945 te.mtype = TlbEntry::MemoryType::Normal; 946 te.shareable = s; 947 te.innerAttrs = 6; 948 te.outerAttrs = bits(texcb, 1, 0); 949 break; 950 case 3: // Outer and Inner Write-Back, no Write-Allocate 951 te.mtype = TlbEntry::MemoryType::Normal; 952 te.shareable = s; 953 te.innerAttrs = 7; 954 te.outerAttrs = bits(texcb, 1, 0); 955 break; 956 case 4: // Outer and Inner Non-cacheable 957 te.nonCacheable = true; 958 te.mtype = TlbEntry::MemoryType::Normal; 959 te.shareable = s; 960 te.innerAttrs = 0; 961 te.outerAttrs = bits(texcb, 1, 0); 962 break; 963 case 5: // Reserved 964 panic("Reserved texcb value!\n"); 965 break; 966 case 6: // Implementation Defined 967 panic("Implementation-defined texcb value!\n"); 968 break; 969 case 7: // Outer and Inner Write-Back, Write-Allocate 970 te.mtype = TlbEntry::MemoryType::Normal; 971 te.shareable = s; 972 te.innerAttrs = 5; 973 te.outerAttrs = 1; 974 break; 975 case 8: // Non-shareable Device 976 te.nonCacheable = true; 977 te.mtype = TlbEntry::MemoryType::Device; 978 te.shareable = false; 979 te.innerAttrs = 3; 980 te.outerAttrs = 0; 981 break; 982 case 9 ... 15: // Reserved 983 panic("Reserved texcb value!\n"); 984 break; 985 case 16 ... 31: // Cacheable Memory 986 te.mtype = TlbEntry::MemoryType::Normal; 987 te.shareable = s; 988 if (bits(texcb, 1,0) == 0 || bits(texcb, 3,2) == 0) 989 te.nonCacheable = true; 990 te.innerAttrs = bits(texcb, 1, 0); 991 te.outerAttrs = bits(texcb, 3, 2); 992 break; 993 default: 994 panic("More than 32 states for 5 bits?\n"); 995 } 996 } else { 997 assert(tc); 998 PRRR prrr = tc->readMiscReg(flattenMiscRegNsBanked(MISCREG_PRRR, 999 currState->tc, !currState->isSecure)); 1000 NMRR nmrr = tc->readMiscReg(flattenMiscRegNsBanked(MISCREG_NMRR, 1001 currState->tc, !currState->isSecure)); 1002 DPRINTF(TLBVerbose, "memAttrs PRRR:%08x NMRR:%08x\n", prrr, nmrr); 1003 uint8_t curr_tr = 0, curr_ir = 0, curr_or = 0; 1004 switch(bits(texcb, 2,0)) { 1005 case 0: 1006 curr_tr = prrr.tr0; 1007 curr_ir = nmrr.ir0; 1008 curr_or = nmrr.or0; 1009 te.outerShareable = (prrr.nos0 == 0); 1010 break; 1011 case 1: 1012 curr_tr = prrr.tr1; 1013 curr_ir = nmrr.ir1; 1014 curr_or = nmrr.or1; 1015 te.outerShareable = (prrr.nos1 == 0); 1016 break; 1017 case 2: 1018 curr_tr = prrr.tr2; 1019 curr_ir = nmrr.ir2; 1020 curr_or = nmrr.or2; 1021 te.outerShareable = (prrr.nos2 == 0); 1022 break; 1023 case 3: 1024 curr_tr = prrr.tr3; 1025 curr_ir = nmrr.ir3; 1026 curr_or = nmrr.or3; 1027 te.outerShareable = (prrr.nos3 == 0); 1028 break; 1029 case 4: 1030 curr_tr = prrr.tr4; 1031 curr_ir = nmrr.ir4; 1032 curr_or = nmrr.or4; 1033 te.outerShareable = (prrr.nos4 == 0); 1034 break; 1035 case 5: 1036 curr_tr = prrr.tr5; 1037 curr_ir = nmrr.ir5; 1038 curr_or = nmrr.or5; 1039 te.outerShareable = (prrr.nos5 == 0); 1040 break; 1041 case 6: 1042 panic("Imp defined type\n"); 1043 case 7: 1044 curr_tr = prrr.tr7; 1045 curr_ir = nmrr.ir7; 1046 curr_or = nmrr.or7; 1047 te.outerShareable = (prrr.nos7 == 0); 1048 break; 1049 } 1050 1051 switch(curr_tr) { 1052 case 0: 1053 DPRINTF(TLBVerbose, "StronglyOrdered\n"); 1054 te.mtype = TlbEntry::MemoryType::StronglyOrdered; 1055 te.nonCacheable = true; 1056 te.innerAttrs = 1; 1057 te.outerAttrs = 0; 1058 te.shareable = true; 1059 break; 1060 case 1: 1061 DPRINTF(TLBVerbose, "Device ds1:%d ds0:%d s:%d\n", 1062 prrr.ds1, prrr.ds0, s); 1063 te.mtype = TlbEntry::MemoryType::Device; 1064 te.nonCacheable = true; 1065 te.innerAttrs = 3; 1066 te.outerAttrs = 0; 1067 if (prrr.ds1 && s) 1068 te.shareable = true; 1069 if (prrr.ds0 && !s) 1070 te.shareable = true; 1071 break; 1072 case 2: 1073 DPRINTF(TLBVerbose, "Normal ns1:%d ns0:%d s:%d\n", 1074 prrr.ns1, prrr.ns0, s); 1075 te.mtype = TlbEntry::MemoryType::Normal; 1076 if (prrr.ns1 && s) 1077 te.shareable = true; 1078 if (prrr.ns0 && !s) 1079 te.shareable = true; 1080 break; 1081 case 3: 1082 panic("Reserved type"); 1083 } 1084 1085 if (te.mtype == TlbEntry::MemoryType::Normal){ 1086 switch(curr_ir) { 1087 case 0: 1088 te.nonCacheable = true; 1089 te.innerAttrs = 0; 1090 break; 1091 case 1: 1092 te.innerAttrs = 5; 1093 break; 1094 case 2: 1095 te.innerAttrs = 6; 1096 break; 1097 case 3: 1098 te.innerAttrs = 7; 1099 break; 1100 } 1101 1102 switch(curr_or) { 1103 case 0: 1104 te.nonCacheable = true; 1105 te.outerAttrs = 0; 1106 break; 1107 case 1: 1108 te.outerAttrs = 1; 1109 break; 1110 case 2: 1111 te.outerAttrs = 2; 1112 break; 1113 case 3: 1114 te.outerAttrs = 3; 1115 break; 1116 } 1117 } 1118 } 1119 DPRINTF(TLBVerbose, "memAttrs: shareable: %d, innerAttrs: %d, " 1120 "outerAttrs: %d\n", 1121 te.shareable, te.innerAttrs, te.outerAttrs); 1122 te.setAttributes(false); 1123} 1124 1125void 1126TableWalker::memAttrsLPAE(ThreadContext *tc, TlbEntry &te, 1127 LongDescriptor &lDescriptor) 1128{ 1129 assert(_haveLPAE); 1130 1131 uint8_t attr; 1132 uint8_t sh = lDescriptor.sh(); 1133 // Different format and source of attributes if this is a stage 2 1134 // translation 1135 if (isStage2) { 1136 attr = lDescriptor.memAttr(); 1137 uint8_t attr_3_2 = (attr >> 2) & 0x3; 1138 uint8_t attr_1_0 = attr & 0x3; 1139 1140 DPRINTF(TLBVerbose, "memAttrsLPAE MemAttr:%#x sh:%#x\n", attr, sh); 1141 1142 if (attr_3_2 == 0) { 1143 te.mtype = attr_1_0 == 0 ? TlbEntry::MemoryType::StronglyOrdered 1144 : TlbEntry::MemoryType::Device; 1145 te.outerAttrs = 0; 1146 te.innerAttrs = attr_1_0 == 0 ? 1 : 3; 1147 te.nonCacheable = true; 1148 } else { 1149 te.mtype = TlbEntry::MemoryType::Normal; 1150 te.outerAttrs = attr_3_2 == 1 ? 0 : 1151 attr_3_2 == 2 ? 2 : 1; 1152 te.innerAttrs = attr_1_0 == 1 ? 0 : 1153 attr_1_0 == 2 ? 6 : 5; 1154 te.nonCacheable = (attr_3_2 == 1) || (attr_1_0 == 1); 1155 } 1156 } else { 1157 uint8_t attrIndx = lDescriptor.attrIndx(); 1158 1159 // LPAE always uses remapping of memory attributes, irrespective of the 1160 // value of SCTLR.TRE 1161 int reg = attrIndx & 0x4 ? MISCREG_MAIR1 : MISCREG_MAIR0; 1162 reg = flattenMiscRegNsBanked(reg, currState->tc, !currState->isSecure); 1163 uint32_t mair = currState->tc->readMiscReg(reg); 1164 attr = (mair >> (8 * (attrIndx % 4))) & 0xff; 1165 uint8_t attr_7_4 = bits(attr, 7, 4); 1166 uint8_t attr_3_0 = bits(attr, 3, 0); 1167 DPRINTF(TLBVerbose, "memAttrsLPAE AttrIndx:%#x sh:%#x, attr %#x\n", attrIndx, sh, attr); 1168 1169 // Note: the memory subsystem only cares about the 'cacheable' memory 1170 // attribute. The other attributes are only used to fill the PAR register 1171 // accordingly to provide the illusion of full support 1172 te.nonCacheable = false; 1173 1174 switch (attr_7_4) { 1175 case 0x0: 1176 // Strongly-ordered or Device memory 1177 if (attr_3_0 == 0x0) 1178 te.mtype = TlbEntry::MemoryType::StronglyOrdered; 1179 else if (attr_3_0 == 0x4) 1180 te.mtype = TlbEntry::MemoryType::Device; 1181 else 1182 panic("Unpredictable behavior\n"); 1183 te.nonCacheable = true; 1184 te.outerAttrs = 0; 1185 break; 1186 case 0x4: 1187 // Normal memory, Outer Non-cacheable 1188 te.mtype = TlbEntry::MemoryType::Normal; 1189 te.outerAttrs = 0; 1190 if (attr_3_0 == 0x4) 1191 // Inner Non-cacheable 1192 te.nonCacheable = true; 1193 else if (attr_3_0 < 0x8) 1194 panic("Unpredictable behavior\n"); 1195 break; 1196 case 0x8: 1197 case 0x9: 1198 case 0xa: 1199 case 0xb: 1200 case 0xc: 1201 case 0xd: 1202 case 0xe: 1203 case 0xf: 1204 if (attr_7_4 & 0x4) { 1205 te.outerAttrs = (attr_7_4 & 1) ? 1 : 3; 1206 } else { 1207 te.outerAttrs = 0x2; 1208 } 1209 // Normal memory, Outer Cacheable 1210 te.mtype = TlbEntry::MemoryType::Normal; 1211 if (attr_3_0 != 0x4 && attr_3_0 < 0x8) 1212 panic("Unpredictable behavior\n"); 1213 break; 1214 default: 1215 panic("Unpredictable behavior\n"); 1216 break; 1217 } 1218 1219 switch (attr_3_0) { 1220 case 0x0: 1221 te.innerAttrs = 0x1; 1222 break; 1223 case 0x4: 1224 te.innerAttrs = attr_7_4 == 0 ? 0x3 : 0; 1225 break; 1226 case 0x8: 1227 case 0x9: 1228 case 0xA: 1229 case 0xB: 1230 te.innerAttrs = 6; 1231 break; 1232 case 0xC: 1233 case 0xD: 1234 case 0xE: 1235 case 0xF: 1236 te.innerAttrs = attr_3_0 & 1 ? 0x5 : 0x7; 1237 break; 1238 default: 1239 panic("Unpredictable behavior\n"); 1240 break; 1241 } 1242 } 1243 1244 te.outerShareable = sh == 2; 1245 te.shareable = (sh & 0x2) ? true : false; 1246 te.setAttributes(true); 1247 te.attributes |= (uint64_t) attr << 56; 1248} 1249 1250void 1251TableWalker::memAttrsAArch64(ThreadContext *tc, TlbEntry &te, uint8_t attrIndx, 1252 uint8_t sh) 1253{ 1254 DPRINTF(TLBVerbose, "memAttrsAArch64 AttrIndx:%#x sh:%#x\n", attrIndx, sh); 1255 1256 // Select MAIR 1257 uint64_t mair; 1258 switch (currState->el) { 1259 case EL0: 1260 case EL1: 1261 mair = tc->readMiscReg(MISCREG_MAIR_EL1); 1262 break; 1263 case EL2: 1264 mair = tc->readMiscReg(MISCREG_MAIR_EL2); 1265 break; 1266 case EL3: 1267 mair = tc->readMiscReg(MISCREG_MAIR_EL3); 1268 break; 1269 default: 1270 panic("Invalid exception level"); 1271 break; 1272 } 1273 1274 // Select attributes 1275 uint8_t attr = bits(mair, 8 * attrIndx + 7, 8 * attrIndx); 1276 uint8_t attr_lo = bits(attr, 3, 0); 1277 uint8_t attr_hi = bits(attr, 7, 4); 1278 1279 // Memory type 1280 te.mtype = attr_hi == 0 ? TlbEntry::MemoryType::Device : TlbEntry::MemoryType::Normal; 1281 1282 // Cacheability 1283 te.nonCacheable = false; 1284 if (te.mtype == TlbEntry::MemoryType::Device || // Device memory 1285 attr_hi == 0x8 || // Normal memory, Outer Non-cacheable 1286 attr_lo == 0x8) { // Normal memory, Inner Non-cacheable 1287 te.nonCacheable = true; 1288 } 1289 1290 te.shareable = sh == 2; 1291 te.outerShareable = (sh & 0x2) ? true : false; 1292 // Attributes formatted according to the 64-bit PAR 1293 te.attributes = ((uint64_t) attr << 56) | 1294 (1 << 11) | // LPAE bit 1295 (te.ns << 9) | // NS bit 1296 (sh << 7); 1297} 1298 1299void 1300TableWalker::doL1Descriptor() 1301{ 1302 if (currState->fault != NoFault) { 1303 return; 1304 } 1305 1306 DPRINTF(TLB, "L1 descriptor for %#x is %#x\n", 1307 currState->vaddr_tainted, currState->l1Desc.data); 1308 TlbEntry te; 1309 1310 switch (currState->l1Desc.type()) { 1311 case L1Descriptor::Ignore: 1312 case L1Descriptor::Reserved: 1313 if (!currState->timing) { 1314 currState->tc = NULL; 1315 currState->req = NULL; 1316 } 1317 DPRINTF(TLB, "L1 Descriptor Reserved/Ignore, causing fault\n"); 1318 if (currState->isFetch) 1319 currState->fault = 1320 new PrefetchAbort(currState->vaddr_tainted, 1321 ArmFault::TranslationLL + L1, 1322 isStage2, 1323 ArmFault::VmsaTran); 1324 else 1325 currState->fault = 1326 new DataAbort(currState->vaddr_tainted, 1327 TlbEntry::DomainType::NoAccess, 1328 currState->isWrite, 1329 ArmFault::TranslationLL + L1, isStage2, 1330 ArmFault::VmsaTran); 1331 return; 1332 case L1Descriptor::Section: 1333 if (currState->sctlr.afe && bits(currState->l1Desc.ap(), 0) == 0) { 1334 /** @todo: check sctlr.ha (bit[17]) if Hardware Access Flag is 1335 * enabled if set, do l1.Desc.setAp0() instead of generating 1336 * AccessFlag0 1337 */ 1338 1339 currState->fault = new DataAbort(currState->vaddr_tainted, 1340 currState->l1Desc.domain(), 1341 currState->isWrite, 1342 ArmFault::AccessFlagLL + L1, 1343 isStage2, 1344 ArmFault::VmsaTran); 1345 } 1346 if (currState->l1Desc.supersection()) { 1347 panic("Haven't implemented supersections\n"); 1348 } 1349 insertTableEntry(currState->l1Desc, false); 1350 return; 1351 case L1Descriptor::PageTable: 1352 { 1353 Addr l2desc_addr; 1354 l2desc_addr = currState->l1Desc.l2Addr() | 1355 (bits(currState->vaddr, 19, 12) << 2); 1356 DPRINTF(TLB, "L1 descriptor points to page table at: %#x (%s)\n", 1357 l2desc_addr, currState->isSecure ? "s" : "ns"); 1358 1359 // Trickbox address check 1360 currState->fault = tlb->walkTrickBoxCheck( 1361 l2desc_addr, currState->isSecure, currState->vaddr, 1362 sizeof(uint32_t), currState->isFetch, currState->isWrite, 1363 currState->l1Desc.domain(), L2); 1364 1365 if (currState->fault) { 1366 if (!currState->timing) { 1367 currState->tc = NULL; 1368 currState->req = NULL; 1369 } 1370 return; 1371 } 1372 1373 Request::Flags flag = 0; 1374 if (currState->isSecure) 1375 flag.set(Request::SECURE); 1376 1377 bool delayed; 1378 delayed = fetchDescriptor(l2desc_addr, 1379 (uint8_t*)&currState->l2Desc.data, 1380 sizeof(uint32_t), flag, -1, &doL2DescEvent, 1381 &TableWalker::doL2Descriptor); 1382 if (delayed) { 1383 currState->delayed = true; 1384 } 1385 1386 return; 1387 } 1388 default: 1389 panic("A new type in a 2 bit field?\n"); 1390 } 1391} 1392 1393void 1394TableWalker::doLongDescriptor() 1395{ 1396 if (currState->fault != NoFault) { 1397 return; 1398 } 1399 1400 DPRINTF(TLB, "L%d descriptor for %#llx is %#llx (%s)\n", 1401 currState->longDesc.lookupLevel, currState->vaddr_tainted, 1402 currState->longDesc.data, 1403 currState->aarch64 ? "AArch64" : "long-desc."); 1404 1405 if ((currState->longDesc.type() == LongDescriptor::Block) || 1406 (currState->longDesc.type() == LongDescriptor::Page)) { 1407 DPRINTF(TLBVerbose, "Analyzing L%d descriptor: %#llx, pxn: %d, " 1408 "xn: %d, ap: %d, af: %d, type: %d\n", 1409 currState->longDesc.lookupLevel, 1410 currState->longDesc.data, 1411 currState->longDesc.pxn(), 1412 currState->longDesc.xn(), 1413 currState->longDesc.ap(), 1414 currState->longDesc.af(), 1415 currState->longDesc.type()); 1416 } else { 1417 DPRINTF(TLBVerbose, "Analyzing L%d descriptor: %#llx, type: %d\n", 1418 currState->longDesc.lookupLevel, 1419 currState->longDesc.data, 1420 currState->longDesc.type()); 1421 } 1422 1423 TlbEntry te; 1424 1425 switch (currState->longDesc.type()) { 1426 case LongDescriptor::Invalid: 1427 if (!currState->timing) { 1428 currState->tc = NULL; 1429 currState->req = NULL; 1430 } 1431 1432 DPRINTF(TLB, "L%d descriptor Invalid, causing fault type %d\n", 1433 currState->longDesc.lookupLevel, 1434 ArmFault::TranslationLL + currState->longDesc.lookupLevel); 1435 if (currState->isFetch) 1436 currState->fault = new PrefetchAbort( 1437 currState->vaddr_tainted, 1438 ArmFault::TranslationLL + currState->longDesc.lookupLevel, 1439 isStage2, 1440 ArmFault::LpaeTran); 1441 else 1442 currState->fault = new DataAbort( 1443 currState->vaddr_tainted, 1444 TlbEntry::DomainType::NoAccess, 1445 currState->isWrite, 1446 ArmFault::TranslationLL + currState->longDesc.lookupLevel, 1447 isStage2, 1448 ArmFault::LpaeTran); 1449 return; 1450 case LongDescriptor::Block: 1451 case LongDescriptor::Page: 1452 { 1453 bool fault = false; 1454 bool aff = false; 1455 // Check for address size fault 1456 if (checkAddrSizeFaultAArch64( 1457 mbits(currState->longDesc.data, MaxPhysAddrRange - 1, 1458 currState->longDesc.offsetBits()), 1459 currState->physAddrRange)) { 1460 fault = true; 1461 DPRINTF(TLB, "L%d descriptor causing Address Size Fault\n", 1462 currState->longDesc.lookupLevel); 1463 // Check for access fault 1464 } else if (currState->longDesc.af() == 0) { 1465 fault = true; 1466 DPRINTF(TLB, "L%d descriptor causing Access Fault\n", 1467 currState->longDesc.lookupLevel); 1468 aff = true; 1469 } 1470 if (fault) { 1471 if (currState->isFetch) 1472 currState->fault = new PrefetchAbort( 1473 currState->vaddr_tainted, 1474 (aff ? ArmFault::AccessFlagLL : ArmFault::AddressSizeLL) + 1475 currState->longDesc.lookupLevel, 1476 isStage2, 1477 ArmFault::LpaeTran); 1478 else 1479 currState->fault = new DataAbort( 1480 currState->vaddr_tainted, 1481 TlbEntry::DomainType::NoAccess, currState->isWrite, 1482 (aff ? ArmFault::AccessFlagLL : ArmFault::AddressSizeLL) + 1483 currState->longDesc.lookupLevel, 1484 isStage2, 1485 ArmFault::LpaeTran); 1486 } else { 1487 insertTableEntry(currState->longDesc, true); 1488 } 1489 } 1490 return; 1491 case LongDescriptor::Table: 1492 { 1493 // Set hierarchical permission flags 1494 currState->secureLookup = currState->secureLookup && 1495 currState->longDesc.secureTable(); 1496 currState->rwTable = currState->rwTable && 1497 currState->longDesc.rwTable(); 1498 currState->userTable = currState->userTable && 1499 currState->longDesc.userTable(); 1500 currState->xnTable = currState->xnTable || 1501 currState->longDesc.xnTable(); 1502 currState->pxnTable = currState->pxnTable || 1503 currState->longDesc.pxnTable(); 1504 1505 // Set up next level lookup 1506 Addr next_desc_addr = currState->longDesc.nextDescAddr( 1507 currState->vaddr); 1508 1509 DPRINTF(TLB, "L%d descriptor points to L%d descriptor at: %#x (%s)\n", 1510 currState->longDesc.lookupLevel, 1511 currState->longDesc.lookupLevel + 1, 1512 next_desc_addr, 1513 currState->secureLookup ? "s" : "ns"); 1514 1515 // Check for address size fault 1516 if (currState->aarch64 && checkAddrSizeFaultAArch64( 1517 next_desc_addr, currState->physAddrRange)) { 1518 DPRINTF(TLB, "L%d descriptor causing Address Size Fault\n", 1519 currState->longDesc.lookupLevel); 1520 if (currState->isFetch) 1521 currState->fault = new PrefetchAbort( 1522 currState->vaddr_tainted, 1523 ArmFault::AddressSizeLL 1524 + currState->longDesc.lookupLevel, 1525 isStage2, 1526 ArmFault::LpaeTran); 1527 else 1528 currState->fault = new DataAbort( 1529 currState->vaddr_tainted, 1530 TlbEntry::DomainType::NoAccess, currState->isWrite, 1531 ArmFault::AddressSizeLL 1532 + currState->longDesc.lookupLevel, 1533 isStage2, 1534 ArmFault::LpaeTran); 1535 return; 1536 } 1537 1538 // Trickbox address check 1539 currState->fault = tlb->walkTrickBoxCheck( 1540 next_desc_addr, currState->vaddr, 1541 currState->vaddr, sizeof(uint64_t), 1542 currState->isFetch, currState->isWrite, 1543 TlbEntry::DomainType::Client, 1544 toLookupLevel(currState->longDesc.lookupLevel +1)); 1545 1546 if (currState->fault) { 1547 if (!currState->timing) { 1548 currState->tc = NULL; 1549 currState->req = NULL; 1550 } 1551 return; 1552 } 1553 1554 Request::Flags flag = 0; 1555 if (currState->secureLookup) 1556 flag.set(Request::SECURE); 1557 1558 currState->longDesc.lookupLevel = 1559 (LookupLevel) (currState->longDesc.lookupLevel + 1); 1560 Event *event = NULL; 1561 switch (currState->longDesc.lookupLevel) { 1562 case L1: 1563 assert(currState->aarch64); 1564 event = &doL1LongDescEvent; 1565 break; 1566 case L2: 1567 event = &doL2LongDescEvent; 1568 break; 1569 case L3: 1570 event = &doL3LongDescEvent; 1571 break; 1572 default: 1573 panic("Wrong lookup level in table walk\n"); 1574 break; 1575 } 1576 1577 bool delayed; 1578 delayed = fetchDescriptor(next_desc_addr, (uint8_t*)&currState->longDesc.data, 1579 sizeof(uint64_t), flag, -1, event, 1580 &TableWalker::doLongDescriptor); 1581 if (delayed) { 1582 currState->delayed = true; 1583 } 1584 } 1585 return; 1586 default: 1587 panic("A new type in a 2 bit field?\n"); 1588 } 1589} 1590 1591void 1592TableWalker::doL2Descriptor() 1593{ 1594 if (currState->fault != NoFault) { 1595 return; 1596 } 1597 1598 DPRINTF(TLB, "L2 descriptor for %#x is %#x\n", 1599 currState->vaddr_tainted, currState->l2Desc.data); 1600 TlbEntry te; 1601 1602 if (currState->l2Desc.invalid()) { 1603 DPRINTF(TLB, "L2 descriptor invalid, causing fault\n"); 1604 if (!currState->timing) { 1605 currState->tc = NULL; 1606 currState->req = NULL; 1607 } 1608 if (currState->isFetch) 1609 currState->fault = 1610 new PrefetchAbort(currState->vaddr_tainted, 1611 ArmFault::TranslationLL + L2, 1612 isStage2, 1613 ArmFault::VmsaTran); 1614 else 1615 currState->fault = 1616 new DataAbort(currState->vaddr_tainted, currState->l1Desc.domain(), 1617 currState->isWrite, ArmFault::TranslationLL + L2, 1618 isStage2, 1619 ArmFault::VmsaTran); 1620 return; 1621 } 1622 1623 if (currState->sctlr.afe && bits(currState->l2Desc.ap(), 0) == 0) { 1624 /** @todo: check sctlr.ha (bit[17]) if Hardware Access Flag is enabled 1625 * if set, do l2.Desc.setAp0() instead of generating AccessFlag0 1626 */ 1627 DPRINTF(TLB, "Generating access fault at L2, afe: %d, ap: %d\n", 1628 currState->sctlr.afe, currState->l2Desc.ap()); 1629 1630 currState->fault = 1631 new DataAbort(currState->vaddr_tainted, 1632 TlbEntry::DomainType::NoAccess, currState->isWrite, 1633 ArmFault::AccessFlagLL + L2, isStage2, 1634 ArmFault::VmsaTran); 1635 } 1636 1637 insertTableEntry(currState->l2Desc, false); 1638} 1639 1640void 1641TableWalker::doL1DescriptorWrapper() 1642{ 1643 currState = stateQueues[L1].front(); 1644 currState->delayed = false; 1645 // if there's a stage2 translation object we don't need it any more 1646 if (currState->stage2Tran) { 1647 delete currState->stage2Tran; 1648 currState->stage2Tran = NULL; 1649 } 1650 1651 1652 DPRINTF(TLBVerbose, "L1 Desc object host addr: %p\n",&currState->l1Desc.data); 1653 DPRINTF(TLBVerbose, "L1 Desc object data: %08x\n",currState->l1Desc.data); 1654 1655 DPRINTF(TLBVerbose, "calling doL1Descriptor for vaddr:%#x\n", currState->vaddr_tainted); 1656 doL1Descriptor(); 1657 1658 stateQueues[L1].pop_front(); 1659 completeDrain(); 1660 // Check if fault was generated 1661 if (currState->fault != NoFault) { 1662 currState->transState->finish(currState->fault, currState->req, 1663 currState->tc, currState->mode); 1664 1665 pending = false; 1666 nextWalk(currState->tc); 1667 1668 currState->req = NULL; 1669 currState->tc = NULL; 1670 currState->delayed = false; 1671 delete currState; 1672 } 1673 else if (!currState->delayed) { 1674 // delay is not set so there is no L2 to do 1675 // Don't finish the translation if a stage 2 look up is underway 1676 if (!currState->doingStage2) { 1677 DPRINTF(TLBVerbose, "calling translateTiming again\n"); 1678 currState->fault = tlb->translateTiming(currState->req, currState->tc, 1679 currState->transState, currState->mode); 1680 } 1681 1682 pending = false; 1683 nextWalk(currState->tc); 1684 1685 currState->req = NULL; 1686 currState->tc = NULL; 1687 currState->delayed = false; 1688 delete currState; 1689 } else { 1690 // need to do L2 descriptor 1691 stateQueues[L2].push_back(currState); 1692 } 1693 currState = NULL; 1694} 1695 1696void 1697TableWalker::doL2DescriptorWrapper() 1698{ 1699 currState = stateQueues[L2].front(); 1700 assert(currState->delayed); 1701 // if there's a stage2 translation object we don't need it any more 1702 if (currState->stage2Tran) { 1703 delete currState->stage2Tran; 1704 currState->stage2Tran = NULL; 1705 } 1706 1707 DPRINTF(TLBVerbose, "calling doL2Descriptor for vaddr:%#x\n", 1708 currState->vaddr_tainted); 1709 doL2Descriptor(); 1710 1711 // Check if fault was generated 1712 if (currState->fault != NoFault) { 1713 currState->transState->finish(currState->fault, currState->req, 1714 currState->tc, currState->mode); 1715 } 1716 else { 1717 // Don't finish the translation if a stage 2 look up is underway 1718 if (!currState->doingStage2) { 1719 DPRINTF(TLBVerbose, "calling translateTiming again\n"); 1720 currState->fault = tlb->translateTiming(currState->req, 1721 currState->tc, currState->transState, currState->mode); 1722 } 1723 } 1724 1725 1726 stateQueues[L2].pop_front(); 1727 completeDrain(); 1728 pending = false; 1729 nextWalk(currState->tc); 1730 1731 currState->req = NULL; 1732 currState->tc = NULL; 1733 currState->delayed = false; 1734 1735 delete currState; 1736 currState = NULL; 1737} 1738 1739void 1740TableWalker::doL0LongDescriptorWrapper() 1741{ 1742 doLongDescriptorWrapper(L0); 1743} 1744 1745void 1746TableWalker::doL1LongDescriptorWrapper() 1747{ 1748 doLongDescriptorWrapper(L1); 1749} 1750 1751void 1752TableWalker::doL2LongDescriptorWrapper() 1753{ 1754 doLongDescriptorWrapper(L2); 1755} 1756 1757void 1758TableWalker::doL3LongDescriptorWrapper() 1759{ 1760 doLongDescriptorWrapper(L3); 1761} 1762 1763void 1764TableWalker::doLongDescriptorWrapper(LookupLevel curr_lookup_level) 1765{ 1766 currState = stateQueues[curr_lookup_level].front(); 1767 assert(curr_lookup_level == currState->longDesc.lookupLevel); 1768 currState->delayed = false; 1769 1770 // if there's a stage2 translation object we don't need it any more 1771 if (currState->stage2Tran) { 1772 delete currState->stage2Tran; 1773 currState->stage2Tran = NULL; 1774 } 1775 1776 DPRINTF(TLBVerbose, "calling doLongDescriptor for vaddr:%#x\n", 1777 currState->vaddr_tainted); 1778 doLongDescriptor(); 1779 1780 stateQueues[curr_lookup_level].pop_front(); 1781 1782 if (currState->fault != NoFault) { 1783 // A fault was generated 1784 currState->transState->finish(currState->fault, currState->req, 1785 currState->tc, currState->mode); 1786 1787 pending = false; 1788 nextWalk(currState->tc); 1789 1790 currState->req = NULL; 1791 currState->tc = NULL; 1792 currState->delayed = false; 1793 delete currState; 1794 } else if (!currState->delayed) { 1795 // No additional lookups required 1796 // Don't finish the translation if a stage 2 look up is underway 1797 if (!currState->doingStage2) { 1798 DPRINTF(TLBVerbose, "calling translateTiming again\n"); 1799 currState->fault = tlb->translateTiming(currState->req, currState->tc, 1800 currState->transState, 1801 currState->mode); 1802 } 1803 1804 pending = false; 1805 nextWalk(currState->tc); 1806 1807 currState->req = NULL; 1808 currState->tc = NULL; 1809 currState->delayed = false; 1810 delete currState; 1811 } else { 1812 if (curr_lookup_level >= MAX_LOOKUP_LEVELS - 1) 1813 panic("Max. number of lookups already reached in table walk\n"); 1814 // Need to perform additional lookups 1815 stateQueues[currState->longDesc.lookupLevel].push_back(currState); 1816 } 1817 currState = NULL; 1818} 1819 1820 1821void 1822TableWalker::nextWalk(ThreadContext *tc) 1823{ 1824 if (pendingQueue.size()) 1825 schedule(doProcessEvent, clockEdge(Cycles(1))); 1826} 1827 1828bool 1829TableWalker::fetchDescriptor(Addr descAddr, uint8_t *data, int numBytes, 1830 Request::Flags flags, int queueIndex, Event *event, 1831 void (TableWalker::*doDescriptor)()) 1832{ 1833 bool isTiming = currState->timing; 1834 1835 // do the requests for the page table descriptors have to go through the 1836 // second stage MMU 1837 if (currState->stage2Req) { 1838 Fault fault; 1839 flags = flags | TLB::MustBeOne; 1840 1841 if (isTiming) { 1842 Stage2MMU::Stage2Translation *tran = new 1843 Stage2MMU::Stage2Translation(*stage2Mmu, data, event, 1844 currState->vaddr); 1845 currState->stage2Tran = tran; 1846 stage2Mmu->readDataTimed(currState->tc, descAddr, tran, numBytes, 1847 flags, masterId); 1848 fault = tran->fault; 1849 } else { 1850 fault = stage2Mmu->readDataUntimed(currState->tc, 1851 currState->vaddr, descAddr, data, numBytes, flags, masterId, 1852 currState->functional); 1853 } 1854 1855 if (fault != NoFault) { 1856 currState->fault = fault; 1857 } 1858 if (isTiming) { 1859 if (queueIndex >= 0) { 1860 DPRINTF(TLBVerbose, "Adding to walker fifo: queue size before adding: %d\n", 1861 stateQueues[queueIndex].size()); 1862 stateQueues[queueIndex].push_back(currState); 1863 currState = NULL; 1864 } 1865 } else { 1866 (this->*doDescriptor)(); 1867 } 1868 } else { 1869 if (isTiming) { 1870 port.dmaAction(MemCmd::ReadReq, descAddr, numBytes, event, data, 1871 currState->tc->getCpuPtr()->clockPeriod(), flags); 1872 if (queueIndex >= 0) { 1873 DPRINTF(TLBVerbose, "Adding to walker fifo: queue size before adding: %d\n", 1874 stateQueues[queueIndex].size()); 1875 stateQueues[queueIndex].push_back(currState); 1876 currState = NULL; 1877 } 1878 } else if (!currState->functional) { 1879 port.dmaAction(MemCmd::ReadReq, descAddr, numBytes, NULL, data, 1880 currState->tc->getCpuPtr()->clockPeriod(), flags); 1881 (this->*doDescriptor)(); 1882 } else { 1883 RequestPtr req = new Request(descAddr, numBytes, flags, masterId); 1884 req->taskId(ContextSwitchTaskId::DMA); 1885 PacketPtr pkt = new Packet(req, MemCmd::ReadReq); 1886 pkt->dataStatic(data); 1887 port.sendFunctional(pkt); 1888 (this->*doDescriptor)(); 1889 delete req; 1890 delete pkt; 1891 } 1892 } 1893 return (isTiming); 1894} 1895 1896void 1897TableWalker::insertTableEntry(DescriptorBase &descriptor, bool longDescriptor) 1898{ 1899 TlbEntry te; 1900 1901 // Create and fill a new page table entry 1902 te.valid = true; 1903 te.longDescFormat = longDescriptor; 1904 te.isHyp = currState->isHyp; 1905 te.asid = currState->asid; 1906 te.vmid = currState->vmid; 1907 te.N = descriptor.offsetBits(); 1908 te.vpn = currState->vaddr >> te.N; 1909 te.size = (1<<te.N) - 1; 1910 te.pfn = descriptor.pfn(); 1911 te.domain = descriptor.domain(); 1912 te.lookupLevel = descriptor.lookupLevel; 1913 te.ns = !descriptor.secure(haveSecurity, currState) || isStage2; 1914 te.nstid = !currState->isSecure; 1915 te.xn = descriptor.xn(); 1916 if (currState->aarch64) 1917 te.el = currState->el; 1918 else 1919 te.el = 1; 1920 1921 // ASID has no meaning for stage 2 TLB entries, so mark all stage 2 entries 1922 // as global 1923 te.global = descriptor.global(currState) || isStage2; 1924 if (longDescriptor) { 1925 LongDescriptor lDescriptor = 1926 dynamic_cast<LongDescriptor &>(descriptor); 1927 1928 te.xn |= currState->xnTable; 1929 te.pxn = currState->pxnTable || lDescriptor.pxn(); 1930 if (isStage2) { 1931 // this is actually the HAP field, but its stored in the same bit 1932 // possitions as the AP field in a stage 1 translation. 1933 te.hap = lDescriptor.ap(); 1934 } else { 1935 te.ap = ((!currState->rwTable || descriptor.ap() >> 1) << 1) | 1936 (currState->userTable && (descriptor.ap() & 0x1)); 1937 } 1938 if (currState->aarch64) 1939 memAttrsAArch64(currState->tc, te, currState->longDesc.attrIndx(), 1940 currState->longDesc.sh()); 1941 else 1942 memAttrsLPAE(currState->tc, te, lDescriptor); 1943 } else { 1944 te.ap = descriptor.ap(); 1945 memAttrs(currState->tc, te, currState->sctlr, descriptor.texcb(), 1946 descriptor.shareable()); 1947 } 1948 1949 // Debug output 1950 DPRINTF(TLB, descriptor.dbgHeader().c_str()); 1951 DPRINTF(TLB, " - N:%d pfn:%#x size:%#x global:%d valid:%d\n", 1952 te.N, te.pfn, te.size, te.global, te.valid); 1953 DPRINTF(TLB, " - vpn:%#x xn:%d pxn:%d ap:%d domain:%d asid:%d " 1954 "vmid:%d hyp:%d nc:%d ns:%d\n", te.vpn, te.xn, te.pxn, 1955 te.ap, static_cast<uint8_t>(te.domain), te.asid, te.vmid, te.isHyp, 1956 te.nonCacheable, te.ns); 1957 DPRINTF(TLB, " - domain from L%d desc:%d data:%#x\n", 1958 descriptor.lookupLevel, static_cast<uint8_t>(descriptor.domain()), 1959 descriptor.getRawData()); 1960 1961 // Insert the entry into the TLB 1962 tlb->insert(currState->vaddr, te); 1963 if (!currState->timing) { 1964 currState->tc = NULL; 1965 currState->req = NULL; 1966 } 1967} 1968 1969ArmISA::TableWalker * 1970ArmTableWalkerParams::create() 1971{ 1972 return new ArmISA::TableWalker(this); 1973} 1974 1975LookupLevel 1976TableWalker::toLookupLevel(uint8_t lookup_level_as_int) 1977{ 1978 switch (lookup_level_as_int) { 1979 case L1: 1980 return L1; 1981 case L2: 1982 return L2; 1983 case L3: 1984 return L3; 1985 default: 1986 panic("Invalid lookup level conversion"); 1987 } 1988} 1989