1/*
|
2 * Copyright (c) 2010 ARM Limited
|
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:
|
78 enum MemoryType {
|
89 enum class MemoryType : std::uint8_t { |
90 StronglyOrdered, 91 Device, 92 Normal 93 };
|
83 enum DomainType {
84 DomainNoAccess = 0,
85 DomainClient,
86 DomainReserved,
87 DomainManager
|
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
|
94 uint32_t asid; // Address Space Identifier
|
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?
|
101 bool sNp; // Section descriptor
|
140 141 // Memory Attributes
|
104 MemoryType mtype;
105 uint8_t innerAttrs;
106 uint8_t outerAttrs;
|
142 bool shareable;
|
108 uint32_t attributes; // Memory attributes formatted for PAR
|
143 bool outerShareable; |
144
|
110
|
145 // Access permissions 146 bool xn; // Execute Never
|
113 uint8_t ap; // Access permissions bits
114 uint8_t domain; // Access Domain
|
147 bool pxn; // Privileged Execute Never (LPAE only) |
148 149 //Construct an entry that maps to physical address addr for SE mode
|
117 TlbEntry(Addr _asn, Addr _vaddr, Addr _paddr)
|
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 {
|
119 pfn = _paddr >> PageShift;
120 size = PageBytes - 1;
121 asid = _asn;
122 global = false;
123 valid = true;
|
159 // no restrictions by default, hap = 0x3 |
160
|
125 vpn = _vaddr >> PageShift;
|
161 // @todo Check the memory type 162 } |
163
|
127 nonCacheable = sNp = false;
|
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
|
129 xn = 0;
130 ap = 0; // ???
131 domain = DomainClient; //???
|
174 // @todo Check the memory type |
175 } 176
|
134 TlbEntry()
135 {}
136
|
177 void 178 updateVaddr(Addr new_vaddr) 179 { 180 vpn = new_vaddr >> PageShift; 181 } 182 183 Addr
|
144 pageStart()
|
184 pageStart() const |
185 { 186 return pfn << PageShift; 187 } 188 189 bool
|
150 match(Addr va, uint8_t cid)
|
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;
|
153 if (valid && va >= v && va <= v + size && (global || cid == asid))
154 return true;
155 return false;
|
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
|
159 pAddr(Addr va)
|
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);
|
175 SERIALIZE_SCALAR(sNp);
|
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);
|
183 SERIALIZE_SCALAR(domain);
|
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);
|
196 UNSERIALIZE_SCALAR(sNp);
|
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);
|
204 UNSERIALIZE_SCALAR(domain);
|
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
|