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"
| 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__
| 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__
|