1/*
2 * Copyright (c) 2012 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 * 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: Andreas Sandberg
38 */
39
40#include <linux/kvm.h>
41#include <sys/ioctl.h>
42#include <sys/mman.h>
43#include <unistd.h>
44
45#include <cerrno>
46#include <csignal>
47#include <ostream>
48
49#include "arch/mmapped_ipr.hh"
50#include "arch/utility.hh"
51#include "cpu/kvm/base.hh"
52#include "debug/Checkpoint.hh"
53#include "debug/Drain.hh"
54#include "debug/Kvm.hh"
55#include "debug/KvmIO.hh"
56#include "debug/KvmRun.hh"
57#include "params/BaseKvmCPU.hh"
58#include "sim/process.hh"
59#include "sim/system.hh"
60
61#include <signal.h>
62
63/* Used by some KVM macros */
64#define PAGE_SIZE pageSize
65
66BaseKvmCPU::BaseKvmCPU(BaseKvmCPUParams *params)
67 : BaseCPU(params),
68 vm(*params->kvmVM),
69 _status(Idle),
70 dataPort(name() + ".dcache_port", this),
71 instPort(name() + ".icache_port", this),
72 threadContextDirty(true),
73 kvmStateDirty(false),
74 vcpuID(vm.allocVCPUID()), vcpuFD(-1), vcpuMMapSize(0),
75 _kvmRun(NULL), mmioRing(NULL),
76 pageSize(sysconf(_SC_PAGE_SIZE)),
77 tickEvent(*this),
78 activeInstPeriod(0),
79 perfControlledByTimer(params->usePerfOverflow),
80 hostFactor(params->hostFactor),
81 drainManager(NULL),
82 ctrInsts(0)
83{
84 if (pageSize == -1)
85 panic("KVM: Failed to determine host page size (%i)\n",
86 errno);
87
| 1/*
2 * Copyright (c) 2012 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 * 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: Andreas Sandberg
38 */
39
40#include <linux/kvm.h>
41#include <sys/ioctl.h>
42#include <sys/mman.h>
43#include <unistd.h>
44
45#include <cerrno>
46#include <csignal>
47#include <ostream>
48
49#include "arch/mmapped_ipr.hh"
50#include "arch/utility.hh"
51#include "cpu/kvm/base.hh"
52#include "debug/Checkpoint.hh"
53#include "debug/Drain.hh"
54#include "debug/Kvm.hh"
55#include "debug/KvmIO.hh"
56#include "debug/KvmRun.hh"
57#include "params/BaseKvmCPU.hh"
58#include "sim/process.hh"
59#include "sim/system.hh"
60
61#include <signal.h>
62
63/* Used by some KVM macros */
64#define PAGE_SIZE pageSize
65
66BaseKvmCPU::BaseKvmCPU(BaseKvmCPUParams *params)
67 : BaseCPU(params),
68 vm(*params->kvmVM),
69 _status(Idle),
70 dataPort(name() + ".dcache_port", this),
71 instPort(name() + ".icache_port", this),
72 threadContextDirty(true),
73 kvmStateDirty(false),
74 vcpuID(vm.allocVCPUID()), vcpuFD(-1), vcpuMMapSize(0),
75 _kvmRun(NULL), mmioRing(NULL),
76 pageSize(sysconf(_SC_PAGE_SIZE)),
77 tickEvent(*this),
78 activeInstPeriod(0),
79 perfControlledByTimer(params->usePerfOverflow),
80 hostFactor(params->hostFactor),
81 drainManager(NULL),
82 ctrInsts(0)
83{
84 if (pageSize == -1)
85 panic("KVM: Failed to determine host page size (%i)\n",
86 errno);
87
|
88 thread = new SimpleThread(this, 0, params->system,
89 params->itb, params->dtb, params->isa[0]);
| 88 if (FullSystem)
89 thread = new SimpleThread(this, 0, params->system, params->itb, params->dtb,
90 params->isa[0]);
91 else
92 thread = new SimpleThread(this, /* thread_num */ 0, params->system,
93 params->workload[0], params->itb,
94 params->dtb, params->isa[0]);
95
|
90 thread->setStatus(ThreadContext::Halted);
91 tc = thread->getTC();
92 threadContexts.push_back(tc);
93}
94
95BaseKvmCPU::~BaseKvmCPU()
96{
97 if (_kvmRun)
98 munmap(_kvmRun, vcpuMMapSize);
99 close(vcpuFD);
100}
101
102void
103BaseKvmCPU::init()
104{
105 BaseCPU::init();
106
107 if (numThreads != 1)
108 fatal("KVM: Multithreading not supported");
109
110 tc->initMemProxies(tc);
111
112 // initialize CPU, including PC
113 if (FullSystem && !switchedOut())
114 TheISA::initCPU(tc, tc->contextId());
115
116 mmio_req.setThreadContext(tc->contextId(), 0);
117}
118
119void
120BaseKvmCPU::startup()
121{
122 const BaseKvmCPUParams * const p(
123 dynamic_cast<const BaseKvmCPUParams *>(params()));
124
125 Kvm &kvm(vm.kvm);
126
127 BaseCPU::startup();
128
129 assert(vcpuFD == -1);
130
131 // Tell the VM that a CPU is about to start.
132 vm.cpuStartup();
133
134 // We can't initialize KVM CPUs in BaseKvmCPU::init() since we are
135 // not guaranteed that the parent KVM VM has initialized at that
136 // point. Initialize virtual CPUs here instead.
137 vcpuFD = vm.createVCPU(vcpuID);
138
139 // Map the KVM run structure */
140 vcpuMMapSize = kvm.getVCPUMMapSize();
141 _kvmRun = (struct kvm_run *)mmap(0, vcpuMMapSize,
142 PROT_READ | PROT_WRITE, MAP_SHARED,
143 vcpuFD, 0);
144 if (_kvmRun == MAP_FAILED)
145 panic("KVM: Failed to map run data structure\n");
146
147 // Setup a pointer to the MMIO ring buffer if coalesced MMIO is
148 // available. The offset into the KVM's communication page is
149 // provided by the coalesced MMIO capability.
150 int mmioOffset(kvm.capCoalescedMMIO());
151 if (!p->useCoalescedMMIO) {
152 inform("KVM: Coalesced MMIO disabled by config.\n");
153 } else if (mmioOffset) {
154 inform("KVM: Coalesced IO available\n");
155 mmioRing = (struct kvm_coalesced_mmio_ring *)(
156 (char *)_kvmRun + (mmioOffset * pageSize));
157 } else {
158 inform("KVM: Coalesced not supported by host OS\n");
159 }
160
161 thread->startup();
162
163 Event *startupEvent(
164 new EventWrapper<BaseKvmCPU,
165 &BaseKvmCPU::startupThread>(this, true));
166 schedule(startupEvent, curTick());
167}
168
169void
170BaseKvmCPU::startupThread()
171{
172 // Do thread-specific initialization. We need to setup signal
173 // delivery for counters and timers from within the thread that
174 // will execute the event queue to ensure that signals are
175 // delivered to the right threads.
176 const BaseKvmCPUParams * const p(
177 dynamic_cast<const BaseKvmCPUParams *>(params()));
178
179 vcpuThread = pthread_self();
180
181 // Setup signal handlers. This has to be done after the vCPU is
182 // created since it manipulates the vCPU signal mask.
183 setupSignalHandler();
184
185 setupCounters();
186
187 if (p->usePerfOverflow)
188 runTimer.reset(new PerfKvmTimer(hwCycles,
189 KVM_KICK_SIGNAL,
190 p->hostFactor,
191 p->hostFreq));
192 else
193 runTimer.reset(new PosixKvmTimer(KVM_KICK_SIGNAL, CLOCK_MONOTONIC,
194 p->hostFactor,
195 p->hostFreq));
196
197}
198
199void
200BaseKvmCPU::regStats()
201{
202 using namespace Stats;
203
204 BaseCPU::regStats();
205
206 numInsts
207 .name(name() + ".committedInsts")
208 .desc("Number of instructions committed")
209 ;
210
211 numVMExits
212 .name(name() + ".numVMExits")
213 .desc("total number of KVM exits")
214 ;
215
216 numVMHalfEntries
217 .name(name() + ".numVMHalfEntries")
218 .desc("number of KVM entries to finalize pending operations")
219 ;
220
221 numExitSignal
222 .name(name() + ".numExitSignal")
223 .desc("exits due to signal delivery")
224 ;
225
226 numMMIO
227 .name(name() + ".numMMIO")
228 .desc("number of VM exits due to memory mapped IO")
229 ;
230
231 numCoalescedMMIO
232 .name(name() + ".numCoalescedMMIO")
233 .desc("number of coalesced memory mapped IO requests")
234 ;
235
236 numIO
237 .name(name() + ".numIO")
238 .desc("number of VM exits due to legacy IO")
239 ;
240
241 numHalt
242 .name(name() + ".numHalt")
243 .desc("number of VM exits due to wait for interrupt instructions")
244 ;
245
246 numInterrupts
247 .name(name() + ".numInterrupts")
248 .desc("number of interrupts delivered")
249 ;
250
251 numHypercalls
252 .name(name() + ".numHypercalls")
253 .desc("number of hypercalls")
254 ;
255}
256
257void
258BaseKvmCPU::serializeThread(std::ostream &os, ThreadID tid)
259{
260 if (DTRACE(Checkpoint)) {
261 DPRINTF(Checkpoint, "KVM: Serializing thread %i:\n", tid);
262 dump();
263 }
264
265 assert(tid == 0);
266 assert(_status == Idle);
267 thread->serialize(os);
268}
269
270void
271BaseKvmCPU::unserializeThread(Checkpoint *cp, const std::string §ion,
272 ThreadID tid)
273{
274 DPRINTF(Checkpoint, "KVM: Unserialize thread %i:\n", tid);
275
276 assert(tid == 0);
277 assert(_status == Idle);
278 thread->unserialize(cp, section);
279 threadContextDirty = true;
280}
281
282unsigned int
283BaseKvmCPU::drain(DrainManager *dm)
284{
285 if (switchedOut())
286 return 0;
287
288 DPRINTF(Drain, "BaseKvmCPU::drain\n");
289 switch (_status) {
290 case Running:
291 // The base KVM code is normally ready when it is in the
292 // Running state, but the architecture specific code might be
293 // of a different opinion. This may happen when the CPU been
294 // notified of an event that hasn't been accepted by the vCPU
295 // yet.
296 if (!archIsDrained()) {
297 drainManager = dm;
298 return 1;
299 }
300
301 // The state of the CPU is consistent, so we don't need to do
302 // anything special to drain it. We simply de-schedule the
303 // tick event and enter the Idle state to prevent nasty things
304 // like MMIOs from happening.
305 if (tickEvent.scheduled())
306 deschedule(tickEvent);
307 _status = Idle;
308
309 /** FALLTHROUGH */
310 case Idle:
311 // Idle, no need to drain
312 assert(!tickEvent.scheduled());
313
314 // Sync the thread context here since we'll need it when we
315 // switch CPUs or checkpoint the CPU.
316 syncThreadContext();
317
318 return 0;
319
320 case RunningServiceCompletion:
321 // The CPU has just requested a service that was handled in
322 // the RunningService state, but the results have still not
323 // been reported to the CPU. Now, we /could/ probably just
324 // update the register state ourselves instead of letting KVM
325 // handle it, but that would be tricky. Instead, we enter KVM
326 // and let it do its stuff.
327 drainManager = dm;
328
329 DPRINTF(Drain, "KVM CPU is waiting for service completion, "
330 "requesting drain.\n");
331 return 1;
332
333 case RunningService:
334 // We need to drain since the CPU is waiting for service (e.g., MMIOs)
335 drainManager = dm;
336
337 DPRINTF(Drain, "KVM CPU is waiting for service, requesting drain.\n");
338 return 1;
339
340 default:
341 panic("KVM: Unhandled CPU state in drain()\n");
342 return 0;
343 }
344}
345
346void
347BaseKvmCPU::drainResume()
348{
349 assert(!tickEvent.scheduled());
350
351 // We might have been switched out. In that case, we don't need to
352 // do anything.
353 if (switchedOut())
354 return;
355
356 DPRINTF(Kvm, "drainResume\n");
357 verifyMemoryMode();
358
359 // The tick event is de-scheduled as a part of the draining
360 // process. Re-schedule it if the thread context is active.
361 if (tc->status() == ThreadContext::Active) {
362 schedule(tickEvent, nextCycle());
363 _status = Running;
364 } else {
365 _status = Idle;
366 }
367}
368
369void
370BaseKvmCPU::switchOut()
371{
372 DPRINTF(Kvm, "switchOut\n");
373
374 BaseCPU::switchOut();
375
376 // We should have drained prior to executing a switchOut, which
377 // means that the tick event shouldn't be scheduled and the CPU is
378 // idle.
379 assert(!tickEvent.scheduled());
380 assert(_status == Idle);
381}
382
383void
384BaseKvmCPU::takeOverFrom(BaseCPU *cpu)
385{
386 DPRINTF(Kvm, "takeOverFrom\n");
387
388 BaseCPU::takeOverFrom(cpu);
389
390 // We should have drained prior to executing a switchOut, which
391 // means that the tick event shouldn't be scheduled and the CPU is
392 // idle.
393 assert(!tickEvent.scheduled());
394 assert(_status == Idle);
395 assert(threadContexts.size() == 1);
396
397 // Force an update of the KVM state here instead of flagging the
398 // TC as dirty. This is not ideal from a performance point of
399 // view, but it makes debugging easier as it allows meaningful KVM
400 // state to be dumped before and after a takeover.
401 updateKvmState();
402 threadContextDirty = false;
403}
404
405void
406BaseKvmCPU::verifyMemoryMode() const
407{
408 if (!(system->isAtomicMode() && system->bypassCaches())) {
409 fatal("The KVM-based CPUs requires the memory system to be in the "
410 "'atomic_noncaching' mode.\n");
411 }
412}
413
414void
415BaseKvmCPU::wakeup()
416{
417 DPRINTF(Kvm, "wakeup()\n");
418 // This method might have been called from another
419 // context. Migrate to this SimObject's event queue when
420 // delivering the wakeup signal.
421 EventQueue::ScopedMigration migrate(eventQueue());
422
423 // Kick the vCPU to get it to come out of KVM.
424 kick();
425
426 if (thread->status() != ThreadContext::Suspended)
427 return;
428
429 thread->activate();
430}
431
432void
433BaseKvmCPU::activateContext(ThreadID thread_num)
434{
435 DPRINTF(Kvm, "ActivateContext %d\n", thread_num);
436
437 assert(thread_num == 0);
438 assert(thread);
439
440 assert(_status == Idle);
441 assert(!tickEvent.scheduled());
442
443 numCycles += ticksToCycles(thread->lastActivate - thread->lastSuspend);
444
445 schedule(tickEvent, clockEdge(Cycles(0)));
446 _status = Running;
447}
448
449
450void
451BaseKvmCPU::suspendContext(ThreadID thread_num)
452{
453 DPRINTF(Kvm, "SuspendContext %d\n", thread_num);
454
455 assert(thread_num == 0);
456 assert(thread);
457
458 if (_status == Idle)
459 return;
460
| 96 thread->setStatus(ThreadContext::Halted);
97 tc = thread->getTC();
98 threadContexts.push_back(tc);
99}
100
101BaseKvmCPU::~BaseKvmCPU()
102{
103 if (_kvmRun)
104 munmap(_kvmRun, vcpuMMapSize);
105 close(vcpuFD);
106}
107
108void
109BaseKvmCPU::init()
110{
111 BaseCPU::init();
112
113 if (numThreads != 1)
114 fatal("KVM: Multithreading not supported");
115
116 tc->initMemProxies(tc);
117
118 // initialize CPU, including PC
119 if (FullSystem && !switchedOut())
120 TheISA::initCPU(tc, tc->contextId());
121
122 mmio_req.setThreadContext(tc->contextId(), 0);
123}
124
125void
126BaseKvmCPU::startup()
127{
128 const BaseKvmCPUParams * const p(
129 dynamic_cast<const BaseKvmCPUParams *>(params()));
130
131 Kvm &kvm(vm.kvm);
132
133 BaseCPU::startup();
134
135 assert(vcpuFD == -1);
136
137 // Tell the VM that a CPU is about to start.
138 vm.cpuStartup();
139
140 // We can't initialize KVM CPUs in BaseKvmCPU::init() since we are
141 // not guaranteed that the parent KVM VM has initialized at that
142 // point. Initialize virtual CPUs here instead.
143 vcpuFD = vm.createVCPU(vcpuID);
144
145 // Map the KVM run structure */
146 vcpuMMapSize = kvm.getVCPUMMapSize();
147 _kvmRun = (struct kvm_run *)mmap(0, vcpuMMapSize,
148 PROT_READ | PROT_WRITE, MAP_SHARED,
149 vcpuFD, 0);
150 if (_kvmRun == MAP_FAILED)
151 panic("KVM: Failed to map run data structure\n");
152
153 // Setup a pointer to the MMIO ring buffer if coalesced MMIO is
154 // available. The offset into the KVM's communication page is
155 // provided by the coalesced MMIO capability.
156 int mmioOffset(kvm.capCoalescedMMIO());
157 if (!p->useCoalescedMMIO) {
158 inform("KVM: Coalesced MMIO disabled by config.\n");
159 } else if (mmioOffset) {
160 inform("KVM: Coalesced IO available\n");
161 mmioRing = (struct kvm_coalesced_mmio_ring *)(
162 (char *)_kvmRun + (mmioOffset * pageSize));
163 } else {
164 inform("KVM: Coalesced not supported by host OS\n");
165 }
166
167 thread->startup();
168
169 Event *startupEvent(
170 new EventWrapper<BaseKvmCPU,
171 &BaseKvmCPU::startupThread>(this, true));
172 schedule(startupEvent, curTick());
173}
174
175void
176BaseKvmCPU::startupThread()
177{
178 // Do thread-specific initialization. We need to setup signal
179 // delivery for counters and timers from within the thread that
180 // will execute the event queue to ensure that signals are
181 // delivered to the right threads.
182 const BaseKvmCPUParams * const p(
183 dynamic_cast<const BaseKvmCPUParams *>(params()));
184
185 vcpuThread = pthread_self();
186
187 // Setup signal handlers. This has to be done after the vCPU is
188 // created since it manipulates the vCPU signal mask.
189 setupSignalHandler();
190
191 setupCounters();
192
193 if (p->usePerfOverflow)
194 runTimer.reset(new PerfKvmTimer(hwCycles,
195 KVM_KICK_SIGNAL,
196 p->hostFactor,
197 p->hostFreq));
198 else
199 runTimer.reset(new PosixKvmTimer(KVM_KICK_SIGNAL, CLOCK_MONOTONIC,
200 p->hostFactor,
201 p->hostFreq));
202
203}
204
205void
206BaseKvmCPU::regStats()
207{
208 using namespace Stats;
209
210 BaseCPU::regStats();
211
212 numInsts
213 .name(name() + ".committedInsts")
214 .desc("Number of instructions committed")
215 ;
216
217 numVMExits
218 .name(name() + ".numVMExits")
219 .desc("total number of KVM exits")
220 ;
221
222 numVMHalfEntries
223 .name(name() + ".numVMHalfEntries")
224 .desc("number of KVM entries to finalize pending operations")
225 ;
226
227 numExitSignal
228 .name(name() + ".numExitSignal")
229 .desc("exits due to signal delivery")
230 ;
231
232 numMMIO
233 .name(name() + ".numMMIO")
234 .desc("number of VM exits due to memory mapped IO")
235 ;
236
237 numCoalescedMMIO
238 .name(name() + ".numCoalescedMMIO")
239 .desc("number of coalesced memory mapped IO requests")
240 ;
241
242 numIO
243 .name(name() + ".numIO")
244 .desc("number of VM exits due to legacy IO")
245 ;
246
247 numHalt
248 .name(name() + ".numHalt")
249 .desc("number of VM exits due to wait for interrupt instructions")
250 ;
251
252 numInterrupts
253 .name(name() + ".numInterrupts")
254 .desc("number of interrupts delivered")
255 ;
256
257 numHypercalls
258 .name(name() + ".numHypercalls")
259 .desc("number of hypercalls")
260 ;
261}
262
263void
264BaseKvmCPU::serializeThread(std::ostream &os, ThreadID tid)
265{
266 if (DTRACE(Checkpoint)) {
267 DPRINTF(Checkpoint, "KVM: Serializing thread %i:\n", tid);
268 dump();
269 }
270
271 assert(tid == 0);
272 assert(_status == Idle);
273 thread->serialize(os);
274}
275
276void
277BaseKvmCPU::unserializeThread(Checkpoint *cp, const std::string §ion,
278 ThreadID tid)
279{
280 DPRINTF(Checkpoint, "KVM: Unserialize thread %i:\n", tid);
281
282 assert(tid == 0);
283 assert(_status == Idle);
284 thread->unserialize(cp, section);
285 threadContextDirty = true;
286}
287
288unsigned int
289BaseKvmCPU::drain(DrainManager *dm)
290{
291 if (switchedOut())
292 return 0;
293
294 DPRINTF(Drain, "BaseKvmCPU::drain\n");
295 switch (_status) {
296 case Running:
297 // The base KVM code is normally ready when it is in the
298 // Running state, but the architecture specific code might be
299 // of a different opinion. This may happen when the CPU been
300 // notified of an event that hasn't been accepted by the vCPU
301 // yet.
302 if (!archIsDrained()) {
303 drainManager = dm;
304 return 1;
305 }
306
307 // The state of the CPU is consistent, so we don't need to do
308 // anything special to drain it. We simply de-schedule the
309 // tick event and enter the Idle state to prevent nasty things
310 // like MMIOs from happening.
311 if (tickEvent.scheduled())
312 deschedule(tickEvent);
313 _status = Idle;
314
315 /** FALLTHROUGH */
316 case Idle:
317 // Idle, no need to drain
318 assert(!tickEvent.scheduled());
319
320 // Sync the thread context here since we'll need it when we
321 // switch CPUs or checkpoint the CPU.
322 syncThreadContext();
323
324 return 0;
325
326 case RunningServiceCompletion:
327 // The CPU has just requested a service that was handled in
328 // the RunningService state, but the results have still not
329 // been reported to the CPU. Now, we /could/ probably just
330 // update the register state ourselves instead of letting KVM
331 // handle it, but that would be tricky. Instead, we enter KVM
332 // and let it do its stuff.
333 drainManager = dm;
334
335 DPRINTF(Drain, "KVM CPU is waiting for service completion, "
336 "requesting drain.\n");
337 return 1;
338
339 case RunningService:
340 // We need to drain since the CPU is waiting for service (e.g., MMIOs)
341 drainManager = dm;
342
343 DPRINTF(Drain, "KVM CPU is waiting for service, requesting drain.\n");
344 return 1;
345
346 default:
347 panic("KVM: Unhandled CPU state in drain()\n");
348 return 0;
349 }
350}
351
352void
353BaseKvmCPU::drainResume()
354{
355 assert(!tickEvent.scheduled());
356
357 // We might have been switched out. In that case, we don't need to
358 // do anything.
359 if (switchedOut())
360 return;
361
362 DPRINTF(Kvm, "drainResume\n");
363 verifyMemoryMode();
364
365 // The tick event is de-scheduled as a part of the draining
366 // process. Re-schedule it if the thread context is active.
367 if (tc->status() == ThreadContext::Active) {
368 schedule(tickEvent, nextCycle());
369 _status = Running;
370 } else {
371 _status = Idle;
372 }
373}
374
375void
376BaseKvmCPU::switchOut()
377{
378 DPRINTF(Kvm, "switchOut\n");
379
380 BaseCPU::switchOut();
381
382 // We should have drained prior to executing a switchOut, which
383 // means that the tick event shouldn't be scheduled and the CPU is
384 // idle.
385 assert(!tickEvent.scheduled());
386 assert(_status == Idle);
387}
388
389void
390BaseKvmCPU::takeOverFrom(BaseCPU *cpu)
391{
392 DPRINTF(Kvm, "takeOverFrom\n");
393
394 BaseCPU::takeOverFrom(cpu);
395
396 // We should have drained prior to executing a switchOut, which
397 // means that the tick event shouldn't be scheduled and the CPU is
398 // idle.
399 assert(!tickEvent.scheduled());
400 assert(_status == Idle);
401 assert(threadContexts.size() == 1);
402
403 // Force an update of the KVM state here instead of flagging the
404 // TC as dirty. This is not ideal from a performance point of
405 // view, but it makes debugging easier as it allows meaningful KVM
406 // state to be dumped before and after a takeover.
407 updateKvmState();
408 threadContextDirty = false;
409}
410
411void
412BaseKvmCPU::verifyMemoryMode() const
413{
414 if (!(system->isAtomicMode() && system->bypassCaches())) {
415 fatal("The KVM-based CPUs requires the memory system to be in the "
416 "'atomic_noncaching' mode.\n");
417 }
418}
419
420void
421BaseKvmCPU::wakeup()
422{
423 DPRINTF(Kvm, "wakeup()\n");
424 // This method might have been called from another
425 // context. Migrate to this SimObject's event queue when
426 // delivering the wakeup signal.
427 EventQueue::ScopedMigration migrate(eventQueue());
428
429 // Kick the vCPU to get it to come out of KVM.
430 kick();
431
432 if (thread->status() != ThreadContext::Suspended)
433 return;
434
435 thread->activate();
436}
437
438void
439BaseKvmCPU::activateContext(ThreadID thread_num)
440{
441 DPRINTF(Kvm, "ActivateContext %d\n", thread_num);
442
443 assert(thread_num == 0);
444 assert(thread);
445
446 assert(_status == Idle);
447 assert(!tickEvent.scheduled());
448
449 numCycles += ticksToCycles(thread->lastActivate - thread->lastSuspend);
450
451 schedule(tickEvent, clockEdge(Cycles(0)));
452 _status = Running;
453}
454
455
456void
457BaseKvmCPU::suspendContext(ThreadID thread_num)
458{
459 DPRINTF(Kvm, "SuspendContext %d\n", thread_num);
460
461 assert(thread_num == 0);
462 assert(thread);
463
464 if (_status == Idle)
465 return;
466
|
461 assert(_status == Running);
| 467 assert(_status == Running || _status == RunningServiceCompletion);
|
462
463 // The tick event may no be scheduled if the quest has requested
464 // the monitor to wait for interrupts. The normal CPU models can
465 // get their tick events descheduled by quiesce instructions, but
466 // that can't happen here.
467 if (tickEvent.scheduled())
468 deschedule(tickEvent);
469
470 _status = Idle;
471}
472
473void
474BaseKvmCPU::deallocateContext(ThreadID thread_num)
475{
476 // for now, these are equivalent
477 suspendContext(thread_num);
478}
479
480void
481BaseKvmCPU::haltContext(ThreadID thread_num)
482{
483 // for now, these are equivalent
484 suspendContext(thread_num);
485}
486
487ThreadContext *
488BaseKvmCPU::getContext(int tn)
489{
490 assert(tn == 0);
491 syncThreadContext();
492 return tc;
493}
494
495
496Counter
497BaseKvmCPU::totalInsts() const
498{
499 return ctrInsts;
500}
501
502Counter
503BaseKvmCPU::totalOps() const
504{
505 hack_once("Pretending totalOps is equivalent to totalInsts()\n");
506 return ctrInsts;
507}
508
509void
510BaseKvmCPU::dump()
511{
512 inform("State dumping not implemented.");
513}
514
515void
516BaseKvmCPU::tick()
517{
518 Tick delay(0);
519 assert(_status != Idle);
520
521 switch (_status) {
522 case RunningService:
523 // handleKvmExit() will determine the next state of the CPU
524 delay = handleKvmExit();
525
526 if (tryDrain())
527 _status = Idle;
528 break;
529
530 case RunningServiceCompletion:
531 case Running: {
532 EventQueue *q = curEventQueue();
533 Tick ticksToExecute(q->nextTick() - curTick());
534
535 // We might need to update the KVM state.
536 syncKvmState();
537
538 // Setup any pending instruction count breakpoints using
539 // PerfEvent.
540 setupInstStop();
541
542 DPRINTF(KvmRun, "Entering KVM...\n");
543 if (drainManager) {
544 // Force an immediate exit from KVM after completing
545 // pending operations. The architecture-specific code
546 // takes care to run until it is in a state where it can
547 // safely be drained.
548 delay = kvmRunDrain();
549 } else {
550 delay = kvmRun(ticksToExecute);
551 }
552
553 // The CPU might have been suspended before entering into
554 // KVM. Assume that the CPU was suspended /before/ entering
555 // into KVM and skip the exit handling.
556 if (_status == Idle)
557 break;
558
559 // Entering into KVM implies that we'll have to reload the thread
560 // context from KVM if we want to access it. Flag the KVM state as
561 // dirty with respect to the cached thread context.
562 kvmStateDirty = true;
563
564 // Enter into the RunningService state unless the
565 // simulation was stopped by a timer.
566 if (_kvmRun->exit_reason != KVM_EXIT_INTR) {
567 _status = RunningService;
568 } else {
569 ++numExitSignal;
570 _status = Running;
571 }
572
573 // Service any pending instruction events. The vCPU should
574 // have exited in time for the event using the instruction
575 // counter configured by setupInstStop().
576 comInstEventQueue[0]->serviceEvents(ctrInsts);
577 system->instEventQueue.serviceEvents(system->totalNumInsts);
578
579 if (tryDrain())
580 _status = Idle;
581 } break;
582
583 default:
584 panic("BaseKvmCPU entered tick() in an illegal state (%i)\n",
585 _status);
586 }
587
588 // Schedule a new tick if we are still running
589 if (_status != Idle)
590 schedule(tickEvent, clockEdge(ticksToCycles(delay)));
591}
592
593Tick
594BaseKvmCPU::kvmRunDrain()
595{
596 // By default, the only thing we need to drain is a pending IO
597 // operation which assumes that we are in the
598 // RunningServiceCompletion state.
599 assert(_status == RunningServiceCompletion);
600
601 // Deliver the data from the pending IO operation and immediately
602 // exit.
603 return kvmRun(0);
604}
605
606uint64_t
607BaseKvmCPU::getHostCycles() const
608{
609 return hwCycles.read();
610}
611
612Tick
613BaseKvmCPU::kvmRun(Tick ticks)
614{
615 Tick ticksExecuted;
616 DPRINTF(KvmRun, "KVM: Executing for %i ticks\n", ticks);
617
618 if (ticks == 0) {
619 // Settings ticks == 0 is a special case which causes an entry
620 // into KVM that finishes pending operations (e.g., IO) and
621 // then immediately exits.
622 DPRINTF(KvmRun, "KVM: Delivering IO without full guest entry\n");
623
624 ++numVMHalfEntries;
625
626 // Send a KVM_KICK_SIGNAL to the vCPU thread (i.e., this
627 // thread). The KVM control signal is masked while executing
628 // in gem5 and gets unmasked temporarily as when entering
629 // KVM. See setSignalMask() and setupSignalHandler().
630 kick();
631
632 // Start the vCPU. KVM will check for signals after completing
633 // pending operations (IO). Since the KVM_KICK_SIGNAL is
634 // pending, this forces an immediate exit to gem5 again. We
635 // don't bother to setup timers since this shouldn't actually
636 // execute any code (other than completing half-executed IO
637 // instructions) in the guest.
638 ioctlRun();
639
640 // We always execute at least one cycle to prevent the
641 // BaseKvmCPU::tick() to be rescheduled on the same tick
642 // twice.
643 ticksExecuted = clockPeriod();
644 } else {
645 // This method is executed as a result of a tick event. That
646 // means that the event queue will be locked when entering the
647 // method. We temporarily unlock the event queue to allow
648 // other threads to steal control of this thread to inject
649 // interrupts. They will typically lock the queue and then
650 // force an exit from KVM by kicking the vCPU.
651 EventQueue::ScopedRelease release(curEventQueue());
652
653 if (ticks < runTimer->resolution()) {
654 DPRINTF(KvmRun, "KVM: Adjusting tick count (%i -> %i)\n",
655 ticks, runTimer->resolution());
656 ticks = runTimer->resolution();
657 }
658
659 // Get hardware statistics after synchronizing contexts. The KVM
660 // state update might affect guest cycle counters.
661 uint64_t baseCycles(getHostCycles());
662 uint64_t baseInstrs(hwInstructions.read());
663
664 // Arm the run timer and start the cycle timer if it isn't
665 // controlled by the overflow timer. Starting/stopping the cycle
666 // timer automatically starts the other perf timers as they are in
667 // the same counter group.
668 runTimer->arm(ticks);
669 if (!perfControlledByTimer)
670 hwCycles.start();
671
672 ioctlRun();
673
674 runTimer->disarm();
675 if (!perfControlledByTimer)
676 hwCycles.stop();
677
678 // The control signal may have been delivered after we exited
679 // from KVM. It will be pending in that case since it is
680 // masked when we aren't executing in KVM. Discard it to make
681 // sure we don't deliver it immediately next time we try to
682 // enter into KVM.
683 discardPendingSignal(KVM_KICK_SIGNAL);
684
685 const uint64_t hostCyclesExecuted(getHostCycles() - baseCycles);
686 const uint64_t simCyclesExecuted(hostCyclesExecuted * hostFactor);
687 const uint64_t instsExecuted(hwInstructions.read() - baseInstrs);
688 ticksExecuted = runTimer->ticksFromHostCycles(hostCyclesExecuted);
689
690 /* Update statistics */
691 numCycles += simCyclesExecuted;;
692 numInsts += instsExecuted;
693 ctrInsts += instsExecuted;
694 system->totalNumInsts += instsExecuted;
695
696 DPRINTF(KvmRun,
697 "KVM: Executed %i instructions in %i cycles "
698 "(%i ticks, sim cycles: %i).\n",
699 instsExecuted, hostCyclesExecuted, ticksExecuted, simCyclesExecuted);
700 }
701
702 ++numVMExits;
703
704 return ticksExecuted + flushCoalescedMMIO();
705}
706
707void
708BaseKvmCPU::kvmNonMaskableInterrupt()
709{
710 ++numInterrupts;
711 if (ioctl(KVM_NMI) == -1)
712 panic("KVM: Failed to deliver NMI to virtual CPU\n");
713}
714
715void
716BaseKvmCPU::kvmInterrupt(const struct kvm_interrupt &interrupt)
717{
718 ++numInterrupts;
719 if (ioctl(KVM_INTERRUPT, (void *)&interrupt) == -1)
720 panic("KVM: Failed to deliver interrupt to virtual CPU\n");
721}
722
723void
724BaseKvmCPU::getRegisters(struct kvm_regs ®s) const
725{
726 if (ioctl(KVM_GET_REGS, ®s) == -1)
727 panic("KVM: Failed to get guest registers\n");
728}
729
730void
731BaseKvmCPU::setRegisters(const struct kvm_regs ®s)
732{
733 if (ioctl(KVM_SET_REGS, (void *)®s) == -1)
734 panic("KVM: Failed to set guest registers\n");
735}
736
737void
738BaseKvmCPU::getSpecialRegisters(struct kvm_sregs ®s) const
739{
740 if (ioctl(KVM_GET_SREGS, ®s) == -1)
741 panic("KVM: Failed to get guest special registers\n");
742}
743
744void
745BaseKvmCPU::setSpecialRegisters(const struct kvm_sregs ®s)
746{
747 if (ioctl(KVM_SET_SREGS, (void *)®s) == -1)
748 panic("KVM: Failed to set guest special registers\n");
749}
750
751void
752BaseKvmCPU::getFPUState(struct kvm_fpu &state) const
753{
754 if (ioctl(KVM_GET_FPU, &state) == -1)
755 panic("KVM: Failed to get guest FPU state\n");
756}
757
758void
759BaseKvmCPU::setFPUState(const struct kvm_fpu &state)
760{
761 if (ioctl(KVM_SET_FPU, (void *)&state) == -1)
762 panic("KVM: Failed to set guest FPU state\n");
763}
764
765
766void
767BaseKvmCPU::setOneReg(uint64_t id, const void *addr)
768{
769#ifdef KVM_SET_ONE_REG
770 struct kvm_one_reg reg;
771 reg.id = id;
772 reg.addr = (uint64_t)addr;
773
774 if (ioctl(KVM_SET_ONE_REG, ®) == -1) {
775 panic("KVM: Failed to set register (0x%x) value (errno: %i)\n",
776 id, errno);
777 }
778#else
779 panic("KVM_SET_ONE_REG is unsupported on this platform.\n");
780#endif
781}
782
783void
784BaseKvmCPU::getOneReg(uint64_t id, void *addr) const
785{
786#ifdef KVM_GET_ONE_REG
787 struct kvm_one_reg reg;
788 reg.id = id;
789 reg.addr = (uint64_t)addr;
790
791 if (ioctl(KVM_GET_ONE_REG, ®) == -1) {
792 panic("KVM: Failed to get register (0x%x) value (errno: %i)\n",
793 id, errno);
794 }
795#else
796 panic("KVM_GET_ONE_REG is unsupported on this platform.\n");
797#endif
798}
799
800std::string
801BaseKvmCPU::getAndFormatOneReg(uint64_t id) const
802{
803#ifdef KVM_GET_ONE_REG
804 std::ostringstream ss;
805
806 ss.setf(std::ios::hex, std::ios::basefield);
807 ss.setf(std::ios::showbase);
808#define HANDLE_INTTYPE(len) \
809 case KVM_REG_SIZE_U ## len: { \
810 uint ## len ## _t value; \
811 getOneReg(id, &value); \
812 ss << value; \
813 } break
814
815#define HANDLE_ARRAY(len) \
816 case KVM_REG_SIZE_U ## len: { \
817 uint8_t value[len / 8]; \
818 getOneReg(id, value); \
819 ss << "[" << value[0]; \
820 for (int i = 1; i < len / 8; ++i) \
821 ss << ", " << value[i]; \
822 ss << "]"; \
823 } break
824
825 switch (id & KVM_REG_SIZE_MASK) {
826 HANDLE_INTTYPE(8);
827 HANDLE_INTTYPE(16);
828 HANDLE_INTTYPE(32);
829 HANDLE_INTTYPE(64);
830 HANDLE_ARRAY(128);
831 HANDLE_ARRAY(256);
832 HANDLE_ARRAY(512);
833 HANDLE_ARRAY(1024);
834 default:
835 ss << "??";
836 }
837
838#undef HANDLE_INTTYPE
839#undef HANDLE_ARRAY
840
841 return ss.str();
842#else
843 panic("KVM_GET_ONE_REG is unsupported on this platform.\n");
844#endif
845}
846
847void
848BaseKvmCPU::syncThreadContext()
849{
850 if (!kvmStateDirty)
851 return;
852
853 assert(!threadContextDirty);
854
855 updateThreadContext();
856 kvmStateDirty = false;
857}
858
859void
860BaseKvmCPU::syncKvmState()
861{
862 if (!threadContextDirty)
863 return;
864
865 assert(!kvmStateDirty);
866
867 updateKvmState();
868 threadContextDirty = false;
869}
870
871Tick
872BaseKvmCPU::handleKvmExit()
873{
874 DPRINTF(KvmRun, "handleKvmExit (exit_reason: %i)\n", _kvmRun->exit_reason);
875 assert(_status == RunningService);
876
877 // Switch into the running state by default. Individual handlers
878 // can override this.
879 _status = Running;
880 switch (_kvmRun->exit_reason) {
881 case KVM_EXIT_UNKNOWN:
882 return handleKvmExitUnknown();
883
884 case KVM_EXIT_EXCEPTION:
885 return handleKvmExitException();
886
887 case KVM_EXIT_IO:
888 _status = RunningServiceCompletion;
889 ++numIO;
890 return handleKvmExitIO();
891
892 case KVM_EXIT_HYPERCALL:
893 ++numHypercalls;
894 return handleKvmExitHypercall();
895
896 case KVM_EXIT_HLT:
897 /* The guest has halted and is waiting for interrupts */
898 DPRINTF(Kvm, "handleKvmExitHalt\n");
899 ++numHalt;
900
901 // Suspend the thread until the next interrupt arrives
902 thread->suspend();
903
904 // This is actually ignored since the thread is suspended.
905 return 0;
906
907 case KVM_EXIT_MMIO:
908 _status = RunningServiceCompletion;
909 /* Service memory mapped IO requests */
910 DPRINTF(KvmIO, "KVM: Handling MMIO (w: %u, addr: 0x%x, len: %u)\n",
911 _kvmRun->mmio.is_write,
912 _kvmRun->mmio.phys_addr, _kvmRun->mmio.len);
913
914 ++numMMIO;
915 return doMMIOAccess(_kvmRun->mmio.phys_addr, _kvmRun->mmio.data,
916 _kvmRun->mmio.len, _kvmRun->mmio.is_write);
917
918 case KVM_EXIT_IRQ_WINDOW_OPEN:
919 return handleKvmExitIRQWindowOpen();
920
921 case KVM_EXIT_FAIL_ENTRY:
922 return handleKvmExitFailEntry();
923
924 case KVM_EXIT_INTR:
925 /* KVM was interrupted by a signal, restart it in the next
926 * tick. */
927 return 0;
928
929 case KVM_EXIT_INTERNAL_ERROR:
930 panic("KVM: Internal error (suberror: %u)\n",
931 _kvmRun->internal.suberror);
932
933 default:
934 dump();
935 panic("KVM: Unexpected exit (exit_reason: %u)\n", _kvmRun->exit_reason);
936 }
937}
938
939Tick
940BaseKvmCPU::handleKvmExitIO()
941{
942 panic("KVM: Unhandled guest IO (dir: %i, size: %i, port: 0x%x, count: %i)\n",
943 _kvmRun->io.direction, _kvmRun->io.size,
944 _kvmRun->io.port, _kvmRun->io.count);
945}
946
947Tick
948BaseKvmCPU::handleKvmExitHypercall()
949{
950 panic("KVM: Unhandled hypercall\n");
951}
952
953Tick
954BaseKvmCPU::handleKvmExitIRQWindowOpen()
955{
956 warn("KVM: Unhandled IRQ window.\n");
957 return 0;
958}
959
960
961Tick
962BaseKvmCPU::handleKvmExitUnknown()
963{
964 dump();
965 panic("KVM: Unknown error when starting vCPU (hw reason: 0x%llx)\n",
966 _kvmRun->hw.hardware_exit_reason);
967}
968
969Tick
970BaseKvmCPU::handleKvmExitException()
971{
972 dump();
973 panic("KVM: Got exception when starting vCPU "
974 "(exception: %u, error_code: %u)\n",
975 _kvmRun->ex.exception, _kvmRun->ex.error_code);
976}
977
978Tick
979BaseKvmCPU::handleKvmExitFailEntry()
980{
981 dump();
982 panic("KVM: Failed to enter virtualized mode (hw reason: 0x%llx)\n",
983 _kvmRun->fail_entry.hardware_entry_failure_reason);
984}
985
986Tick
987BaseKvmCPU::doMMIOAccess(Addr paddr, void *data, int size, bool write)
988{
989 ThreadContext *tc(thread->getTC());
990 syncThreadContext();
991
992 mmio_req.setPhys(paddr, size, Request::UNCACHEABLE, dataMasterId());
993 // Some architectures do need to massage physical addresses a bit
994 // before they are inserted into the memory system. This enables
995 // APIC accesses on x86 and m5ops where supported through a MMIO
996 // interface.
997 BaseTLB::Mode tlb_mode(write ? BaseTLB::Write : BaseTLB::Read);
998 Fault fault(tc->getDTBPtr()->finalizePhysical(&mmio_req, tc, tlb_mode));
999 if (fault != NoFault)
1000 warn("Finalization of MMIO address failed: %s\n", fault->name());
1001
1002
1003 const MemCmd cmd(write ? MemCmd::WriteReq : MemCmd::ReadReq);
1004 Packet pkt(&mmio_req, cmd);
1005 pkt.dataStatic(data);
1006
1007 if (mmio_req.isMmappedIpr()) {
1008 // We currently assume that there is no need to migrate to a
1009 // different event queue when doing IPRs. Currently, IPRs are
1010 // only used for m5ops, so it should be a valid assumption.
1011 const Cycles ipr_delay(write ?
1012 TheISA::handleIprWrite(tc, &pkt) :
1013 TheISA::handleIprRead(tc, &pkt));
| 468
469 // The tick event may no be scheduled if the quest has requested
470 // the monitor to wait for interrupts. The normal CPU models can
471 // get their tick events descheduled by quiesce instructions, but
472 // that can't happen here.
473 if (tickEvent.scheduled())
474 deschedule(tickEvent);
475
476 _status = Idle;
477}
478
479void
480BaseKvmCPU::deallocateContext(ThreadID thread_num)
481{
482 // for now, these are equivalent
483 suspendContext(thread_num);
484}
485
486void
487BaseKvmCPU::haltContext(ThreadID thread_num)
488{
489 // for now, these are equivalent
490 suspendContext(thread_num);
491}
492
493ThreadContext *
494BaseKvmCPU::getContext(int tn)
495{
496 assert(tn == 0);
497 syncThreadContext();
498 return tc;
499}
500
501
502Counter
503BaseKvmCPU::totalInsts() const
504{
505 return ctrInsts;
506}
507
508Counter
509BaseKvmCPU::totalOps() const
510{
511 hack_once("Pretending totalOps is equivalent to totalInsts()\n");
512 return ctrInsts;
513}
514
515void
516BaseKvmCPU::dump()
517{
518 inform("State dumping not implemented.");
519}
520
521void
522BaseKvmCPU::tick()
523{
524 Tick delay(0);
525 assert(_status != Idle);
526
527 switch (_status) {
528 case RunningService:
529 // handleKvmExit() will determine the next state of the CPU
530 delay = handleKvmExit();
531
532 if (tryDrain())
533 _status = Idle;
534 break;
535
536 case RunningServiceCompletion:
537 case Running: {
538 EventQueue *q = curEventQueue();
539 Tick ticksToExecute(q->nextTick() - curTick());
540
541 // We might need to update the KVM state.
542 syncKvmState();
543
544 // Setup any pending instruction count breakpoints using
545 // PerfEvent.
546 setupInstStop();
547
548 DPRINTF(KvmRun, "Entering KVM...\n");
549 if (drainManager) {
550 // Force an immediate exit from KVM after completing
551 // pending operations. The architecture-specific code
552 // takes care to run until it is in a state where it can
553 // safely be drained.
554 delay = kvmRunDrain();
555 } else {
556 delay = kvmRun(ticksToExecute);
557 }
558
559 // The CPU might have been suspended before entering into
560 // KVM. Assume that the CPU was suspended /before/ entering
561 // into KVM and skip the exit handling.
562 if (_status == Idle)
563 break;
564
565 // Entering into KVM implies that we'll have to reload the thread
566 // context from KVM if we want to access it. Flag the KVM state as
567 // dirty with respect to the cached thread context.
568 kvmStateDirty = true;
569
570 // Enter into the RunningService state unless the
571 // simulation was stopped by a timer.
572 if (_kvmRun->exit_reason != KVM_EXIT_INTR) {
573 _status = RunningService;
574 } else {
575 ++numExitSignal;
576 _status = Running;
577 }
578
579 // Service any pending instruction events. The vCPU should
580 // have exited in time for the event using the instruction
581 // counter configured by setupInstStop().
582 comInstEventQueue[0]->serviceEvents(ctrInsts);
583 system->instEventQueue.serviceEvents(system->totalNumInsts);
584
585 if (tryDrain())
586 _status = Idle;
587 } break;
588
589 default:
590 panic("BaseKvmCPU entered tick() in an illegal state (%i)\n",
591 _status);
592 }
593
594 // Schedule a new tick if we are still running
595 if (_status != Idle)
596 schedule(tickEvent, clockEdge(ticksToCycles(delay)));
597}
598
599Tick
600BaseKvmCPU::kvmRunDrain()
601{
602 // By default, the only thing we need to drain is a pending IO
603 // operation which assumes that we are in the
604 // RunningServiceCompletion state.
605 assert(_status == RunningServiceCompletion);
606
607 // Deliver the data from the pending IO operation and immediately
608 // exit.
609 return kvmRun(0);
610}
611
612uint64_t
613BaseKvmCPU::getHostCycles() const
614{
615 return hwCycles.read();
616}
617
618Tick
619BaseKvmCPU::kvmRun(Tick ticks)
620{
621 Tick ticksExecuted;
622 DPRINTF(KvmRun, "KVM: Executing for %i ticks\n", ticks);
623
624 if (ticks == 0) {
625 // Settings ticks == 0 is a special case which causes an entry
626 // into KVM that finishes pending operations (e.g., IO) and
627 // then immediately exits.
628 DPRINTF(KvmRun, "KVM: Delivering IO without full guest entry\n");
629
630 ++numVMHalfEntries;
631
632 // Send a KVM_KICK_SIGNAL to the vCPU thread (i.e., this
633 // thread). The KVM control signal is masked while executing
634 // in gem5 and gets unmasked temporarily as when entering
635 // KVM. See setSignalMask() and setupSignalHandler().
636 kick();
637
638 // Start the vCPU. KVM will check for signals after completing
639 // pending operations (IO). Since the KVM_KICK_SIGNAL is
640 // pending, this forces an immediate exit to gem5 again. We
641 // don't bother to setup timers since this shouldn't actually
642 // execute any code (other than completing half-executed IO
643 // instructions) in the guest.
644 ioctlRun();
645
646 // We always execute at least one cycle to prevent the
647 // BaseKvmCPU::tick() to be rescheduled on the same tick
648 // twice.
649 ticksExecuted = clockPeriod();
650 } else {
651 // This method is executed as a result of a tick event. That
652 // means that the event queue will be locked when entering the
653 // method. We temporarily unlock the event queue to allow
654 // other threads to steal control of this thread to inject
655 // interrupts. They will typically lock the queue and then
656 // force an exit from KVM by kicking the vCPU.
657 EventQueue::ScopedRelease release(curEventQueue());
658
659 if (ticks < runTimer->resolution()) {
660 DPRINTF(KvmRun, "KVM: Adjusting tick count (%i -> %i)\n",
661 ticks, runTimer->resolution());
662 ticks = runTimer->resolution();
663 }
664
665 // Get hardware statistics after synchronizing contexts. The KVM
666 // state update might affect guest cycle counters.
667 uint64_t baseCycles(getHostCycles());
668 uint64_t baseInstrs(hwInstructions.read());
669
670 // Arm the run timer and start the cycle timer if it isn't
671 // controlled by the overflow timer. Starting/stopping the cycle
672 // timer automatically starts the other perf timers as they are in
673 // the same counter group.
674 runTimer->arm(ticks);
675 if (!perfControlledByTimer)
676 hwCycles.start();
677
678 ioctlRun();
679
680 runTimer->disarm();
681 if (!perfControlledByTimer)
682 hwCycles.stop();
683
684 // The control signal may have been delivered after we exited
685 // from KVM. It will be pending in that case since it is
686 // masked when we aren't executing in KVM. Discard it to make
687 // sure we don't deliver it immediately next time we try to
688 // enter into KVM.
689 discardPendingSignal(KVM_KICK_SIGNAL);
690
691 const uint64_t hostCyclesExecuted(getHostCycles() - baseCycles);
692 const uint64_t simCyclesExecuted(hostCyclesExecuted * hostFactor);
693 const uint64_t instsExecuted(hwInstructions.read() - baseInstrs);
694 ticksExecuted = runTimer->ticksFromHostCycles(hostCyclesExecuted);
695
696 /* Update statistics */
697 numCycles += simCyclesExecuted;;
698 numInsts += instsExecuted;
699 ctrInsts += instsExecuted;
700 system->totalNumInsts += instsExecuted;
701
702 DPRINTF(KvmRun,
703 "KVM: Executed %i instructions in %i cycles "
704 "(%i ticks, sim cycles: %i).\n",
705 instsExecuted, hostCyclesExecuted, ticksExecuted, simCyclesExecuted);
706 }
707
708 ++numVMExits;
709
710 return ticksExecuted + flushCoalescedMMIO();
711}
712
713void
714BaseKvmCPU::kvmNonMaskableInterrupt()
715{
716 ++numInterrupts;
717 if (ioctl(KVM_NMI) == -1)
718 panic("KVM: Failed to deliver NMI to virtual CPU\n");
719}
720
721void
722BaseKvmCPU::kvmInterrupt(const struct kvm_interrupt &interrupt)
723{
724 ++numInterrupts;
725 if (ioctl(KVM_INTERRUPT, (void *)&interrupt) == -1)
726 panic("KVM: Failed to deliver interrupt to virtual CPU\n");
727}
728
729void
730BaseKvmCPU::getRegisters(struct kvm_regs ®s) const
731{
732 if (ioctl(KVM_GET_REGS, ®s) == -1)
733 panic("KVM: Failed to get guest registers\n");
734}
735
736void
737BaseKvmCPU::setRegisters(const struct kvm_regs ®s)
738{
739 if (ioctl(KVM_SET_REGS, (void *)®s) == -1)
740 panic("KVM: Failed to set guest registers\n");
741}
742
743void
744BaseKvmCPU::getSpecialRegisters(struct kvm_sregs ®s) const
745{
746 if (ioctl(KVM_GET_SREGS, ®s) == -1)
747 panic("KVM: Failed to get guest special registers\n");
748}
749
750void
751BaseKvmCPU::setSpecialRegisters(const struct kvm_sregs ®s)
752{
753 if (ioctl(KVM_SET_SREGS, (void *)®s) == -1)
754 panic("KVM: Failed to set guest special registers\n");
755}
756
757void
758BaseKvmCPU::getFPUState(struct kvm_fpu &state) const
759{
760 if (ioctl(KVM_GET_FPU, &state) == -1)
761 panic("KVM: Failed to get guest FPU state\n");
762}
763
764void
765BaseKvmCPU::setFPUState(const struct kvm_fpu &state)
766{
767 if (ioctl(KVM_SET_FPU, (void *)&state) == -1)
768 panic("KVM: Failed to set guest FPU state\n");
769}
770
771
772void
773BaseKvmCPU::setOneReg(uint64_t id, const void *addr)
774{
775#ifdef KVM_SET_ONE_REG
776 struct kvm_one_reg reg;
777 reg.id = id;
778 reg.addr = (uint64_t)addr;
779
780 if (ioctl(KVM_SET_ONE_REG, ®) == -1) {
781 panic("KVM: Failed to set register (0x%x) value (errno: %i)\n",
782 id, errno);
783 }
784#else
785 panic("KVM_SET_ONE_REG is unsupported on this platform.\n");
786#endif
787}
788
789void
790BaseKvmCPU::getOneReg(uint64_t id, void *addr) const
791{
792#ifdef KVM_GET_ONE_REG
793 struct kvm_one_reg reg;
794 reg.id = id;
795 reg.addr = (uint64_t)addr;
796
797 if (ioctl(KVM_GET_ONE_REG, ®) == -1) {
798 panic("KVM: Failed to get register (0x%x) value (errno: %i)\n",
799 id, errno);
800 }
801#else
802 panic("KVM_GET_ONE_REG is unsupported on this platform.\n");
803#endif
804}
805
806std::string
807BaseKvmCPU::getAndFormatOneReg(uint64_t id) const
808{
809#ifdef KVM_GET_ONE_REG
810 std::ostringstream ss;
811
812 ss.setf(std::ios::hex, std::ios::basefield);
813 ss.setf(std::ios::showbase);
814#define HANDLE_INTTYPE(len) \
815 case KVM_REG_SIZE_U ## len: { \
816 uint ## len ## _t value; \
817 getOneReg(id, &value); \
818 ss << value; \
819 } break
820
821#define HANDLE_ARRAY(len) \
822 case KVM_REG_SIZE_U ## len: { \
823 uint8_t value[len / 8]; \
824 getOneReg(id, value); \
825 ss << "[" << value[0]; \
826 for (int i = 1; i < len / 8; ++i) \
827 ss << ", " << value[i]; \
828 ss << "]"; \
829 } break
830
831 switch (id & KVM_REG_SIZE_MASK) {
832 HANDLE_INTTYPE(8);
833 HANDLE_INTTYPE(16);
834 HANDLE_INTTYPE(32);
835 HANDLE_INTTYPE(64);
836 HANDLE_ARRAY(128);
837 HANDLE_ARRAY(256);
838 HANDLE_ARRAY(512);
839 HANDLE_ARRAY(1024);
840 default:
841 ss << "??";
842 }
843
844#undef HANDLE_INTTYPE
845#undef HANDLE_ARRAY
846
847 return ss.str();
848#else
849 panic("KVM_GET_ONE_REG is unsupported on this platform.\n");
850#endif
851}
852
853void
854BaseKvmCPU::syncThreadContext()
855{
856 if (!kvmStateDirty)
857 return;
858
859 assert(!threadContextDirty);
860
861 updateThreadContext();
862 kvmStateDirty = false;
863}
864
865void
866BaseKvmCPU::syncKvmState()
867{
868 if (!threadContextDirty)
869 return;
870
871 assert(!kvmStateDirty);
872
873 updateKvmState();
874 threadContextDirty = false;
875}
876
877Tick
878BaseKvmCPU::handleKvmExit()
879{
880 DPRINTF(KvmRun, "handleKvmExit (exit_reason: %i)\n", _kvmRun->exit_reason);
881 assert(_status == RunningService);
882
883 // Switch into the running state by default. Individual handlers
884 // can override this.
885 _status = Running;
886 switch (_kvmRun->exit_reason) {
887 case KVM_EXIT_UNKNOWN:
888 return handleKvmExitUnknown();
889
890 case KVM_EXIT_EXCEPTION:
891 return handleKvmExitException();
892
893 case KVM_EXIT_IO:
894 _status = RunningServiceCompletion;
895 ++numIO;
896 return handleKvmExitIO();
897
898 case KVM_EXIT_HYPERCALL:
899 ++numHypercalls;
900 return handleKvmExitHypercall();
901
902 case KVM_EXIT_HLT:
903 /* The guest has halted and is waiting for interrupts */
904 DPRINTF(Kvm, "handleKvmExitHalt\n");
905 ++numHalt;
906
907 // Suspend the thread until the next interrupt arrives
908 thread->suspend();
909
910 // This is actually ignored since the thread is suspended.
911 return 0;
912
913 case KVM_EXIT_MMIO:
914 _status = RunningServiceCompletion;
915 /* Service memory mapped IO requests */
916 DPRINTF(KvmIO, "KVM: Handling MMIO (w: %u, addr: 0x%x, len: %u)\n",
917 _kvmRun->mmio.is_write,
918 _kvmRun->mmio.phys_addr, _kvmRun->mmio.len);
919
920 ++numMMIO;
921 return doMMIOAccess(_kvmRun->mmio.phys_addr, _kvmRun->mmio.data,
922 _kvmRun->mmio.len, _kvmRun->mmio.is_write);
923
924 case KVM_EXIT_IRQ_WINDOW_OPEN:
925 return handleKvmExitIRQWindowOpen();
926
927 case KVM_EXIT_FAIL_ENTRY:
928 return handleKvmExitFailEntry();
929
930 case KVM_EXIT_INTR:
931 /* KVM was interrupted by a signal, restart it in the next
932 * tick. */
933 return 0;
934
935 case KVM_EXIT_INTERNAL_ERROR:
936 panic("KVM: Internal error (suberror: %u)\n",
937 _kvmRun->internal.suberror);
938
939 default:
940 dump();
941 panic("KVM: Unexpected exit (exit_reason: %u)\n", _kvmRun->exit_reason);
942 }
943}
944
945Tick
946BaseKvmCPU::handleKvmExitIO()
947{
948 panic("KVM: Unhandled guest IO (dir: %i, size: %i, port: 0x%x, count: %i)\n",
949 _kvmRun->io.direction, _kvmRun->io.size,
950 _kvmRun->io.port, _kvmRun->io.count);
951}
952
953Tick
954BaseKvmCPU::handleKvmExitHypercall()
955{
956 panic("KVM: Unhandled hypercall\n");
957}
958
959Tick
960BaseKvmCPU::handleKvmExitIRQWindowOpen()
961{
962 warn("KVM: Unhandled IRQ window.\n");
963 return 0;
964}
965
966
967Tick
968BaseKvmCPU::handleKvmExitUnknown()
969{
970 dump();
971 panic("KVM: Unknown error when starting vCPU (hw reason: 0x%llx)\n",
972 _kvmRun->hw.hardware_exit_reason);
973}
974
975Tick
976BaseKvmCPU::handleKvmExitException()
977{
978 dump();
979 panic("KVM: Got exception when starting vCPU "
980 "(exception: %u, error_code: %u)\n",
981 _kvmRun->ex.exception, _kvmRun->ex.error_code);
982}
983
984Tick
985BaseKvmCPU::handleKvmExitFailEntry()
986{
987 dump();
988 panic("KVM: Failed to enter virtualized mode (hw reason: 0x%llx)\n",
989 _kvmRun->fail_entry.hardware_entry_failure_reason);
990}
991
992Tick
993BaseKvmCPU::doMMIOAccess(Addr paddr, void *data, int size, bool write)
994{
995 ThreadContext *tc(thread->getTC());
996 syncThreadContext();
997
998 mmio_req.setPhys(paddr, size, Request::UNCACHEABLE, dataMasterId());
999 // Some architectures do need to massage physical addresses a bit
1000 // before they are inserted into the memory system. This enables
1001 // APIC accesses on x86 and m5ops where supported through a MMIO
1002 // interface.
1003 BaseTLB::Mode tlb_mode(write ? BaseTLB::Write : BaseTLB::Read);
1004 Fault fault(tc->getDTBPtr()->finalizePhysical(&mmio_req, tc, tlb_mode));
1005 if (fault != NoFault)
1006 warn("Finalization of MMIO address failed: %s\n", fault->name());
1007
1008
1009 const MemCmd cmd(write ? MemCmd::WriteReq : MemCmd::ReadReq);
1010 Packet pkt(&mmio_req, cmd);
1011 pkt.dataStatic(data);
1012
1013 if (mmio_req.isMmappedIpr()) {
1014 // We currently assume that there is no need to migrate to a
1015 // different event queue when doing IPRs. Currently, IPRs are
1016 // only used for m5ops, so it should be a valid assumption.
1017 const Cycles ipr_delay(write ?
1018 TheISA::handleIprWrite(tc, &pkt) :
1019 TheISA::handleIprRead(tc, &pkt));
|
| 1020 threadContextDirty = true;
|
1014 return clockPeriod() * ipr_delay;
1015 } else {
1016 // Temporarily lock and migrate to the event queue of the
1017 // VM. This queue is assumed to "own" all devices we need to
1018 // access if running in multi-core mode.
1019 EventQueue::ScopedMigration migrate(vm.eventQueue());
1020
1021 return dataPort.sendAtomic(&pkt);
1022 }
1023}
1024
1025void
1026BaseKvmCPU::setSignalMask(const sigset_t *mask)
1027{
1028 std::unique_ptr<struct kvm_signal_mask> kvm_mask;
1029
1030 if (mask) {
1031 kvm_mask.reset((struct kvm_signal_mask *)operator new(
1032 sizeof(struct kvm_signal_mask) + sizeof(*mask)));
1033 // The kernel and the user-space headers have different ideas
1034 // about the size of sigset_t. This seems like a massive hack,
1035 // but is actually what qemu does.
1036 assert(sizeof(*mask) >= 8);
1037 kvm_mask->len = 8;
1038 memcpy(kvm_mask->sigset, mask, kvm_mask->len);
1039 }
1040
1041 if (ioctl(KVM_SET_SIGNAL_MASK, (void *)kvm_mask.get()) == -1)
1042 panic("KVM: Failed to set vCPU signal mask (errno: %i)\n",
1043 errno);
1044}
1045
1046int
1047BaseKvmCPU::ioctl(int request, long p1) const
1048{
1049 if (vcpuFD == -1)
1050 panic("KVM: CPU ioctl called before initialization\n");
1051
1052 return ::ioctl(vcpuFD, request, p1);
1053}
1054
1055Tick
1056BaseKvmCPU::flushCoalescedMMIO()
1057{
1058 if (!mmioRing)
1059 return 0;
1060
1061 DPRINTF(KvmIO, "KVM: Flushing the coalesced MMIO ring buffer\n");
1062
1063 // TODO: We might need to do synchronization when we start to
1064 // support multiple CPUs
1065 Tick ticks(0);
1066 while (mmioRing->first != mmioRing->last) {
1067 struct kvm_coalesced_mmio &ent(
1068 mmioRing->coalesced_mmio[mmioRing->first]);
1069
1070 DPRINTF(KvmIO, "KVM: Handling coalesced MMIO (addr: 0x%x, len: %u)\n",
1071 ent.phys_addr, ent.len);
1072
1073 ++numCoalescedMMIO;
1074 ticks += doMMIOAccess(ent.phys_addr, ent.data, ent.len, true);
1075
1076 mmioRing->first = (mmioRing->first + 1) % KVM_COALESCED_MMIO_MAX;
1077 }
1078
1079 return ticks;
1080}
1081
1082/**
1083 * Dummy handler for KVM kick signals.
1084 *
1085 * @note This function is usually not called since the kernel doesn't
1086 * seem to deliver signals when the signal is only unmasked when
1087 * running in KVM. This doesn't matter though since we are only
1088 * interested in getting KVM to exit, which happens as expected. See
1089 * setupSignalHandler() and kvmRun() for details about KVM signal
1090 * handling.
1091 */
1092static void
1093onKickSignal(int signo, siginfo_t *si, void *data)
1094{
1095}
1096
1097void
1098BaseKvmCPU::setupSignalHandler()
1099{
1100 struct sigaction sa;
1101
1102 memset(&sa, 0, sizeof(sa));
1103 sa.sa_sigaction = onKickSignal;
1104 sa.sa_flags = SA_SIGINFO | SA_RESTART;
1105 if (sigaction(KVM_KICK_SIGNAL, &sa, NULL) == -1)
1106 panic("KVM: Failed to setup vCPU timer signal handler\n");
1107
1108 sigset_t sigset;
1109 if (pthread_sigmask(SIG_BLOCK, NULL, &sigset) == -1)
1110 panic("KVM: Failed get signal mask\n");
1111
1112 // Request KVM to setup the same signal mask as we're currently
1113 // running with except for the KVM control signal. We'll sometimes
1114 // need to raise the KVM_KICK_SIGNAL to cause immediate exits from
1115 // KVM after servicing IO requests. See kvmRun().
1116 sigdelset(&sigset, KVM_KICK_SIGNAL);
1117 setSignalMask(&sigset);
1118
1119 // Mask our control signals so they aren't delivered unless we're
1120 // actually executing inside KVM.
1121 sigaddset(&sigset, KVM_KICK_SIGNAL);
1122 if (pthread_sigmask(SIG_SETMASK, &sigset, NULL) == -1)
1123 panic("KVM: Failed mask the KVM control signals\n");
1124}
1125
1126bool
1127BaseKvmCPU::discardPendingSignal(int signum) const
1128{
1129 int discardedSignal;
1130
1131 // Setting the timeout to zero causes sigtimedwait to return
1132 // immediately.
1133 struct timespec timeout;
1134 timeout.tv_sec = 0;
1135 timeout.tv_nsec = 0;
1136
1137 sigset_t sigset;
1138 sigemptyset(&sigset);
1139 sigaddset(&sigset, signum);
1140
1141 do {
1142 discardedSignal = sigtimedwait(&sigset, NULL, &timeout);
1143 } while (discardedSignal == -1 && errno == EINTR);
1144
1145 if (discardedSignal == signum)
1146 return true;
1147 else if (discardedSignal == -1 && errno == EAGAIN)
1148 return false;
1149 else
1150 panic("Unexpected return value from sigtimedwait: %i (errno: %i)\n",
1151 discardedSignal, errno);
1152}
1153
1154void
1155BaseKvmCPU::setupCounters()
1156{
1157 DPRINTF(Kvm, "Attaching cycle counter...\n");
1158 PerfKvmCounterConfig cfgCycles(PERF_TYPE_HARDWARE,
1159 PERF_COUNT_HW_CPU_CYCLES);
1160 cfgCycles.disabled(true)
1161 .pinned(true);
1162
1163 // Try to exclude the host. We set both exclude_hv and
1164 // exclude_host since different architectures use slightly
1165 // different APIs in the kernel.
1166 cfgCycles.exclude_hv(true)
1167 .exclude_host(true);
1168
1169 if (perfControlledByTimer) {
1170 // We need to configure the cycles counter to send overflows
1171 // since we are going to use it to trigger timer signals that
1172 // trap back into m5 from KVM. In practice, this means that we
1173 // need to set some non-zero sample period that gets
1174 // overridden when the timer is armed.
1175 cfgCycles.wakeupEvents(1)
1176 .samplePeriod(42);
1177 }
1178
1179 hwCycles.attach(cfgCycles,
1180 0); // TID (0 => currentThread)
1181
1182 setupInstCounter();
1183}
1184
1185bool
1186BaseKvmCPU::tryDrain()
1187{
1188 if (!drainManager)
1189 return false;
1190
1191 if (!archIsDrained()) {
1192 DPRINTF(Drain, "tryDrain: Architecture code is not ready.\n");
1193 return false;
1194 }
1195
1196 if (_status == Idle || _status == Running) {
1197 DPRINTF(Drain,
1198 "tryDrain: CPU transitioned into the Idle state, drain done\n");
1199 drainManager->signalDrainDone();
1200 drainManager = NULL;
1201 return true;
1202 } else {
1203 DPRINTF(Drain, "tryDrain: CPU not ready.\n");
1204 return false;
1205 }
1206}
1207
1208void
1209BaseKvmCPU::ioctlRun()
1210{
1211 if (ioctl(KVM_RUN) == -1) {
1212 if (errno != EINTR)
1213 panic("KVM: Failed to start virtual CPU (errno: %i)\n",
1214 errno);
1215 }
1216}
1217
1218void
1219BaseKvmCPU::setupInstStop()
1220{
1221 if (comInstEventQueue[0]->empty()) {
1222 setupInstCounter(0);
1223 } else {
1224 const uint64_t next(comInstEventQueue[0]->nextTick());
1225
1226 assert(next > ctrInsts);
1227 setupInstCounter(next - ctrInsts);
1228 }
1229}
1230
1231void
1232BaseKvmCPU::setupInstCounter(uint64_t period)
1233{
1234 // No need to do anything if we aren't attaching for the first
1235 // time or the period isn't changing.
1236 if (period == activeInstPeriod && hwInstructions.attached())
1237 return;
1238
1239 PerfKvmCounterConfig cfgInstructions(PERF_TYPE_HARDWARE,
1240 PERF_COUNT_HW_INSTRUCTIONS);
1241
1242 // Try to exclude the host. We set both exclude_hv and
1243 // exclude_host since different architectures use slightly
1244 // different APIs in the kernel.
1245 cfgInstructions.exclude_hv(true)
1246 .exclude_host(true);
1247
1248 if (period) {
1249 // Setup a sampling counter if that has been requested.
1250 cfgInstructions.wakeupEvents(1)
1251 .samplePeriod(period);
1252 }
1253
1254 // We need to detach and re-attach the counter to reliably change
1255 // sampling settings. See PerfKvmCounter::period() for details.
1256 if (hwInstructions.attached())
1257 hwInstructions.detach();
1258 assert(hwCycles.attached());
1259 hwInstructions.attach(cfgInstructions,
1260 0, // TID (0 => currentThread)
1261 hwCycles);
1262
1263 if (period)
1264 hwInstructions.enableSignals(KVM_KICK_SIGNAL);
1265
1266 activeInstPeriod = period;
1267}
| 1021 return clockPeriod() * ipr_delay;
1022 } else {
1023 // Temporarily lock and migrate to the event queue of the
1024 // VM. This queue is assumed to "own" all devices we need to
1025 // access if running in multi-core mode.
1026 EventQueue::ScopedMigration migrate(vm.eventQueue());
1027
1028 return dataPort.sendAtomic(&pkt);
1029 }
1030}
1031
1032void
1033BaseKvmCPU::setSignalMask(const sigset_t *mask)
1034{
1035 std::unique_ptr<struct kvm_signal_mask> kvm_mask;
1036
1037 if (mask) {
1038 kvm_mask.reset((struct kvm_signal_mask *)operator new(
1039 sizeof(struct kvm_signal_mask) + sizeof(*mask)));
1040 // The kernel and the user-space headers have different ideas
1041 // about the size of sigset_t. This seems like a massive hack,
1042 // but is actually what qemu does.
1043 assert(sizeof(*mask) >= 8);
1044 kvm_mask->len = 8;
1045 memcpy(kvm_mask->sigset, mask, kvm_mask->len);
1046 }
1047
1048 if (ioctl(KVM_SET_SIGNAL_MASK, (void *)kvm_mask.get()) == -1)
1049 panic("KVM: Failed to set vCPU signal mask (errno: %i)\n",
1050 errno);
1051}
1052
1053int
1054BaseKvmCPU::ioctl(int request, long p1) const
1055{
1056 if (vcpuFD == -1)
1057 panic("KVM: CPU ioctl called before initialization\n");
1058
1059 return ::ioctl(vcpuFD, request, p1);
1060}
1061
1062Tick
1063BaseKvmCPU::flushCoalescedMMIO()
1064{
1065 if (!mmioRing)
1066 return 0;
1067
1068 DPRINTF(KvmIO, "KVM: Flushing the coalesced MMIO ring buffer\n");
1069
1070 // TODO: We might need to do synchronization when we start to
1071 // support multiple CPUs
1072 Tick ticks(0);
1073 while (mmioRing->first != mmioRing->last) {
1074 struct kvm_coalesced_mmio &ent(
1075 mmioRing->coalesced_mmio[mmioRing->first]);
1076
1077 DPRINTF(KvmIO, "KVM: Handling coalesced MMIO (addr: 0x%x, len: %u)\n",
1078 ent.phys_addr, ent.len);
1079
1080 ++numCoalescedMMIO;
1081 ticks += doMMIOAccess(ent.phys_addr, ent.data, ent.len, true);
1082
1083 mmioRing->first = (mmioRing->first + 1) % KVM_COALESCED_MMIO_MAX;
1084 }
1085
1086 return ticks;
1087}
1088
1089/**
1090 * Dummy handler for KVM kick signals.
1091 *
1092 * @note This function is usually not called since the kernel doesn't
1093 * seem to deliver signals when the signal is only unmasked when
1094 * running in KVM. This doesn't matter though since we are only
1095 * interested in getting KVM to exit, which happens as expected. See
1096 * setupSignalHandler() and kvmRun() for details about KVM signal
1097 * handling.
1098 */
1099static void
1100onKickSignal(int signo, siginfo_t *si, void *data)
1101{
1102}
1103
1104void
1105BaseKvmCPU::setupSignalHandler()
1106{
1107 struct sigaction sa;
1108
1109 memset(&sa, 0, sizeof(sa));
1110 sa.sa_sigaction = onKickSignal;
1111 sa.sa_flags = SA_SIGINFO | SA_RESTART;
1112 if (sigaction(KVM_KICK_SIGNAL, &sa, NULL) == -1)
1113 panic("KVM: Failed to setup vCPU timer signal handler\n");
1114
1115 sigset_t sigset;
1116 if (pthread_sigmask(SIG_BLOCK, NULL, &sigset) == -1)
1117 panic("KVM: Failed get signal mask\n");
1118
1119 // Request KVM to setup the same signal mask as we're currently
1120 // running with except for the KVM control signal. We'll sometimes
1121 // need to raise the KVM_KICK_SIGNAL to cause immediate exits from
1122 // KVM after servicing IO requests. See kvmRun().
1123 sigdelset(&sigset, KVM_KICK_SIGNAL);
1124 setSignalMask(&sigset);
1125
1126 // Mask our control signals so they aren't delivered unless we're
1127 // actually executing inside KVM.
1128 sigaddset(&sigset, KVM_KICK_SIGNAL);
1129 if (pthread_sigmask(SIG_SETMASK, &sigset, NULL) == -1)
1130 panic("KVM: Failed mask the KVM control signals\n");
1131}
1132
1133bool
1134BaseKvmCPU::discardPendingSignal(int signum) const
1135{
1136 int discardedSignal;
1137
1138 // Setting the timeout to zero causes sigtimedwait to return
1139 // immediately.
1140 struct timespec timeout;
1141 timeout.tv_sec = 0;
1142 timeout.tv_nsec = 0;
1143
1144 sigset_t sigset;
1145 sigemptyset(&sigset);
1146 sigaddset(&sigset, signum);
1147
1148 do {
1149 discardedSignal = sigtimedwait(&sigset, NULL, &timeout);
1150 } while (discardedSignal == -1 && errno == EINTR);
1151
1152 if (discardedSignal == signum)
1153 return true;
1154 else if (discardedSignal == -1 && errno == EAGAIN)
1155 return false;
1156 else
1157 panic("Unexpected return value from sigtimedwait: %i (errno: %i)\n",
1158 discardedSignal, errno);
1159}
1160
1161void
1162BaseKvmCPU::setupCounters()
1163{
1164 DPRINTF(Kvm, "Attaching cycle counter...\n");
1165 PerfKvmCounterConfig cfgCycles(PERF_TYPE_HARDWARE,
1166 PERF_COUNT_HW_CPU_CYCLES);
1167 cfgCycles.disabled(true)
1168 .pinned(true);
1169
1170 // Try to exclude the host. We set both exclude_hv and
1171 // exclude_host since different architectures use slightly
1172 // different APIs in the kernel.
1173 cfgCycles.exclude_hv(true)
1174 .exclude_host(true);
1175
1176 if (perfControlledByTimer) {
1177 // We need to configure the cycles counter to send overflows
1178 // since we are going to use it to trigger timer signals that
1179 // trap back into m5 from KVM. In practice, this means that we
1180 // need to set some non-zero sample period that gets
1181 // overridden when the timer is armed.
1182 cfgCycles.wakeupEvents(1)
1183 .samplePeriod(42);
1184 }
1185
1186 hwCycles.attach(cfgCycles,
1187 0); // TID (0 => currentThread)
1188
1189 setupInstCounter();
1190}
1191
1192bool
1193BaseKvmCPU::tryDrain()
1194{
1195 if (!drainManager)
1196 return false;
1197
1198 if (!archIsDrained()) {
1199 DPRINTF(Drain, "tryDrain: Architecture code is not ready.\n");
1200 return false;
1201 }
1202
1203 if (_status == Idle || _status == Running) {
1204 DPRINTF(Drain,
1205 "tryDrain: CPU transitioned into the Idle state, drain done\n");
1206 drainManager->signalDrainDone();
1207 drainManager = NULL;
1208 return true;
1209 } else {
1210 DPRINTF(Drain, "tryDrain: CPU not ready.\n");
1211 return false;
1212 }
1213}
1214
1215void
1216BaseKvmCPU::ioctlRun()
1217{
1218 if (ioctl(KVM_RUN) == -1) {
1219 if (errno != EINTR)
1220 panic("KVM: Failed to start virtual CPU (errno: %i)\n",
1221 errno);
1222 }
1223}
1224
1225void
1226BaseKvmCPU::setupInstStop()
1227{
1228 if (comInstEventQueue[0]->empty()) {
1229 setupInstCounter(0);
1230 } else {
1231 const uint64_t next(comInstEventQueue[0]->nextTick());
1232
1233 assert(next > ctrInsts);
1234 setupInstCounter(next - ctrInsts);
1235 }
1236}
1237
1238void
1239BaseKvmCPU::setupInstCounter(uint64_t period)
1240{
1241 // No need to do anything if we aren't attaching for the first
1242 // time or the period isn't changing.
1243 if (period == activeInstPeriod && hwInstructions.attached())
1244 return;
1245
1246 PerfKvmCounterConfig cfgInstructions(PERF_TYPE_HARDWARE,
1247 PERF_COUNT_HW_INSTRUCTIONS);
1248
1249 // Try to exclude the host. We set both exclude_hv and
1250 // exclude_host since different architectures use slightly
1251 // different APIs in the kernel.
1252 cfgInstructions.exclude_hv(true)
1253 .exclude_host(true);
1254
1255 if (period) {
1256 // Setup a sampling counter if that has been requested.
1257 cfgInstructions.wakeupEvents(1)
1258 .samplePeriod(period);
1259 }
1260
1261 // We need to detach and re-attach the counter to reliably change
1262 // sampling settings. See PerfKvmCounter::period() for details.
1263 if (hwInstructions.attached())
1264 hwInstructions.detach();
1265 assert(hwCycles.attached());
1266 hwInstructions.attach(cfgInstructions,
1267 0, // TID (0 => currentThread)
1268 hwCycles);
1269
1270 if (period)
1271 hwInstructions.enableSignals(KVM_KICK_SIGNAL);
1272
1273 activeInstPeriod = period;
1274}
|