PGMHandler.cpp@ 73494

Last change on this file since 73494 was 73097, checked in by vboxsync, 6 years ago
*: Made RT_UOFFSETOF, RT_OFFSETOF, RT_UOFFSETOF_ADD and RT_OFFSETOF_ADD work like builtin_offsetof() and require compile time resolvable requests, adding RT_UOFFSETOF_DYN for the dynamic questions that can only be answered at runtime.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 36.6 KB

Line
1	/* $Id: PGMHandler.cpp 73097 2018-07-12 21:06:33Z vboxsync $ */
2	/** @file
3	* PGM - Page Manager / Monitor, Access Handlers.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PGM
23	#include <VBox/vmm/dbgf.h>
24	#include <VBox/vmm/pgm.h>
25	#include <VBox/vmm/cpum.h>
26	#include <VBox/vmm/iom.h>
27	#include <VBox/sup.h>
28	#include <VBox/vmm/mm.h>
29	#include <VBox/vmm/em.h>
30	#include <VBox/vmm/stam.h>
31	#include <VBox/vmm/csam.h>
32	#ifdef VBOX_WITH_REM
33	# include <VBox/vmm/rem.h>
34	#endif
35	#include <VBox/vmm/dbgf.h>
36	#ifdef VBOX_WITH_REM
37	# include <VBox/vmm/rem.h>
38	#endif
39	#include <VBox/vmm/selm.h>
40	#include <VBox/vmm/ssm.h>
41	#include "PGMInternal.h"
42	#include <VBox/vmm/vm.h>
43	#include "PGMInline.h"
44	#include <VBox/dbg.h>
45
46	#include <VBox/log.h>
47	#include <iprt/assert.h>
48	#include <iprt/alloc.h>
49	#include <iprt/asm.h>
50	#include <iprt/thread.h>
51	#include <iprt/string.h>
52	#include <VBox/param.h>
53	#include <VBox/err.h>
54	#include <VBox/vmm/hm.h>
55
56
57	/*********************************************************************************************************************************
58	* Internal Functions *
59	*********************************************************************************************************************************/
60	static DECLCALLBACK(int) pgmR3HandlerPhysicalOneClear(PAVLROGCPHYSNODECORE pNode, void *pvUser);
61	static DECLCALLBACK(int) pgmR3HandlerPhysicalOneSet(PAVLROGCPHYSNODECORE pNode, void *pvUser);
62	static DECLCALLBACK(int) pgmR3InfoHandlersPhysicalOne(PAVLROGCPHYSNODECORE pNode, void *pvUser);
63	#ifdef VBOX_WITH_RAW_MODE
64	static DECLCALLBACK(int) pgmR3InfoHandlersVirtualOne(PAVLROGCPTRNODECORE pNode, void *pvUser);
65	#endif
66
67
68
69
70	/**
71	* Register a physical page access handler type, extended version.
72	*
73	* @returns VBox status code.
74	* @param pVM The cross context VM structure.
75	* @param enmKind The kind of access handler.
76	* @param pfnHandlerR3 Pointer to the ring-3 handler callback.
77	* @param pfnHandlerR0 Pointer to the ring-0 handler callback.
78	* @param pfnPfHandlerR0 Pointer to the ring-0 \#PF handler callback.
79	* @param pfnHandlerRC Pointer to the raw-mode context handler callback.
80	* @param pfnPfHandlerRC Pointer to the raw-mode context \#PF handler
81	* callback.
82	* @param pszDesc The type description.
83	* @param phType Where to return the type handle (cross context
84	* safe).
85	*/
86	VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegisterEx(PVM pVM, PGMPHYSHANDLERKIND enmKind,
87	PFNPGMPHYSHANDLER pfnHandlerR3,
88	R0PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR0,
89	R0PTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerR0,
90	RCPTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerRC,
91	RCPTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerRC,
92	const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
93	{
94	AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
95	AssertReturn(pfnHandlerR0 != NIL_RTR0PTR, VERR_INVALID_POINTER);
96	AssertReturn(pfnPfHandlerR0 != NIL_RTR0PTR, VERR_INVALID_POINTER);
97	AssertReturn(pfnHandlerRC != NIL_RTRCPTR \|\| !VM_IS_RAW_MODE_ENABLED(pVM), VERR_INVALID_POINTER);
98	AssertReturn(pfnPfHandlerRC != NIL_RTRCPTR \|\| !VM_IS_RAW_MODE_ENABLED(pVM), VERR_INVALID_POINTER);
99	AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
100	AssertReturn( enmKind == PGMPHYSHANDLERKIND_WRITE
101	\|\| enmKind == PGMPHYSHANDLERKIND_ALL
102	\|\| enmKind == PGMPHYSHANDLERKIND_MMIO,
103	VERR_INVALID_PARAMETER);
104
105	PPGMPHYSHANDLERTYPEINT pType;
106	int rc = MMHyperAlloc(pVM, sizeof(pType), 0, MM_TAG_PGM_HANDLER_TYPES, (void *)&pType);
107	if (RT_SUCCESS(rc))
108	{
109	pType->u32Magic = PGMPHYSHANDLERTYPEINT_MAGIC;
110	pType->cRefs = 1;
111	pType->enmKind = enmKind;
112	pType->uState = enmKind == PGMPHYSHANDLERKIND_WRITE
113	? PGM_PAGE_HNDL_PHYS_STATE_WRITE : PGM_PAGE_HNDL_PHYS_STATE_ALL;
114	pType->pfnHandlerR3 = pfnHandlerR3;
115	pType->pfnHandlerR0 = pfnHandlerR0;
116	pType->pfnPfHandlerR0 = pfnPfHandlerR0;
117	pType->pfnHandlerRC = pfnHandlerRC;
118	pType->pfnPfHandlerRC = pfnPfHandlerRC;
119	pType->pszDesc = pszDesc;
120
121	pgmLock(pVM);
122	RTListOff32Append(&pVM->pgm.s.CTX_SUFF(pTrees)->HeadPhysHandlerTypes, &pType->ListNode);
123	pgmUnlock(pVM);
124
125	*phType = MMHyperHeapPtrToOffset(pVM, pType);
126	LogFlow(("PGMR3HandlerPhysicalTypeRegisterEx: %p/%#x: enmKind=%d pfnHandlerR3=%RHv pfnHandlerR0=%RHv pfnHandlerRC=%RRv pszDesc=%s\n",
127	pType, *phType, enmKind, pfnHandlerR3, pfnPfHandlerR0, pfnPfHandlerRC, pszDesc));
128	return VINF_SUCCESS;
129	}
130	*phType = NIL_PGMPHYSHANDLERTYPE;
131	return rc;
132	}
133
134
135	/**
136	* Register a physical page access handler type.
137	*
138	* @returns VBox status code.
139	* @param pVM The cross context VM structure.
140	* @param enmKind The kind of access handler.
141	* @param pfnHandlerR3 Pointer to the ring-3 handler callback.
142	* @param pszModR0 The name of the ring-0 module, NULL is an alias for
143	* the main ring-0 module.
144	* @param pszHandlerR0 The name of the ring-0 handler, NULL if the ring-3
145	* handler should be called.
146	* @param pszPfHandlerR0 The name of the ring-0 \#PF handler, NULL if the
147	* ring-3 handler should be called.
148	* @param pszModRC The name of the raw-mode context module, NULL is an
149	* alias for the main RC module.
150	* @param pszHandlerRC The name of the raw-mode context handler, NULL if
151	* the ring-3 handler should be called.
152	* @param pszPfHandlerRC The name of the raw-mode context \#PF handler, NULL
153	* if the ring-3 handler should be called.
154	* @param pszDesc The type description.
155	* @param phType Where to return the type handle (cross context
156	* safe).
157	*/
158	VMMR3DECL(int) PGMR3HandlerPhysicalTypeRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind,
159	R3PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR3,
160	const char pszModR0, const char pszHandlerR0, const char *pszPfHandlerR0,
161	const char pszModRC, const char pszHandlerRC, const char *pszPfHandlerRC,
162	const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
163	{
164	LogFlow(("PGMR3HandlerPhysicalTypeRegister: enmKind=%d pfnHandlerR3=%RHv pszModR0=%s pszHandlerR0=%s pszPfHandlerR0=%s pszModRC=%s pszHandlerRC=%s pszPfHandlerRC=%s pszDesc=%s\n",
165	enmKind, pfnHandlerR3, pszModR0, pszHandlerR0, pszPfHandlerR0, pszModRC, pszHandlerRC, pszPfHandlerRC, pszDesc));
166
167	/*
168	* Validate input.
169	*/
170	AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
171	AssertPtrNullReturn(pszModR0, VERR_INVALID_POINTER);
172	AssertPtrNullReturn(pszHandlerR0, VERR_INVALID_POINTER);
173	AssertPtrNullReturn(pszPfHandlerR0, VERR_INVALID_POINTER);
174	AssertPtrNullReturn(pszModRC, VERR_INVALID_POINTER);
175	AssertPtrNullReturn(pszHandlerRC, VERR_INVALID_POINTER);
176	AssertPtrNullReturn(pszPfHandlerRC, VERR_INVALID_POINTER);
177
178	/*
179	* Resolve the R0 handlers.
180	*/
181	R0PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR0 = NIL_RTR0PTR;
182	int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pszHandlerR0 ? pszModR0 : NULL, NULL /pszSearchPath/,
183	pszHandlerR0 ? pszHandlerR0 : "pgmPhysHandlerRedirectToHC", &pfnHandlerR0);
184	if (RT_SUCCESS(rc))
185	{
186	R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0 = NIL_RTR0PTR;
187	rc = PDMR3LdrGetSymbolR0Lazy(pVM, pszPfHandlerR0 ? pszModR0 : NULL, NULL /pszSearchPath/,
188	pszPfHandlerR0 ? pszPfHandlerR0 : "pgmPhysPfHandlerRedirectToHC", &pfnPfHandlerR0);
189	if (RT_SUCCESS(rc))
190	{
191	/*
192	* Resolve the GC handler.
193	*/
194	RTRCPTR pfnHandlerRC = NIL_RTRCPTR;
195	RTRCPTR pfnPfHandlerRC = NIL_RTRCPTR;
196	if (VM_IS_RAW_MODE_ENABLED(pVM))
197	{
198	rc = PDMR3LdrGetSymbolRCLazy(pVM, pszHandlerRC ? pszModRC : NULL, NULL /pszSearchPath/,
199	pszHandlerRC ? pszHandlerRC : "pgmPhysHandlerRedirectToHC", &pfnHandlerRC);
200	if (RT_SUCCESS(rc))
201	{
202	rc = PDMR3LdrGetSymbolRCLazy(pVM, pszPfHandlerRC ? pszModRC : NULL, NULL /pszSearchPath/,
203	pszPfHandlerRC ? pszPfHandlerRC : "pgmPhysPfHandlerRedirectToHC", &pfnPfHandlerRC);
204	AssertMsgRC(rc, ("Failed to resolve %s.%s, rc=%Rrc.\n", pszPfHandlerRC ? pszModRC : VMMRC_MAIN_MODULE_NAME,
205	pszPfHandlerRC ? pszPfHandlerRC : "pgmPhysPfHandlerRedirectToHC", rc));
206	}
207	else
208	AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszHandlerRC ? pszModRC : VMMRC_MAIN_MODULE_NAME,
209	pszHandlerRC ? pszHandlerRC : "pgmPhysHandlerRedirectToHC", rc));
210
211	}
212	if (RT_SUCCESS(rc))
213	return PGMR3HandlerPhysicalTypeRegisterEx(pVM, enmKind, pfnHandlerR3,
214	pfnHandlerR0, pfnPfHandlerR0,
215	pfnHandlerRC, pfnPfHandlerRC,
216	pszDesc, phType);
217	}
218	else
219	AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszPfHandlerR0 ? pszModR0 : VMMR0_MAIN_MODULE_NAME,
220	pszPfHandlerR0 ? pszPfHandlerR0 : "pgmPhysHandlerRedirectToHC", rc));
221	}
222	else
223	AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszHandlerR0 ? pszModR0 : VMMR0_MAIN_MODULE_NAME,
224	pszHandlerR0 ? pszHandlerR0 : "pgmPhysHandlerRedirectToHC", rc));
225
226	return rc;
227	}
228
229
230	/**
231	* Updates the physical page access handlers.
232	*
233	* @param pVM The cross context VM structure.
234	* @remark Only used when restoring a saved state.
235	*/
236	void pgmR3HandlerPhysicalUpdateAll(PVM pVM)
237	{
238	LogFlow(("pgmHandlerPhysicalUpdateAll:\n"));
239
240	/*
241	* Clear and set.
242	* (the right -> left on the setting pass is just bird speculating on cache hits)
243	*/
244	pgmLock(pVM);
245	RTAvlroGCPhysDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, true, pgmR3HandlerPhysicalOneClear, pVM);
246	RTAvlroGCPhysDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, false, pgmR3HandlerPhysicalOneSet, pVM);
247	pgmUnlock(pVM);
248	}
249
250
251	/**
252	* Clears all the page level flags for one physical handler range.
253	*
254	* @returns 0
255	* @param pNode Pointer to a PGMPHYSHANDLER.
256	* @param pvUser Pointer to the VM.
257	*/
258	static DECLCALLBACK(int) pgmR3HandlerPhysicalOneClear(PAVLROGCPHYSNODECORE pNode, void *pvUser)
259	{
260	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)pNode;
261	PPGMRAMRANGE pRamHint = NULL;
262	RTGCPHYS GCPhys = pCur->Core.Key;
263	RTUINT cPages = pCur->cPages;
264	PVM pVM = (PVM)pvUser;
265	for (;;)
266	{
267	PPGMPAGE pPage;
268	int rc = pgmPhysGetPageWithHintEx(pVM, GCPhys, &pPage, &pRamHint);
269	if (RT_SUCCESS(rc))
270	{
271	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_NONE);
272
273	/* Tell NEM about the protection change. */
274	if (VM_IS_NEM_ENABLED(pVM))
275	{
276	uint8_t u2State = PGM_PAGE_GET_NEM_STATE(pPage);
277	PGMPAGETYPE enmType = (PGMPAGETYPE)PGM_PAGE_GET_TYPE(pPage);
278	NEMHCNotifyPhysPageProtChanged(pVM, GCPhys, PGM_PAGE_GET_HCPHYS(pPage),
279	pgmPhysPageCalcNemProtection(pPage, enmType), enmType, &u2State);
280	PGM_PAGE_SET_NEM_STATE(pPage, u2State);
281	}
282	}
283	else
284	AssertRC(rc);
285
286	if (--cPages == 0)
287	return 0;
288	GCPhys += PAGE_SIZE;
289	}
290	}
291
292
293	/**
294	* Sets all the page level flags for one physical handler range.
295	*
296	* @returns 0
297	* @param pNode Pointer to a PGMPHYSHANDLER.
298	* @param pvUser Pointer to the VM.
299	*/
300	static DECLCALLBACK(int) pgmR3HandlerPhysicalOneSet(PAVLROGCPHYSNODECORE pNode, void *pvUser)
301	{
302	PVM pVM = (PVM)pvUser;
303	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)pNode;
304	PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
305	unsigned uState = pCurType->uState;
306	PPGMRAMRANGE pRamHint = NULL;
307	RTGCPHYS GCPhys = pCur->Core.Key;
308	RTUINT cPages = pCur->cPages;
309	for (;;)
310	{
311	PPGMPAGE pPage;
312	int rc = pgmPhysGetPageWithHintEx(pVM, GCPhys, &pPage, &pRamHint);
313	if (RT_SUCCESS(rc))
314	{
315	PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, uState);
316
317	/* Tell NEM about the protection change. */
318	if (VM_IS_NEM_ENABLED(pVM))
319	{
320	uint8_t u2State = PGM_PAGE_GET_NEM_STATE(pPage);
321	PGMPAGETYPE enmType = (PGMPAGETYPE)PGM_PAGE_GET_TYPE(pPage);
322	NEMHCNotifyPhysPageProtChanged(pVM, GCPhys, PGM_PAGE_GET_HCPHYS(pPage),
323	pgmPhysPageCalcNemProtection(pPage, enmType), enmType, &u2State);
324	PGM_PAGE_SET_NEM_STATE(pPage, u2State);
325	}
326	}
327	else
328	AssertRC(rc);
329
330	if (--cPages == 0)
331	return 0;
332	GCPhys += PAGE_SIZE;
333	}
334	}
335
336	#ifdef VBOX_WITH_RAW_MODE
337
338	/**
339	* Register a virtual page access handler type, extended version.
340	*
341	* @returns VBox status code.
342	* @param pVM The cross context VM structure.
343	* @param enmKind The kind of access handler.
344	* @param fRelocUserRC Whether the pvUserRC argument should be
345	* automatically relocated or not.
346	* @param pfnInvalidateR3 Pointer to the ring-3 invalidation handler callback.
347	* Warning! This callback stopped working in VBox v1.2!
348	* @param pfnHandlerR3 Pointer to the ring-3 handler callback.
349	* @param pfnHandlerRC Pointer to the raw-mode context handler callback.
350	* @param pfnPfHandlerRC Pointer to the raw-mode context \#PF handler
351	* callback.
352	* @param pszDesc The type description.
353	* @param phType Where to return the type handle (cross context
354	* safe).
355	* @remarks No virtual handlers when executing using HM (i.e. ring-0).
356	*/
357	VMMR3_INT_DECL(int) PGMR3HandlerVirtualTypeRegisterEx(PVM pVM, PGMVIRTHANDLERKIND enmKind, bool fRelocUserRC,
358	PFNPGMR3VIRTINVALIDATE pfnInvalidateR3,
359	PFNPGMVIRTHANDLER pfnHandlerR3,
360	RCPTRTYPE(FNPGMVIRTHANDLER) pfnHandlerRC,
361	RCPTRTYPE(FNPGMRCVIRTPFHANDLER) pfnPfHandlerRC,
362	const char *pszDesc, PPGMVIRTHANDLERTYPE phType)
363	{
364	AssertReturn(VM_IS_RAW_MODE_ENABLED(pVM), VERR_NOT_AVAILABLE); /* Only supported/relevant for raw-mode. */
365	AssertReturn( enmKind == PGMVIRTHANDLERKIND_WRITE
366	\|\| enmKind == PGMVIRTHANDLERKIND_ALL
367	\|\| enmKind == PGMVIRTHANDLERKIND_HYPERVISOR,
368	VERR_INVALID_PARAMETER);
369	if (enmKind != PGMVIRTHANDLERKIND_HYPERVISOR)
370	{
371	AssertPtrNullReturn(pfnInvalidateR3, VERR_INVALID_POINTER);
372	AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
373	AssertReturn(pfnHandlerRC != NIL_RTRCPTR, VERR_INVALID_POINTER);
374	}
375	else
376	{
377	AssertReturn(pfnInvalidateR3 == NULL, VERR_INVALID_POINTER);
378	AssertReturn(pfnHandlerR3 == NULL, VERR_INVALID_POINTER);
379	AssertReturn(pfnHandlerRC == NIL_RTR0PTR, VERR_INVALID_POINTER);
380	}
381	AssertReturn(pfnPfHandlerRC != NIL_RTRCPTR, VERR_INVALID_POINTER);
382	AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
383
384	PPGMVIRTHANDLERTYPEINT pType;
385	int rc = MMHyperAlloc(pVM, sizeof(pType), 0, MM_TAG_PGM_HANDLER_TYPES, (void *)&pType);
386	if (RT_SUCCESS(rc))
387	{
388	pType->u32Magic = PGMVIRTHANDLERTYPEINT_MAGIC;
389	pType->cRefs = 1;
390	pType->enmKind = enmKind;
391	pType->fRelocUserRC = fRelocUserRC;
392	pType->uState = enmKind == PGMVIRTHANDLERKIND_ALL
393	? PGM_PAGE_HNDL_VIRT_STATE_ALL : PGM_PAGE_HNDL_VIRT_STATE_WRITE;
394	pType->pfnInvalidateR3 = pfnInvalidateR3;
395	pType->pfnHandlerR3 = pfnHandlerR3;
396	pType->pfnHandlerRC = pfnHandlerRC;
397	pType->pfnPfHandlerRC = pfnPfHandlerRC;
398	pType->pszDesc = pszDesc;
399
400	pgmLock(pVM);
401	RTListOff32Append(&pVM->pgm.s.CTX_SUFF(pTrees)->HeadVirtHandlerTypes, &pType->ListNode);
402	pgmUnlock(pVM);
403
404	*phType = MMHyperHeapPtrToOffset(pVM, pType);
405	LogFlow(("PGMR3HandlerVirtualTypeRegisterEx: %p/%#x: enmKind=%d pfnInvalidateR3=%RHv pfnHandlerR3=%RHv pfnPfHandlerRC=%RRv pszDesc=%s\n",
406	pType, *phType, enmKind, pfnInvalidateR3, pfnHandlerR3, pfnPfHandlerRC, pszDesc));
407	return VINF_SUCCESS;
408	}
409	*phType = NIL_PGMVIRTHANDLERTYPE;
410	return rc;
411	}
412
413
414	/**
415	* Register a physical page access handler type.
416	*
417	* @returns VBox status code.
418	* @param pVM The cross context VM structure.
419	* @param enmKind The kind of access handler.
420	* @param fRelocUserRC Whether the pvUserRC argument should be
421	* automatically relocated or not.
422	* @param pfnInvalidateR3 Pointer to the ring-3 invalidateion callback
423	* (optional, can be NULL).
424	* @param pfnHandlerR3 Pointer to the ring-3 handler callback.
425	* @param pszHandlerRC The name of the raw-mode context handler callback
426	* (in VMMRC.rc).
427	* @param pszPfHandlerRC The name of the raw-mode context \#PF handler (in
428	* VMMRC.rc).
429	* @param pszDesc The type description.
430	* @param phType Where to return the type handle (cross context
431	* safe).
432	* @remarks No virtual handlers when executing using HM (i.e. ring-0).
433	*/
434	VMMR3_INT_DECL(int) PGMR3HandlerVirtualTypeRegister(PVM pVM, PGMVIRTHANDLERKIND enmKind, bool fRelocUserRC,
435	PFNPGMR3VIRTINVALIDATE pfnInvalidateR3,
436	PFNPGMVIRTHANDLER pfnHandlerR3,
437	const char pszHandlerRC, const char pszPfHandlerRC, const char *pszDesc,
438	PPGMVIRTHANDLERTYPE phType)
439	{
440	LogFlow(("PGMR3HandlerVirtualTypeRegister: enmKind=%d pfnInvalidateR3=%RHv pfnHandlerR3=%RHv pszPfHandlerRC=%s pszDesc=%s\n",
441	enmKind, pfnInvalidateR3, pfnHandlerR3, pszPfHandlerRC, pszDesc));
442
443	/*
444	* Validate input.
445	*/
446	AssertPtrNullReturn(pszHandlerRC, VERR_INVALID_POINTER);
447	AssertPtrReturn(pszPfHandlerRC, VERR_INVALID_POINTER);
448
449	/*
450	* Resolve the GC handler.
451	*/
452	RTRCPTR pfnHandlerRC = NIL_RTRCPTR;
453	int rc = VINF_SUCCESS;
454	if (pszHandlerRC)
455	rc = PDMR3LdrGetSymbolRCLazy(pVM, VMMRC_MAIN_MODULE_NAME, NULL /pszSearchPath/, pszHandlerRC, &pfnHandlerRC);
456	if (RT_SUCCESS(rc))
457	{
458	RTRCPTR pfnPfHandlerRC = NIL_RTRCPTR;
459	rc = PDMR3LdrGetSymbolRCLazy(pVM, VMMRC_MAIN_MODULE_NAME, NULL /pszSearchPath/, pszPfHandlerRC, &pfnPfHandlerRC);
460	if (RT_SUCCESS(rc))
461	return PGMR3HandlerVirtualTypeRegisterEx(pVM, enmKind, fRelocUserRC,
462	pfnInvalidateR3, pfnHandlerR3,
463	pfnHandlerRC, pfnPfHandlerRC,
464	pszDesc, phType);
465
466	AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", VMMRC_MAIN_MODULE_NAME, pszPfHandlerRC, rc));
467	}
468	else
469	AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", VMMRC_MAIN_MODULE_NAME, pszHandlerRC, rc));
470	return rc;
471	}
472
473
474	/**
475	* Register a access handler for a virtual range.
476	*
477	* @returns VBox status code.
478	* @param pVM The cross context VM structure.
479	* @param pVCpu The cross context virtual CPU structure of the
480	* calling EMT.
481	* @param hType The handler type.
482	* @param GCPtr Start address.
483	* @param GCPtrLast Last address (inclusive).
484	* @param pvUserR3 The ring-3 context user argument.
485	* @param pvUserRC The raw-mode context user argument. Whether this is
486	* automatically relocated or not depends on the type.
487	* @param pszDesc Pointer to description string. This must not be freed.
488	*/
489	VMMR3_INT_DECL(int) PGMR3HandlerVirtualRegister(PVM pVM, PVMCPU pVCpu, PGMVIRTHANDLERTYPE hType, RTGCPTR GCPtr, RTGCPTR GCPtrLast,
490	void pvUserR3, RTRCPTR pvUserRC, const char pszDesc)
491	{
492	AssertReturn(VM_IS_RAW_MODE_ENABLED(pVM), VERR_NOT_AVAILABLE); /* Only supported/relevant for raw-mode. */
493	PPGMVIRTHANDLERTYPEINT pType = PGMVIRTHANDLERTYPEINT_FROM_HANDLE(pVM, hType);
494	Log(("PGMR3HandlerVirtualRegister: GCPhys=%RGp GCPhysLast=%RGp pvUserR3=%RHv pvUserGC=%RRv hType=%#x (%d, %s) pszDesc=%RHv:%s\n",
495	GCPtr, GCPtrLast, pvUserR3, pvUserRC, hType, pType->enmKind, R3STRING(pType->pszDesc), pszDesc, R3STRING(pszDesc)));
496
497	/*
498	* Validate input.
499	*/
500	AssertReturn(pType->u32Magic == PGMVIRTHANDLERTYPEINT_MAGIC, VERR_INVALID_HANDLE);
501	AssertMsgReturn(GCPtr < GCPtrLast, ("GCPtr >= GCPtrLast (%RGp >= %RGp)\n", GCPtr, GCPtrLast), VERR_INVALID_PARAMETER);
502	switch (pType->enmKind)
503	{
504	case PGMVIRTHANDLERKIND_ALL:
505	/* Simplification for PGMPhysRead and others: Full pages. */
506	AssertReleaseMsgReturn( (GCPtr & PAGE_OFFSET_MASK) == 0
507	&& (GCPtrLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK,
508	("PGMVIRTHANDLERKIND_ALL: GCPtr=%RGv GCPtrLast=%RGv\n", GCPtr, GCPtrLast),
509	VERR_NOT_IMPLEMENTED);
510	break;
511	case PGMVIRTHANDLERKIND_WRITE:
512	case PGMVIRTHANDLERKIND_HYPERVISOR:
513	break;
514	default:
515	AssertMsgFailedReturn(("Invalid enmKind=%d!\n", pType->enmKind), VERR_INVALID_PARAMETER);
516	}
517	AssertMsgReturn( (RTRCUINTPTR)pvUserRC < 0x10000
518	\|\| MMHyperR3ToRC(pVM, MMHyperRCToR3(pVM, pvUserRC)) == pvUserRC,
519	("Not RC pointer! pvUserRC=%RRv\n", pvUserRC),
520	VERR_INVALID_PARAMETER);
521
522	/*
523	* Allocate and initialize a new entry.
524	*/
525	unsigned cPages = (RT_ALIGN(GCPtrLast + 1, PAGE_SIZE) - (GCPtr & PAGE_BASE_GC_MASK)) >> PAGE_SHIFT;
526	PPGMVIRTHANDLER pNew;
527	int rc = MMHyperAlloc(pVM, RT_UOFFSETOF_DYN(PGMVIRTHANDLER, aPhysToVirt[cPages]), 0, MM_TAG_PGM_HANDLERS, (void )&pNew); / @todo r=bird: incorrect member name PhysToVirt? */
528	if (RT_FAILURE(rc))
529	return rc;
530
531	pNew->Core.Key = GCPtr;
532	pNew->Core.KeyLast = GCPtrLast;
533
534	pNew->hType = hType;
535	pNew->pvUserRC = pvUserRC;
536	pNew->pvUserR3 = pvUserR3;
537	pNew->pszDesc = pszDesc ? pszDesc : pType->pszDesc;
538	pNew->cb = GCPtrLast - GCPtr + 1;
539	pNew->cPages = cPages;
540	/* Will be synced at next guest execution attempt. */
541	while (cPages-- > 0)
542	{
543	pNew->aPhysToVirt[cPages].Core.Key = NIL_RTGCPHYS;
544	pNew->aPhysToVirt[cPages].Core.KeyLast = NIL_RTGCPHYS;
545	pNew->aPhysToVirt[cPages].offVirtHandler = -(int32_t)RT_UOFFSETOF_DYN(PGMVIRTHANDLER, aPhysToVirt[cPages]);
546	pNew->aPhysToVirt[cPages].offNextAlias = 0;
547	}
548
549	/*
550	* Try to insert it into the tree.
551	*
552	* The current implementation doesn't allow multiple handlers for
553	* the same range this makes everything much simpler and faster.
554	*/
555	AVLROGCPTRTREE *pRoot = pType->enmKind != PGMVIRTHANDLERKIND_HYPERVISOR
556	? &pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers
557	: &pVM->pgm.s.CTX_SUFF(pTrees)->HyperVirtHandlers;
558	pgmLock(pVM);
559	if (*pRoot != 0)
560	{
561	PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrGetBestFit(pRoot, pNew->Core.Key, true);
562	if ( !pCur
563	\|\| GCPtr > pCur->Core.KeyLast
564	\|\| GCPtrLast < pCur->Core.Key)
565	pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrGetBestFit(pRoot, pNew->Core.Key, false);
566	if ( pCur
567	&& GCPtr <= pCur->Core.KeyLast
568	&& GCPtrLast >= pCur->Core.Key)
569	{
570	/*
571	* The LDT sometimes conflicts with the IDT and LDT ranges while being
572	* updated on linux. So, we don't assert simply log it.
573	*/
574	Log(("PGMR3HandlerVirtualRegister: Conflict with existing range %RGv-%RGv (%s), req. %RGv-%RGv (%s)\n",
575	pCur->Core.Key, pCur->Core.KeyLast, pCur->pszDesc, GCPtr, GCPtrLast, pszDesc));
576	MMHyperFree(pVM, pNew);
577	pgmUnlock(pVM);
578	return VERR_PGM_HANDLER_VIRTUAL_CONFLICT;
579	}
580	}
581	if (RTAvlroGCPtrInsert(pRoot, &pNew->Core))
582	{
583	if (pType->enmKind != PGMVIRTHANDLERKIND_HYPERVISOR)
584	{
585	pVCpu->pgm.s.fSyncFlags \|= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL \| PGM_SYNC_CLEAR_PGM_POOL;
586	VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
587	}
588	PGMHandlerVirtualTypeRetain(pVM, hType);
589	pgmUnlock(pVM);
590
591	#ifdef VBOX_WITH_STATISTICS
592	rc = STAMR3RegisterF(pVM, &pNew->Stat, STAMTYPE_PROFILE, STAMVISIBILITY_USED, STAMUNIT_TICKS_PER_CALL, pNew->pszDesc,
593	"/PGM/VirtHandler/Calls/%RGv-%RGv", pNew->Core.Key, pNew->Core.KeyLast);
594	AssertRC(rc);
595	#endif
596	return VINF_SUCCESS;
597	}
598
599	pgmUnlock(pVM);
600	AssertFailed();
601	MMHyperFree(pVM, pNew);
602	return VERR_PGM_HANDLER_VIRTUAL_CONFLICT;
603
604	}
605
606
607	/**
608	* Changes the type of a virtual handler.
609	*
610	* The new and old type must have the same access kind.
611	*
612	* @returns VBox status code.
613	* @param pVM The cross context VM structure.
614	* @param GCPtr Start address of the virtual handler.
615	* @param hNewType The new handler type.
616	*/
617	VMMR3_INT_DECL(int) PGMHandlerVirtualChangeType(PVM pVM, RTGCPTR GCPtr, PGMVIRTHANDLERTYPE hNewType)
618	{
619	PPGMVIRTHANDLERTYPEINT pNewType = PGMVIRTHANDLERTYPEINT_FROM_HANDLE(pVM, hNewType);
620	AssertReturn(pNewType->u32Magic == PGMVIRTHANDLERTYPEINT_MAGIC, VERR_INVALID_HANDLE);
621
622	pgmLock(pVM);
623	PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrGet(&pVM->pgm.s.pTreesR3->VirtHandlers, GCPtr);
624	if (pCur)
625	{
626	PGMVIRTHANDLERTYPE hOldType = pCur->hType;
627	PPGMVIRTHANDLERTYPEINT pOldType = PGMVIRTHANDLERTYPEINT_FROM_HANDLE(pVM, hOldType);
628	if (pOldType != pNewType)
629	{
630	AssertReturnStmt(pNewType->enmKind == pOldType->enmKind, pgmUnlock(pVM), VERR_ACCESS_DENIED);
631	PGMHandlerVirtualTypeRetain(pVM, hNewType);
632	pCur->hType = hNewType;
633	PGMHandlerVirtualTypeRelease(pVM, hOldType);
634	}
635	pgmUnlock(pVM);
636	return VINF_SUCCESS;
637	}
638	pgmUnlock(pVM);
639	AssertMsgFailed(("Range %#x not found!\n", GCPtr));
640	return VERR_INVALID_PARAMETER;
641	}
642
643
644	/**
645	* Deregister an access handler for a virtual range.
646	*
647	* @returns VBox status code.
648	* @param pVM The cross context VM structure.
649	* @param pVCpu The cross context virtual CPU structure of the calling
650	* EMT.
651	* @param GCPtr Start address.
652	* @param fHypervisor Set if PGMVIRTHANDLERKIND_HYPERVISOR, false if not.
653	* @thread EMT(pVCpu)
654	*/
655	VMMR3_INT_DECL(int) PGMHandlerVirtualDeregister(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, bool fHypervisor)
656	{
657	pgmLock(pVM);
658
659	PPGMVIRTHANDLER pCur;
660	if (!fHypervisor)
661	{
662	/*
663	* Normal guest handler.
664	*/
665	pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->VirtHandlers, GCPtr);
666	AssertMsgReturnStmt(pCur, ("GCPtr=%RGv\n", GCPtr), pgmUnlock(pVM), VERR_INVALID_PARAMETER);
667	Assert(PGMVIRTANDLER_GET_TYPE(pVM, pCur)->enmKind != PGMVIRTHANDLERKIND_HYPERVISOR);
668
669	Log(("PGMHandlerVirtualDeregister: Removing Virtual (%d) Range %RGv-%RGv %s\n",
670	PGMVIRTANDLER_GET_TYPE(pVM, pCur)->enmKind, pCur->Core.Key, pCur->Core.KeyLast, pCur->pszDesc));
671
672	/* Reset the flags and remove phys2virt nodes. */
673	for (uint32_t iPage = 0; iPage < pCur->cPages; iPage++)
674	if (pCur->aPhysToVirt[iPage].offNextAlias & PGMPHYS2VIRTHANDLER_IN_TREE)
675	pgmHandlerVirtualClearPage(pVM, pCur, iPage);
676
677	/* Schedule CR3 sync. */
678	pVCpu->pgm.s.fSyncFlags \|= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL \| PGM_SYNC_CLEAR_PGM_POOL;
679	VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
680	}
681	else
682	{
683	/*
684	* Hypervisor one (hypervisor relocation or termination only).
685	*/
686	pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->HyperVirtHandlers, GCPtr);
687	AssertMsgReturnStmt(pCur, ("GCPtr=%RGv\n", GCPtr), pgmUnlock(pVM), VERR_INVALID_PARAMETER);
688	Assert(PGMVIRTANDLER_GET_TYPE(pVM, pCur)->enmKind == PGMVIRTHANDLERKIND_HYPERVISOR);
689
690	Log(("PGMHandlerVirtualDeregister: Removing Hyper Virtual Range %RGv-%RGv %s\n",
691	pCur->Core.Key, pCur->Core.KeyLast, pCur->pszDesc));
692	}
693
694	pgmUnlock(pVM);
695
696	/*
697	* Free it.
698	*/
699	#ifdef VBOX_WITH_STATISTICS
700	STAMR3DeregisterF(pVM->pUVM, "/PGM/VirtHandler/Calls/%RGv-%RGv", pCur->Core.Key, pCur->Core.KeyLast);
701	#endif
702	PGMHandlerVirtualTypeRelease(pVM, pCur->hType);
703	MMHyperFree(pVM, pCur);
704
705	return VINF_SUCCESS;
706	}
707
708	#endif /* VBOX_WITH_RAW_MODE */
709
710
711	/**
712	* Arguments for pgmR3InfoHandlersPhysicalOne and pgmR3InfoHandlersVirtualOne.
713	*/
714	typedef struct PGMHANDLERINFOARG
715	{
716	/** The output helpers.*/
717	PCDBGFINFOHLP pHlp;
718	/** Pointer to the cross context VM handle. */
719	PVM pVM;
720	/** Set if statistics should be dumped. */
721	bool fStats;
722	} PGMHANDLERINFOARG, *PPGMHANDLERINFOARG;
723
724
725	/**
726	* Info callback for 'pgmhandlers'.
727	*
728	* @param pVM The cross context VM structure.
729	* @param pHlp The output helpers.
730	* @param pszArgs The arguments. phys or virt.
731	*/
732	DECLCALLBACK(void) pgmR3InfoHandlers(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
733	{
734	/*
735	* Test input.
736	*/
737	PGMHANDLERINFOARG Args = { pHlp, pVM, /* .fStats = */ true };
738	bool fPhysical = !pszArgs \|\| !*pszArgs;
739	bool fVirtual = fPhysical;
740	bool fHyper = fPhysical;
741	if (!fPhysical)
742	{
743	bool fAll = strstr(pszArgs, "all") != NULL;
744	fPhysical = fAll \|\| strstr(pszArgs, "phys") != NULL;
745	fVirtual = fAll \|\| strstr(pszArgs, "virt") != NULL;
746	fHyper = fAll \|\| strstr(pszArgs, "hyper")!= NULL;
747	Args.fStats = strstr(pszArgs, "nost") == NULL;
748	}
749
750	/*
751	* Dump the handlers.
752	*/
753	if (fPhysical)
754	{
755	pHlp->pfnPrintf(pHlp,
756	"Physical handlers: (PhysHandlers=%d (%#x))\n"
757	"%s %s %s %s HandlerGC UserGC Type Description\n",
758	pVM->pgm.s.pTreesR3->PhysHandlers, pVM->pgm.s.pTreesR3->PhysHandlers,
759	- (int)sizeof(RTGCPHYS) * 2, "From",
760	- (int)sizeof(RTGCPHYS) * 2 - 3, "- To (incl)",
761	- (int)sizeof(RTHCPTR) * 2 - 1, "HandlerHC",
762	- (int)sizeof(RTHCPTR) * 2 - 1, "UserHC");
763	RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesR3->PhysHandlers, true, pgmR3InfoHandlersPhysicalOne, &Args);
764	}
765
766	#ifdef VBOX_WITH_RAW_MODE
767	if (fVirtual)
768	{
769	pHlp->pfnPrintf(pHlp,
770	"Virtual handlers:\n"
771	"%s %s %s %s Type Description\n",
772	- (int)sizeof(RTGCPTR) * 2, "From",
773	- (int)sizeof(RTGCPTR) * 2 - 3, "- To (excl)",
774	- (int)sizeof(RTHCPTR) * 2 - 1, "HandlerHC",
775	- (int)sizeof(RTRCPTR) * 2 - 1, "HandlerGC");
776	RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesR3->VirtHandlers, true, pgmR3InfoHandlersVirtualOne, &Args);
777	}
778
779	if (fHyper)
780	{
781	pHlp->pfnPrintf(pHlp,
782	"Hypervisor Virtual handlers:\n"
783	"%s %s %s %s Type Description\n",
784	- (int)sizeof(RTGCPTR) * 2, "From",
785	- (int)sizeof(RTGCPTR) * 2 - 3, "- To (excl)",
786	- (int)sizeof(RTHCPTR) * 2 - 1, "HandlerHC",
787	- (int)sizeof(RTRCPTR) * 2 - 1, "HandlerGC");
788	RTAvlroGCPtrDoWithAll(&pVM->pgm.s.pTreesR3->HyperVirtHandlers, true, pgmR3InfoHandlersVirtualOne, &Args);
789	}
790	#endif
791	}
792
793
794	/**
795	* Displays one physical handler range.
796	*
797	* @returns 0
798	* @param pNode Pointer to a PGMPHYSHANDLER.
799	* @param pvUser Pointer to command helper functions.
800	*/
801	static DECLCALLBACK(int) pgmR3InfoHandlersPhysicalOne(PAVLROGCPHYSNODECORE pNode, void *pvUser)
802	{
803	PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)pNode;
804	PPGMHANDLERINFOARG pArgs = (PPGMHANDLERINFOARG)pvUser;
805	PCDBGFINFOHLP pHlp = pArgs->pHlp;
806	PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pArgs->pVM, pCur);
807	const char *pszType;
808	switch (pCurType->enmKind)
809	{
810	case PGMPHYSHANDLERKIND_MMIO: pszType = "MMIO "; break;
811	case PGMPHYSHANDLERKIND_WRITE: pszType = "Write "; break;
812	case PGMPHYSHANDLERKIND_ALL: pszType = "All "; break;
813	default: pszType = "????"; break;
814	}
815	pHlp->pfnPrintf(pHlp,
816	"%RGp - %RGp %RHv %RHv %RRv %RRv %s %s\n",
817	pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCur->pvUserR3, pCurType->pfnPfHandlerRC, pCur->pvUserRC,
818	pszType, pCur->pszDesc);
819	#ifdef VBOX_WITH_STATISTICS
820	if (pArgs->fStats)
821	pHlp->pfnPrintf(pHlp, " cPeriods: %9RU64 cTicks: %11RU64 Min: %11RU64 Avg: %11RU64 Max: %11RU64\n",
822	pCur->Stat.cPeriods, pCur->Stat.cTicks, pCur->Stat.cTicksMin,
823	pCur->Stat.cPeriods ? pCur->Stat.cTicks / pCur->Stat.cPeriods : 0, pCur->Stat.cTicksMax);
824	#endif
825	return 0;
826	}
827
828
829	#ifdef VBOX_WITH_RAW_MODE
830	/**
831	* Displays one virtual handler range.
832	*
833	* @returns 0
834	* @param pNode Pointer to a PGMVIRTHANDLER.
835	* @param pvUser Pointer to command helper functions.
836	*/
837	static DECLCALLBACK(int) pgmR3InfoHandlersVirtualOne(PAVLROGCPTRNODECORE pNode, void *pvUser)
838	{
839	PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)pNode;
840	PPGMHANDLERINFOARG pArgs = (PPGMHANDLERINFOARG)pvUser;
841	PCDBGFINFOHLP pHlp = pArgs->pHlp;
842	PPGMVIRTHANDLERTYPEINT pCurType = PGMVIRTANDLER_GET_TYPE(pArgs->pVM, pCur);
843	const char *pszType;
844	switch (pCurType->enmKind)
845	{
846	case PGMVIRTHANDLERKIND_WRITE: pszType = "Write "; break;
847	case PGMVIRTHANDLERKIND_ALL: pszType = "All "; break;
848	case PGMVIRTHANDLERKIND_HYPERVISOR: pszType = "WriteHyp "; break;
849	default: pszType = "????"; break;
850	}
851	pHlp->pfnPrintf(pHlp, "%RGv - %RGv %RHv %RRv %s %s\n",
852	pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCurType->pfnPfHandlerRC, pszType, pCur->pszDesc);
853	# ifdef VBOX_WITH_STATISTICS
854	if (pArgs->fStats)
855	pHlp->pfnPrintf(pHlp, " cPeriods: %9RU64 cTicks: %11RU64 Min: %11RU64 Avg: %11RU64 Max: %11RU64\n",
856	pCur->Stat.cPeriods, pCur->Stat.cTicks, pCur->Stat.cTicksMin,
857	pCur->Stat.cPeriods ? pCur->Stat.cTicks / pCur->Stat.cPeriods : 0, pCur->Stat.cTicksMax);
858	# endif
859	return 0;
860	}
861	#endif /* VBOX_WITH_RAW_MODE */
862

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/VMMR3/PGMHandler.cpp@ 73494

Download in other formats: