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