pagetable.hh revision 10037
1/* 2 * Copyright (c) 2010, 2012-2013 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) 2002-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 */ 42 43#ifndef __ARCH_ARM_PAGETABLE_H__ 44#define __ARCH_ARM_PAGETABLE_H__ 45 46#include <cstdint> 47 48#include "arch/arm/isa_traits.hh" 49#include "arch/arm/utility.hh" 50#include "arch/arm/vtophys.hh" 51#include "sim/serialize.hh" 52 53namespace ArmISA { 54 55struct VAddr 56{ 57 VAddr(Addr a) { panic("not implemented yet."); } 58}; 59 60 61// ITB/DTB page table entry 62struct PTE 63{ 64 void serialize(std::ostream &os) 65 { 66 panic("Need to implement PTE serialization\n"); 67 } 68 69 void unserialize(Checkpoint *cp, const std::string §ion) 70 { 71 panic("Need to implement PTE serialization\n"); 72 } 73 74}; 75 76// Lookup level 77enum LookupLevel { 78 L0 = 0, // AArch64 only 79 L1, 80 L2, 81 L3, 82 MAX_LOOKUP_LEVELS 83}; 84 85// ITB/DTB table entry 86struct TlbEntry 87{ 88 public: 89 enum class MemoryType : std::uint8_t { 90 StronglyOrdered, 91 Device, 92 Normal 93 }; 94 95 enum class DomainType : std::uint8_t { 96 NoAccess = 0, 97 Client, 98 Reserved, 99 Manager 100 }; 101 102 // Matching variables 103 Addr pfn; 104 Addr size; // Size of this entry, == Type of TLB Rec 105 Addr vpn; // Virtual Page Number 106 uint64_t attributes; // Memory attributes formatted for PAR 107 108 LookupLevel lookupLevel; // Lookup level where the descriptor was fetched 109 // from. Used to set the FSR for faults 110 // occurring while the long desc. format is in 111 // use (AArch32 w/ LPAE and AArch64) 112 113 uint16_t asid; // Address Space Identifier 114 uint8_t vmid; // Virtual machine Identifier 115 uint8_t N; // Number of bits in pagesize 116 uint8_t innerAttrs; 117 uint8_t outerAttrs; 118 uint8_t ap; // Access permissions bits 119 uint8_t hap; // Hyp access permissions bits 120 DomainType domain; // Access Domain 121 122 MemoryType mtype; 123 124 // True if the long descriptor format is used for this entry (LPAE only) 125 bool longDescFormat; // @todo use this in the update attribute bethod 126 127 bool isHyp; 128 bool global; 129 bool valid; 130 131 // True if the entry targets the non-secure physical address space 132 bool ns; 133 // True if the entry was brought in from a non-secure page table 134 bool nstid; 135 // Exception level on insert, AARCH64 EL0&1, AARCH32 -> el=1 136 uint8_t el; 137 138 // Type of memory 139 bool nonCacheable; // Can we wrap this in mtype? 140 141 // Memory Attributes 142 bool shareable; 143 bool outerShareable; 144 145 // Access permissions 146 bool xn; // Execute Never 147 bool pxn; // Privileged Execute Never (LPAE only) 148 149 //Construct an entry that maps to physical address addr for SE mode 150 TlbEntry(Addr _asn, Addr _vaddr, Addr _paddr) : 151 pfn(_paddr >> PageShift), size(PageBytes - 1), vpn(_vaddr >> PageShift), 152 attributes(0), lookupLevel(L1), asid(_asn), vmid(0), N(0), 153 innerAttrs(0), outerAttrs(0), ap(0), hap(0x3), 154 domain(DomainType::Client), mtype(MemoryType::StronglyOrdered), 155 longDescFormat(false), isHyp(false), global(false), valid(true), 156 ns(true), nstid(true), el(0), nonCacheable(false), shareable(false), 157 outerShareable(false), xn(0), pxn(0) 158 { 159 // no restrictions by default, hap = 0x3 160 161 // @todo Check the memory type 162 } 163 164 TlbEntry() : 165 pfn(0), size(0), vpn(0), attributes(0), lookupLevel(L1), asid(0), 166 vmid(0), N(0), innerAttrs(0), outerAttrs(0), ap(0), hap(0x3), 167 domain(DomainType::Client), mtype(MemoryType::StronglyOrdered), 168 longDescFormat(false), isHyp(false), global(false), valid(true), 169 ns(true), nstid(true), el(0), nonCacheable(false), 170 shareable(false), outerShareable(false), xn(0), pxn(0) 171 { 172 // no restrictions by default, hap = 0x3 173 174 // @todo Check the memory type 175 } 176 177 void 178 updateVaddr(Addr new_vaddr) 179 { 180 vpn = new_vaddr >> PageShift; 181 } 182 183 Addr 184 pageStart() const 185 { 186 return pfn << PageShift; 187 } 188 189 bool 190 match(Addr va, uint8_t _vmid, bool hypLookUp, bool secure_lookup, 191 uint8_t target_el) const 192 { 193 return match(va, 0, _vmid, hypLookUp, secure_lookup, true, target_el); 194 } 195 196 bool 197 match(Addr va, uint16_t asn, uint8_t _vmid, bool hypLookUp, 198 bool secure_lookup, bool ignore_asn, uint8_t target_el) const 199 { 200 bool match = false; 201 Addr v = vpn << N; 202 203 if (valid && va >= v && va <= v + size && (secure_lookup == !nstid) && 204 (hypLookUp == isHyp)) 205 { 206 if (target_el == 2 || target_el == 3) 207 match = (el == target_el); 208 else 209 match = (el == 0) || (el == 1); 210 if (match && !ignore_asn) { 211 match = global || (asn == asid); 212 } 213 if (match && nstid) { 214 match = isHyp || (_vmid == vmid); 215 } 216 } 217 return match; 218 } 219 220 Addr 221 pAddr(Addr va) const 222 { 223 return (pfn << N) | (va & size); 224 } 225 226 void 227 updateAttributes() 228 { 229 uint64_t mask; 230 uint64_t newBits; 231 232 // chec bit 11 to determine if its currently LPAE or VMSA format. 233 if ( attributes & (1 << 11) ) { 234 newBits = ((outerShareable ? 0x2 : 235 shareable ? 0x3 : 0) << 7); 236 mask = 0x180; 237 } else { 238 /** Formatting for Physical Address Register (PAR) 239 * Only including lower bits (TLB info here) 240 * PAR (32-bit format): 241 * PA [31:12] 242 * LPAE [11] (Large Physical Address Extension) 243 * TLB info [10:1] 244 * NOS [10] (Not Outer Sharable) 245 * NS [9] (Non-Secure) 246 * -- [8] (Implementation Defined) 247 * SH [7] (Sharable) 248 * Inner[6:4](Inner memory attributes) 249 * Outer[3:2](Outer memory attributes) 250 * SS [1] (SuperSection) 251 * F [0] (Fault, Fault Status in [6:1] if faulted) 252 */ 253 newBits = ((outerShareable ? 0:1) << 10) | 254 ((shareable ? 1:0) << 7) | 255 (innerAttrs << 4) | 256 (outerAttrs << 2); 257 // TODO: Supersection bit 258 mask = 0x4FC; 259 } 260 // common bits 261 newBits |= ns << 9; // NS bit 262 mask |= 1 << 9; 263 // add in the new bits 264 attributes &= ~mask; 265 attributes |= newBits; 266 } 267 268 void 269 setAttributes(bool lpae) 270 { 271 attributes = lpae ? (1 << 11) : 0; 272 updateAttributes(); 273 } 274 275 std::string 276 print() const 277 { 278 return csprintf("%#x, asn %d vmn %d hyp %d ppn %#x size: %#x ap:%d " 279 "ns:%d nstid:%d g:%d el:%d", vpn << N, asid, vmid, 280 isHyp, pfn << N, size, ap, ns, nstid, global, el); 281 } 282 283 void 284 serialize(std::ostream &os) 285 { 286 SERIALIZE_SCALAR(longDescFormat); 287 SERIALIZE_SCALAR(pfn); 288 SERIALIZE_SCALAR(size); 289 SERIALIZE_SCALAR(vpn); 290 SERIALIZE_SCALAR(asid); 291 SERIALIZE_SCALAR(vmid); 292 SERIALIZE_SCALAR(isHyp); 293 SERIALIZE_SCALAR(N); 294 SERIALIZE_SCALAR(global); 295 SERIALIZE_SCALAR(valid); 296 SERIALIZE_SCALAR(ns); 297 SERIALIZE_SCALAR(nstid); 298 SERIALIZE_SCALAR(nonCacheable); 299 SERIALIZE_ENUM(lookupLevel); 300 SERIALIZE_ENUM(mtype); 301 SERIALIZE_SCALAR(innerAttrs); 302 SERIALIZE_SCALAR(outerAttrs); 303 SERIALIZE_SCALAR(shareable); 304 SERIALIZE_SCALAR(outerShareable); 305 SERIALIZE_SCALAR(attributes); 306 SERIALIZE_SCALAR(xn); 307 SERIALIZE_SCALAR(pxn); 308 SERIALIZE_SCALAR(ap); 309 SERIALIZE_SCALAR(hap); 310 uint8_t domain_ = static_cast<uint8_t>(domain); 311 paramOut(os, "domain", domain_); 312 } 313 void 314 unserialize(Checkpoint *cp, const std::string §ion) 315 { 316 UNSERIALIZE_SCALAR(longDescFormat); 317 UNSERIALIZE_SCALAR(pfn); 318 UNSERIALIZE_SCALAR(size); 319 UNSERIALIZE_SCALAR(vpn); 320 UNSERIALIZE_SCALAR(asid); 321 UNSERIALIZE_SCALAR(vmid); 322 UNSERIALIZE_SCALAR(isHyp); 323 UNSERIALIZE_SCALAR(N); 324 UNSERIALIZE_SCALAR(global); 325 UNSERIALIZE_SCALAR(valid); 326 UNSERIALIZE_SCALAR(ns); 327 UNSERIALIZE_SCALAR(nstid); 328 UNSERIALIZE_SCALAR(nonCacheable); 329 UNSERIALIZE_ENUM(lookupLevel); 330 UNSERIALIZE_ENUM(mtype); 331 UNSERIALIZE_SCALAR(innerAttrs); 332 UNSERIALIZE_SCALAR(outerAttrs); 333 UNSERIALIZE_SCALAR(shareable); 334 UNSERIALIZE_SCALAR(outerShareable); 335 UNSERIALIZE_SCALAR(attributes); 336 UNSERIALIZE_SCALAR(xn); 337 UNSERIALIZE_SCALAR(pxn); 338 UNSERIALIZE_SCALAR(ap); 339 UNSERIALIZE_SCALAR(hap); 340 uint8_t domain_; 341 paramIn(cp, section, "domain", domain_); 342 domain = static_cast<DomainType>(domain_); 343 } 344 345}; 346 347 348 349} 350#endif // __ARCH_ARM_PAGETABLE_H__ 351 352