pagetable_walker.hh revision 7901
1/* 2 * Copyright (c) 2007 The Hewlett-Packard Development Company 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: Gabe Black 38 */ 39 40#ifndef __ARCH_X86_PAGE_TABLE_WALKER_HH__ 41#define __ARCH_X86_PAGE_TABLE_WALKER_HH__ 42 43#include <vector> 44 45#include "arch/x86/pagetable.hh" 46#include "arch/x86/tlb.hh" 47#include "base/types.hh" 48#include "mem/mem_object.hh" 49#include "mem/packet.hh" 50#include "params/X86PagetableWalker.hh" 51#include "sim/faults.hh" 52 53class ThreadContext; 54 55namespace X86ISA 56{ 57 class Walker : public MemObject 58 { 59 public: 60 enum State { 61 Ready, 62 Waiting, 63 // Long mode 64 LongPML4, LongPDP, LongPD, LongPTE, 65 // PAE legacy mode 66 PAEPDP, PAEPD, PAEPTE, 67 // Non PAE legacy mode with and without PSE 68 PSEPD, PD, PTE 69 }; 70 71 // Act on the current state and determine what to do next. The global 72 // read should be the packet that just came back from a read and write 73 // should be NULL. When the function returns, read is either NULL 74 // if the machine is finished, or points to a packet to initiate 75 // the next read. If any write is required to update an "accessed" 76 // bit, write will point to a packet to do the write. Otherwise it 77 // will be NULL. The return value is whatever fault was incurred 78 // during this stage of the lookup. 79 Fault doNext(PacketPtr &write); 80 81 // Kick off the state machine. 82 Fault start(ThreadContext * _tc, BaseTLB::Translation *translation, 83 RequestPtr req, BaseTLB::Mode mode); 84 // Clean up after the state machine. 85 void 86 stop() 87 { 88 nextState = Ready; 89 delete read->req; 90 delete read; 91 read = NULL; 92 } 93 94 protected: 95 96 /* 97 * State having to do with sending packets. 98 */ 99 PacketPtr read; 100 std::vector<PacketPtr> writes; 101 102 // How many memory operations are in flight. 103 unsigned inflight; 104 105 bool retrying; 106 107 /* 108 * The fault, if any, that's waiting to be delivered in timing mode. 109 */ 110 Fault timingFault; 111 112 /* 113 * Functions for dealing with packets. 114 */ 115 bool recvTiming(PacketPtr pkt); 116 void recvRetry(); 117 118 void sendPackets(); 119 120 /* 121 * Port for accessing memory 122 */ 123 class WalkerPort : public Port 124 { 125 public: 126 WalkerPort(const std::string &_name, Walker * _walker) : 127 Port(_name, _walker), walker(_walker), 128 snoopRangeSent(false) 129 {} 130 131 protected: 132 Walker * walker; 133 134 bool snoopRangeSent; 135 136 bool recvTiming(PacketPtr pkt); 137 Tick recvAtomic(PacketPtr pkt); 138 void recvFunctional(PacketPtr pkt); 139 void recvStatusChange(Status status); 140 void recvRetry(); 141 void getDeviceAddressRanges(AddrRangeList &resp, 142 bool &snoop) 143 { 144 resp.clear(); 145 snoop = true; 146 } 147 }; 148 149 Port *getPort(const std::string &if_name, int idx = -1); 150 151 friend class WalkerPort; 152 153 WalkerPort port; 154 155 // The TLB we're supposed to load. 156 TLB * tlb; 157 System * sys; 158 BaseTLB::Translation * translation; 159 160 /* 161 * State machine state. 162 */ 163 ThreadContext * tc; 164 RequestPtr req; 165 State state; 166 State nextState; 167 int size; 168 bool enableNX; 169 BaseTLB::Mode mode; 170 bool user; 171 TlbEntry entry; 172 173 Fault pageFault(bool present); 174 175 public: 176 177 void setTLB(TLB * _tlb) 178 { 179 tlb = _tlb; 180 } 181 182 typedef X86PagetableWalkerParams Params; 183 184 Walker(const Params *params) : 185 MemObject(params), 186 read(NULL), inflight(0), retrying(false), 187 port(name() + ".port", this), 188 tlb(NULL), sys(params->system), 189 tc(NULL), state(Ready), nextState(Ready) 190 { 191 } 192 }; 193} 194#endif // __ARCH_X86_PAGE_TABLE_WALKER_HH__ 195