tlb.cc revision 8756:cce8cf3906ca
1/* 2 * Copyright (c) 2010 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) 2001-2005 The Regents of The University of Michigan 15 * All rights reserved. 16 * 17 * Redistribution and use in source and binary forms, with or without 18 * modification, are permitted provided that the following conditions are 19 * met: redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer; 21 * redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution; 24 * neither the name of the copyright holders nor the names of its 25 * contributors may be used to endorse or promote products derived from 26 * this software without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 39 * 40 * Authors: Ali Saidi 41 * Nathan Binkert 42 * Steve Reinhardt 43 */ 44 45#include <string> 46#include <vector> 47 48#include "arch/arm/faults.hh" 49#include "arch/arm/pagetable.hh" 50#include "arch/arm/table_walker.hh" 51#include "arch/arm/tlb.hh" 52#include "arch/arm/utility.hh" 53#include "base/inifile.hh" 54#include "base/str.hh" 55#include "base/trace.hh" 56#include "cpu/thread_context.hh" 57#include "debug/Checkpoint.hh" 58#include "debug/TLB.hh" 59#include "debug/TLBVerbose.hh" 60#include "mem/page_table.hh" 61#include "params/ArmTLB.hh" 62#include "sim/full_system.hh" 63#include "sim/process.hh" 64 65#if FULL_SYSTEM 66#include "arch/arm/system.hh" 67#endif 68 69using namespace std; 70using namespace ArmISA; 71 72TLB::TLB(const Params *p) 73 : BaseTLB(p), size(p->size) , tableWalker(p->walker), 74 rangeMRU(1), bootUncacheability(false), miscRegValid(false) 75{ 76 table = new TlbEntry[size]; 77 memset(table, 0, sizeof(TlbEntry) * size); 78 79 tableWalker->setTlb(this); 80} 81 82TLB::~TLB() 83{ 84 if (table) 85 delete [] table; 86} 87 88bool 89TLB::translateFunctional(ThreadContext *tc, Addr va, Addr &pa) 90{ 91 if (!miscRegValid) 92 updateMiscReg(tc); 93 TlbEntry *e = lookup(va, contextId, true); 94 if (!e) 95 return false; 96 pa = e->pAddr(va); 97 return true; 98} 99 100TlbEntry* 101TLB::lookup(Addr va, uint8_t cid, bool functional) 102{ 103 104 TlbEntry *retval = NULL; 105 106 // Maitaining LRU array 107 108 int x = 0; 109 while (retval == NULL && x < size) { 110 if (table[x].match(va, cid)) { 111 112 // We only move the hit entry ahead when the position is higher than rangeMRU 113 if (x > rangeMRU) { 114 TlbEntry tmp_entry = table[x]; 115 for(int i = x; i > 0; i--) 116 table[i] = table[i-1]; 117 table[0] = tmp_entry; 118 retval = &table[0]; 119 } else { 120 retval = &table[x]; 121 } 122 break; 123 } 124 x++; 125 } 126 127 DPRINTF(TLBVerbose, "Lookup %#x, cid %#x -> %s ppn %#x size: %#x pa: %#x ap:%d\n", 128 va, cid, retval ? "hit" : "miss", retval ? retval->pfn : 0, 129 retval ? retval->size : 0, retval ? retval->pAddr(va) : 0, 130 retval ? retval->ap : 0); 131 ; 132 return retval; 133} 134 135// insert a new TLB entry 136void 137TLB::insert(Addr addr, TlbEntry &entry) 138{ 139 DPRINTF(TLB, "Inserting entry into TLB with pfn:%#x size:%#x vpn: %#x" 140 " asid:%d N:%d global:%d valid:%d nc:%d sNp:%d xn:%d ap:%#x" 141 " domain:%#x\n", entry.pfn, entry.size, entry.vpn, entry.asid, 142 entry.N, entry.global, entry.valid, entry.nonCacheable, entry.sNp, 143 entry.xn, entry.ap, entry.domain); 144 145 if (table[size-1].valid) 146 DPRINTF(TLB, " - Replacing Valid entry %#x, asn %d ppn %#x size: %#x ap:%d\n", 147 table[size-1].vpn << table[size-1].N, table[size-1].asid, 148 table[size-1].pfn << table[size-1].N, table[size-1].size, 149 table[size-1].ap); 150 151 //inserting to MRU position and evicting the LRU one 152 153 for(int i = size-1; i > 0; i--) 154 table[i] = table[i-1]; 155 table[0] = entry; 156 157 inserts++; 158} 159 160void 161TLB::printTlb() 162{ 163 int x = 0; 164 TlbEntry *te; 165 DPRINTF(TLB, "Current TLB contents:\n"); 166 while (x < size) { 167 te = &table[x]; 168 if (te->valid) 169 DPRINTF(TLB, " * %#x, asn %d ppn %#x size: %#x ap:%d\n", 170 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap); 171 x++; 172 } 173} 174 175 176void 177TLB::flushAll() 178{ 179 DPRINTF(TLB, "Flushing all TLB entries\n"); 180 int x = 0; 181 TlbEntry *te; 182 while (x < size) { 183 te = &table[x]; 184 if (te->valid) { 185 DPRINTF(TLB, " - %#x, asn %d ppn %#x size: %#x ap:%d\n", 186 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap); 187 flushedEntries++; 188 } 189 x++; 190 } 191 192 memset(table, 0, sizeof(TlbEntry) * size); 193 194 flushTlb++; 195} 196 197 198void 199TLB::flushMvaAsid(Addr mva, uint64_t asn) 200{ 201 DPRINTF(TLB, "Flushing mva %#x asid: %#x\n", mva, asn); 202 TlbEntry *te; 203 204 te = lookup(mva, asn); 205 while (te != NULL) { 206 DPRINTF(TLB, " - %#x, asn %d ppn %#x size: %#x ap:%d\n", 207 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap); 208 te->valid = false; 209 flushedEntries++; 210 te = lookup(mva,asn); 211 } 212 flushTlbMvaAsid++; 213} 214 215void 216TLB::flushAsid(uint64_t asn) 217{ 218 DPRINTF(TLB, "Flushing all entries with asid: %#x\n", asn); 219 220 int x = 0; 221 TlbEntry *te; 222 223 while (x < size) { 224 te = &table[x]; 225 if (te->asid == asn) { 226 te->valid = false; 227 DPRINTF(TLB, " - %#x, asn %d ppn %#x size: %#x ap:%d\n", 228 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap); 229 flushedEntries++; 230 } 231 x++; 232 } 233 flushTlbAsid++; 234} 235 236void 237TLB::flushMva(Addr mva) 238{ 239 DPRINTF(TLB, "Flushing all entries with mva: %#x\n", mva); 240 241 int x = 0; 242 TlbEntry *te; 243 244 while (x < size) { 245 te = &table[x]; 246 Addr v = te->vpn << te->N; 247 if (mva >= v && mva < v + te->size) { 248 te->valid = false; 249 DPRINTF(TLB, " - %#x, asn %d ppn %#x size: %#x ap:%d\n", 250 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap); 251 flushedEntries++; 252 } 253 x++; 254 } 255 flushTlbMva++; 256} 257 258void 259TLB::serialize(ostream &os) 260{ 261 DPRINTF(Checkpoint, "Serializing Arm TLB\n"); 262 263 SERIALIZE_SCALAR(_attr); 264 265 int num_entries = size; 266 SERIALIZE_SCALAR(num_entries); 267 for(int i = 0; i < size; i++){ 268 nameOut(os, csprintf("%s.TlbEntry%d", name(), i)); 269 table[i].serialize(os); 270 } 271} 272 273void 274TLB::unserialize(Checkpoint *cp, const string §ion) 275{ 276 DPRINTF(Checkpoint, "Unserializing Arm TLB\n"); 277 278 UNSERIALIZE_SCALAR(_attr); 279 int num_entries; 280 UNSERIALIZE_SCALAR(num_entries); 281 for(int i = 0; i < min(size, num_entries); i++){ 282 table[i].unserialize(cp, csprintf("%s.TlbEntry%d", section, i)); 283 } 284 miscRegValid = false; 285} 286 287void 288TLB::regStats() 289{ 290 instHits 291 .name(name() + ".inst_hits") 292 .desc("ITB inst hits") 293 ; 294 295 instMisses 296 .name(name() + ".inst_misses") 297 .desc("ITB inst misses") 298 ; 299 300 instAccesses 301 .name(name() + ".inst_accesses") 302 .desc("ITB inst accesses") 303 ; 304 305 readHits 306 .name(name() + ".read_hits") 307 .desc("DTB read hits") 308 ; 309 310 readMisses 311 .name(name() + ".read_misses") 312 .desc("DTB read misses") 313 ; 314 315 readAccesses 316 .name(name() + ".read_accesses") 317 .desc("DTB read accesses") 318 ; 319 320 writeHits 321 .name(name() + ".write_hits") 322 .desc("DTB write hits") 323 ; 324 325 writeMisses 326 .name(name() + ".write_misses") 327 .desc("DTB write misses") 328 ; 329 330 writeAccesses 331 .name(name() + ".write_accesses") 332 .desc("DTB write accesses") 333 ; 334 335 hits 336 .name(name() + ".hits") 337 .desc("DTB hits") 338 ; 339 340 misses 341 .name(name() + ".misses") 342 .desc("DTB misses") 343 ; 344 345 accesses 346 .name(name() + ".accesses") 347 .desc("DTB accesses") 348 ; 349 350 flushTlb 351 .name(name() + ".flush_tlb") 352 .desc("Number of times complete TLB was flushed") 353 ; 354 355 flushTlbMva 356 .name(name() + ".flush_tlb_mva") 357 .desc("Number of times TLB was flushed by MVA") 358 ; 359 360 flushTlbMvaAsid 361 .name(name() + ".flush_tlb_mva_asid") 362 .desc("Number of times TLB was flushed by MVA & ASID") 363 ; 364 365 flushTlbAsid 366 .name(name() + ".flush_tlb_asid") 367 .desc("Number of times TLB was flushed by ASID") 368 ; 369 370 flushedEntries 371 .name(name() + ".flush_entries") 372 .desc("Number of entries that have been flushed from TLB") 373 ; 374 375 alignFaults 376 .name(name() + ".align_faults") 377 .desc("Number of TLB faults due to alignment restrictions") 378 ; 379 380 prefetchFaults 381 .name(name() + ".prefetch_faults") 382 .desc("Number of TLB faults due to prefetch") 383 ; 384 385 domainFaults 386 .name(name() + ".domain_faults") 387 .desc("Number of TLB faults due to domain restrictions") 388 ; 389 390 permsFaults 391 .name(name() + ".perms_faults") 392 .desc("Number of TLB faults due to permissions restrictions") 393 ; 394 395 instAccesses = instHits + instMisses; 396 readAccesses = readHits + readMisses; 397 writeAccesses = writeHits + writeMisses; 398 hits = readHits + writeHits + instHits; 399 misses = readMisses + writeMisses + instMisses; 400 accesses = readAccesses + writeAccesses + instAccesses; 401} 402 403Fault 404TLB::translateSe(RequestPtr req, ThreadContext *tc, Mode mode, 405 Translation *translation, bool &delay, bool timing) 406{ 407 if (!miscRegValid) 408 updateMiscReg(tc); 409 Addr vaddr = req->getVaddr(); 410 uint32_t flags = req->getFlags(); 411 412 bool is_fetch = (mode == Execute); 413 bool is_write = (mode == Write); 414 415 if (!is_fetch) { 416 assert(flags & MustBeOne); 417 if (sctlr.a || !(flags & AllowUnaligned)) { 418 if (vaddr & flags & AlignmentMask) { 419 return new DataAbort(vaddr, 0, is_write, ArmFault::AlignmentFault); 420 } 421 } 422 } 423 424#if !FULL_SYSTEM 425 Addr paddr; 426 Process *p = tc->getProcessPtr(); 427 428 if (!p->pTable->translate(vaddr, paddr)) 429 return Fault(new GenericPageTableFault(vaddr)); 430 req->setPaddr(paddr); 431#endif 432 433 return NoFault; 434} 435 436Fault 437TLB::trickBoxCheck(RequestPtr req, Mode mode, uint8_t domain, bool sNp) 438{ 439 return NoFault; 440} 441 442Fault 443TLB::walkTrickBoxCheck(Addr pa, Addr va, Addr sz, bool is_exec, 444 bool is_write, uint8_t domain, bool sNp) 445{ 446 return NoFault; 447} 448 449Fault 450TLB::translateFs(RequestPtr req, ThreadContext *tc, Mode mode, 451 Translation *translation, bool &delay, bool timing) 452{ 453 if (!miscRegValid) { 454 updateMiscReg(tc); 455 DPRINTF(TLBVerbose, "TLB variables changed!\n"); 456 } 457 458 Addr vaddr = req->getVaddr(); 459 uint32_t flags = req->getFlags(); 460 461 bool is_fetch = (mode == Execute); 462 bool is_write = (mode == Write); 463 bool is_priv = isPriv && !(flags & UserMode); 464 465 req->setAsid(contextId.asid); 466 467 DPRINTF(TLBVerbose, "CPSR is priv:%d UserMode:%d\n", 468 isPriv, flags & UserMode); 469 // If this is a clrex instruction, provide a PA of 0 with no fault 470 // This will force the monitor to set the tracked address to 0 471 // a bit of a hack but this effectively clrears this processors monitor 472 if (flags & Request::CLEAR_LL){ 473 req->setPaddr(0); 474 req->setFlags(Request::UNCACHEABLE); 475 req->setFlags(Request::CLEAR_LL); 476 return NoFault; 477 } 478 if ((req->isInstFetch() && (!sctlr.i)) || 479 ((!req->isInstFetch()) && (!sctlr.c))){ 480 req->setFlags(Request::UNCACHEABLE); 481 } 482 if (!is_fetch) { 483 assert(flags & MustBeOne); 484 if (sctlr.a || !(flags & AllowUnaligned)) { 485 if (vaddr & flags & AlignmentMask) { 486 alignFaults++; 487 return new DataAbort(vaddr, 0, is_write, ArmFault::AlignmentFault); 488 } 489 } 490 } 491 492 Fault fault; 493 494 if (!sctlr.m) { 495 req->setPaddr(vaddr); 496 if (sctlr.tre == 0) { 497 req->setFlags(Request::UNCACHEABLE); 498 } else { 499 if (nmrr.ir0 == 0 || nmrr.or0 == 0 || prrr.tr0 != 0x2) 500 req->setFlags(Request::UNCACHEABLE); 501 } 502 503 // Set memory attributes 504 TlbEntry temp_te; 505 tableWalker->memAttrs(tc, temp_te, sctlr, 0, 1); 506 temp_te.shareable = true; 507 DPRINTF(TLBVerbose, "(No MMU) setting memory attributes: shareable:\ 508 %d, innerAttrs: %d, outerAttrs: %d\n", temp_te.shareable, 509 temp_te.innerAttrs, temp_te.outerAttrs); 510 setAttr(temp_te.attributes); 511 512 return trickBoxCheck(req, mode, 0, false); 513 } 514 515 DPRINTF(TLBVerbose, "Translating vaddr=%#x context=%d\n", vaddr, contextId); 516 // Translation enabled 517 518 TlbEntry *te = lookup(vaddr, contextId); 519 if (te == NULL) { 520 if (req->isPrefetch()){ 521 //if the request is a prefetch don't attempt to fill the TLB 522 //or go any further with the memory access 523 prefetchFaults++; 524 return new PrefetchAbort(vaddr, ArmFault::PrefetchTLBMiss); 525 } 526 527 if (is_fetch) 528 instMisses++; 529 else if (is_write) 530 writeMisses++; 531 else 532 readMisses++; 533 534 // start translation table walk, pass variables rather than 535 // re-retreaving in table walker for speed 536 DPRINTF(TLB, "TLB Miss: Starting hardware table walker for %#x(%d)\n", 537 vaddr, contextId); 538 fault = tableWalker->walk(req, tc, contextId, mode, translation, 539 timing); 540 if (timing && fault == NoFault) { 541 delay = true; 542 // for timing mode, return and wait for table walk 543 return fault; 544 } 545 if (fault) 546 return fault; 547 548 te = lookup(vaddr, contextId); 549 if (!te) 550 printTlb(); 551 assert(te); 552 } else { 553 if (is_fetch) 554 instHits++; 555 else if (is_write) 556 writeHits++; 557 else 558 readHits++; 559 } 560 561 // Set memory attributes 562 DPRINTF(TLBVerbose, 563 "Setting memory attributes: shareable: %d, innerAttrs: %d, \ 564 outerAttrs: %d\n", 565 te->shareable, te->innerAttrs, te->outerAttrs); 566 setAttr(te->attributes); 567 if (te->nonCacheable) { 568 req->setFlags(Request::UNCACHEABLE); 569 570 // Prevent prefetching from I/O devices. 571 if (req->isPrefetch()) { 572 return new PrefetchAbort(vaddr, ArmFault::PrefetchUncacheable); 573 } 574 } 575 576#if FULL_SYSTEM 577 if (!bootUncacheability && 578 ((ArmSystem*)tc->getSystemPtr())->adderBootUncacheable(vaddr)) 579 req->setFlags(Request::UNCACHEABLE); 580#endif 581 582 switch ( (dacr >> (te->domain * 2)) & 0x3) { 583 case 0: 584 domainFaults++; 585 DPRINTF(TLB, "TLB Fault: Data abort on domain. DACR: %#x domain: %#x" 586 " write:%d sNp:%d\n", dacr, te->domain, is_write, te->sNp); 587 if (is_fetch) 588 return new PrefetchAbort(vaddr, 589 (te->sNp ? ArmFault::Domain0 : ArmFault::Domain1)); 590 else 591 return new DataAbort(vaddr, te->domain, is_write, 592 (te->sNp ? ArmFault::Domain0 : ArmFault::Domain1)); 593 case 1: 594 // Continue with permissions check 595 break; 596 case 2: 597 panic("UNPRED domain\n"); 598 case 3: 599 req->setPaddr(te->pAddr(vaddr)); 600 fault = trickBoxCheck(req, mode, te->domain, te->sNp); 601 if (fault) 602 return fault; 603 return NoFault; 604 } 605 606 uint8_t ap = te->ap; 607 608 if (sctlr.afe == 1) 609 ap |= 1; 610 611 bool abt; 612 613 /* if (!sctlr.xp) 614 ap &= 0x3; 615*/ 616 switch (ap) { 617 case 0: 618 DPRINTF(TLB, "Access permissions 0, checking rs:%#x\n", (int)sctlr.rs); 619 if (!sctlr.xp) { 620 switch ((int)sctlr.rs) { 621 case 2: 622 abt = is_write; 623 break; 624 case 1: 625 abt = is_write || !is_priv; 626 break; 627 case 0: 628 case 3: 629 default: 630 abt = true; 631 break; 632 } 633 } else { 634 abt = true; 635 } 636 break; 637 case 1: 638 abt = !is_priv; 639 break; 640 case 2: 641 abt = !is_priv && is_write; 642 break; 643 case 3: 644 abt = false; 645 break; 646 case 4: 647 panic("UNPRED premissions\n"); 648 case 5: 649 abt = !is_priv || is_write; 650 break; 651 case 6: 652 case 7: 653 abt = is_write; 654 break; 655 default: 656 panic("Unknown permissions\n"); 657 } 658 if ((is_fetch) && (abt || te->xn)) { 659 permsFaults++; 660 DPRINTF(TLB, "TLB Fault: Prefetch abort on permission check. AP:%d priv:%d" 661 " write:%d sNp:%d\n", ap, is_priv, is_write, te->sNp); 662 return new PrefetchAbort(vaddr, 663 (te->sNp ? ArmFault::Permission0 : 664 ArmFault::Permission1)); 665 } else if (abt) { 666 permsFaults++; 667 DPRINTF(TLB, "TLB Fault: Data abort on permission check. AP:%d priv:%d" 668 " write:%d sNp:%d\n", ap, is_priv, is_write, te->sNp); 669 return new DataAbort(vaddr, te->domain, is_write, 670 (te->sNp ? ArmFault::Permission0 : 671 ArmFault::Permission1)); 672 } 673 674 req->setPaddr(te->pAddr(vaddr)); 675 // Check for a trickbox generated address fault 676 fault = trickBoxCheck(req, mode, te->domain, te->sNp); 677 if (fault) 678 return fault; 679 680 return NoFault; 681} 682 683Fault 684TLB::translateAtomic(RequestPtr req, ThreadContext *tc, Mode mode) 685{ 686 bool delay = false; 687 Fault fault; 688 if (FullSystem) 689 fault = translateFs(req, tc, mode, NULL, delay, false); 690 else 691 fault = translateSe(req, tc, mode, NULL, delay, false); 692 assert(!delay); 693 return fault; 694} 695 696Fault 697TLB::translateTiming(RequestPtr req, ThreadContext *tc, 698 Translation *translation, Mode mode) 699{ 700 assert(translation); 701 bool delay = false; 702 Fault fault; 703 if (FullSystem) 704 fault = translateFs(req, tc, mode, translation, delay, true); 705 else 706 fault = translateSe(req, tc, mode, translation, delay, true); 707 DPRINTF(TLBVerbose, "Translation returning delay=%d fault=%d\n", delay, fault != 708 NoFault); 709 if (!delay) 710 translation->finish(fault, req, tc, mode); 711 else 712 translation->markDelayed(); 713 return fault; 714} 715 716Port* 717TLB::getPort() 718{ 719 return tableWalker->getPort("port"); 720} 721 722 723 724ArmISA::TLB * 725ArmTLBParams::create() 726{ 727 return new ArmISA::TLB(this); 728} 729