DBGFAddr.cpp@ 73472

Last change on this file since 73472 was 73471, checked in by vboxsync, 6 years ago
VMM,DBGF: Improved unwinding of ring-0 assertion stacks, making the new unwind info stuff deal correctly with ring-0 pointers and such. bugref:3897
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 17.1 KB

Line
1	/* $Id: DBGFAddr.cpp 73471 2018-08-03 12:11:07Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Mixed Address Methods.
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_DBGF
23	#include <VBox/vmm/dbgf.h>
24	#include <VBox/vmm/pgm.h>
25	#include <VBox/vmm/selm.h>
26	#include <VBox/vmm/mm.h>
27	#include <VBox/vmm/hm.h>
28	#include "DBGFInternal.h"
29	#include <VBox/vmm/vm.h>
30	#include <VBox/vmm/uvm.h>
31
32	#include <VBox/param.h>
33	#include <VBox/err.h>
34	#include <VBox/log.h>
35
36
37
38	/**
39	* Checks if an address is in the HMA or not.
40	*
41	* @retval true if it's inside the HMA.
42	* @retval flase if it's not inside the HMA.
43	*
44	* @param pUVM The user mode VM handle.
45	* @param FlatPtr The address in question.
46	*/
47	DECLINLINE(bool) dbgfR3IsHMA(PUVM pUVM, RTGCUINTPTR FlatPtr)
48	{
49	return VM_IS_RAW_MODE_ENABLED(pUVM->pVM)
50	&& MMHyperIsInsideArea(pUVM->pVM, FlatPtr);
51	}
52
53
54	/**
55	* Common worker for DBGFR3AddrFromSelOff and DBGFR3AddrFromSelInfoOff.
56	*/
57	static int dbgfR3AddrFromSelInfoOffWorker(PDBGFADDRESS pAddress, PCDBGFSELINFO pSelInfo, RTUINTPTR off)
58	{
59	if (pSelInfo->fFlags & (DBGFSELINFO_FLAGS_INVALID \| DBGFSELINFO_FLAGS_NOT_PRESENT))
60	return pSelInfo->fFlags & DBGFSELINFO_FLAGS_NOT_PRESENT
61	? VERR_SELECTOR_NOT_PRESENT
62	: VERR_INVALID_SELECTOR;
63
64	/** @todo This all goes voodoo in long mode. */
65	/* check limit. */
66	if (DBGFSelInfoIsExpandDown(pSelInfo))
67	{
68	if ( !pSelInfo->u.Raw.Gen.u1Granularity
69	&& off > UINT32_C(0xffff))
70	return VERR_OUT_OF_SELECTOR_BOUNDS;
71	if (off <= pSelInfo->cbLimit)
72	return VERR_OUT_OF_SELECTOR_BOUNDS;
73	}
74	else if (off > pSelInfo->cbLimit)
75	return VERR_OUT_OF_SELECTOR_BOUNDS;
76
77	pAddress->FlatPtr = pSelInfo->GCPtrBase + off;
78
79	/** @todo fix all these selector tests! */
80	if ( !pSelInfo->GCPtrBase
81	&& pSelInfo->u.Raw.Gen.u1Granularity
82	&& pSelInfo->u.Raw.Gen.u1DefBig)
83	pAddress->fFlags = DBGFADDRESS_FLAGS_FLAT;
84	else if (pSelInfo->cbLimit <= UINT32_C(0xffff))
85	pAddress->fFlags = DBGFADDRESS_FLAGS_FAR16;
86	else if (pSelInfo->cbLimit <= UINT32_C(0xffffffff))
87	pAddress->fFlags = DBGFADDRESS_FLAGS_FAR32;
88	else
89	pAddress->fFlags = DBGFADDRESS_FLAGS_FAR64;
90
91	return VINF_SUCCESS;
92	}
93
94
95	/**
96	* Creates a mixed address from a Sel:off pair.
97	*
98	* @returns VBox status code.
99	* @param pUVM The user mode VM handle.
100	* @param idCpu The CPU ID.
101	* @param pAddress Where to store the mixed address.
102	* @param Sel The selector part.
103	* @param off The offset part.
104	*/
105	VMMR3DECL(int) DBGFR3AddrFromSelOff(PUVM pUVM, VMCPUID idCpu, PDBGFADDRESS pAddress, RTSEL Sel, RTUINTPTR off)
106	{
107	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
108	VM_ASSERT_VALID_EXT_RETURN(pUVM->pVM, VERR_INVALID_VM_HANDLE);
109	AssertReturn(idCpu < pUVM->cCpus, VERR_INVALID_PARAMETER);
110
111	pAddress->Sel = Sel;
112	pAddress->off = off;
113	if (Sel != DBGF_SEL_FLAT)
114	{
115	DBGFSELINFO SelInfo;
116	int rc = DBGFR3SelQueryInfo(pUVM, idCpu, Sel, DBGFSELQI_FLAGS_DT_GUEST \| DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE, &SelInfo);
117	if (RT_FAILURE(rc) && VM_IS_RAW_MODE_ENABLED(pUVM->pVM))
118	rc = DBGFR3SelQueryInfo(pUVM, idCpu, Sel, DBGFSELQI_FLAGS_DT_SHADOW, &SelInfo);
119	if (RT_FAILURE(rc))
120	return rc;
121	rc = dbgfR3AddrFromSelInfoOffWorker(pAddress, &SelInfo, off);
122	if (RT_FAILURE(rc))
123	return rc;
124	if ( (SelInfo.fFlags & DBGFSELINFO_FLAGS_HYPER)
125	\|\| dbgfR3IsHMA(pUVM, pAddress->FlatPtr))
126	pAddress->fFlags \|= DBGFADDRESS_FLAGS_HMA;
127	}
128	else
129	{
130	pAddress->FlatPtr = off;
131	pAddress->fFlags = DBGFADDRESS_FLAGS_FLAT;
132	if (dbgfR3IsHMA(pUVM, pAddress->FlatPtr))
133	pAddress->fFlags \|= DBGFADDRESS_FLAGS_HMA;
134	}
135	pAddress->fFlags \|= DBGFADDRESS_FLAGS_VALID;
136
137	return VINF_SUCCESS;
138	}
139
140
141	/**
142	* Creates a mixed address from selector info and an offset into the segment
143	* described by it.
144	*
145	* @returns VBox status code.
146	* @param pUVM The user mode VM handle.
147	* @param pAddress Where to store the mixed address.
148	* @param pSelInfo The selector info.
149	* @param off The offset part.
150	*/
151	VMMR3DECL(int) DBGFR3AddrFromSelInfoOff(PUVM pUVM, PDBGFADDRESS pAddress, PCDBGFSELINFO pSelInfo, RTUINTPTR off)
152	{
153	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
154	VM_ASSERT_VALID_EXT_RETURN(pUVM->pVM, VERR_INVALID_VM_HANDLE);
155
156	pAddress->Sel = pSelInfo->Sel;
157	pAddress->off = off;
158	int rc = dbgfR3AddrFromSelInfoOffWorker(pAddress, pSelInfo, off);
159	if (RT_FAILURE(rc))
160	return rc;
161
162	pAddress->fFlags \|= DBGFADDRESS_FLAGS_VALID;
163	if (dbgfR3IsHMA(pUVM, pAddress->FlatPtr))
164	pAddress->fFlags \|= DBGFADDRESS_FLAGS_HMA;
165
166	return VINF_SUCCESS;
167	}
168
169
170	/**
171	* Creates a mixed address from a flat address.
172	*
173	* @returns pAddress.
174	* @param pUVM The user mode VM handle.
175	* @param pAddress Where to store the mixed address.
176	* @param FlatPtr The flat pointer.
177	*/
178	VMMR3DECL(PDBGFADDRESS) DBGFR3AddrFromFlat(PUVM pUVM, PDBGFADDRESS pAddress, RTGCUINTPTR FlatPtr)
179	{
180	UVM_ASSERT_VALID_EXT_RETURN(pUVM, NULL);
181	VM_ASSERT_VALID_EXT_RETURN(pUVM->pVM, NULL);
182	pAddress->Sel = DBGF_SEL_FLAT;
183	pAddress->off = FlatPtr;
184	pAddress->FlatPtr = FlatPtr;
185	pAddress->fFlags = DBGFADDRESS_FLAGS_FLAT \| DBGFADDRESS_FLAGS_VALID;
186	if (dbgfR3IsHMA(pUVM, pAddress->FlatPtr))
187	pAddress->fFlags \|= DBGFADDRESS_FLAGS_HMA;
188	return pAddress;
189	}
190
191
192	/**
193	* Creates a mixed address from a guest physical address.
194	*
195	* @returns pAddress.
196	* @param pUVM The user mode VM handle.
197	* @param pAddress Where to store the mixed address.
198	* @param PhysAddr The guest physical address.
199	*/
200	VMMR3DECL(PDBGFADDRESS) DBGFR3AddrFromPhys(PUVM pUVM, PDBGFADDRESS pAddress, RTGCPHYS PhysAddr)
201	{
202	UVM_ASSERT_VALID_EXT_RETURN(pUVM, NULL);
203	pAddress->Sel = DBGF_SEL_FLAT;
204	pAddress->off = PhysAddr;
205	pAddress->FlatPtr = PhysAddr;
206	pAddress->fFlags = DBGFADDRESS_FLAGS_PHYS \| DBGFADDRESS_FLAGS_VALID;
207	return pAddress;
208	}
209
210
211	/**
212	* Creates a mixed address from a flat host ring-0 address.
213	*
214	* @returns pAddress
215	* @param pAddress Where to store the mixed address.
216	* @param R0Ptr The host ring-0 address.
217	*/
218	VMMR3_INT_DECL(PDBGFADDRESS) DBGFR3AddrFromHostR0(PDBGFADDRESS pAddress, RTR0UINTPTR R0Ptr)
219	{
220	pAddress->FlatPtr = R0Ptr;
221	pAddress->off = R0Ptr;
222	pAddress->fFlags = DBGFADDRESS_FLAGS_RING0 \| DBGFADDRESS_FLAGS_VALID;
223	pAddress->Sel = DBGF_SEL_FLAT;
224	return pAddress;
225	}
226
227
228	/**
229	* Checks if the specified address is valid (checks the structure pointer too).
230	*
231	* @returns true if valid.
232	* @returns false if invalid.
233	* @param pUVM The user mode VM handle.
234	* @param pAddress The address to validate.
235	*/
236	VMMR3DECL(bool) DBGFR3AddrIsValid(PUVM pUVM, PCDBGFADDRESS pAddress)
237	{
238	UVM_ASSERT_VALID_EXT_RETURN(pUVM, false);
239	if (!VALID_PTR(pAddress))
240	return false;
241	if (!DBGFADDRESS_IS_VALID(pAddress))
242	return false;
243	/* more? */
244	return true;
245	}
246
247
248	/**
249	* Called on the EMT for the VCpu.
250	*
251	* @returns VBox status code.
252	* @param pVCpu The cross context virtual CPU structure.
253	* @param pAddress The address.
254	* @param pGCPhys Where to return the physical address.
255	*/
256	static DECLCALLBACK(int) dbgfR3AddrToPhysOnVCpu(PVMCPU pVCpu, PCDBGFADDRESS pAddress, PRTGCPHYS pGCPhys)
257	{
258	VMCPU_ASSERT_EMT(pVCpu);
259	/* This is just a wrapper because we cannot pass FlatPtr thru VMR3ReqCall directly. */
260	return PGMGstGetPage(pVCpu, pAddress->FlatPtr, NULL, pGCPhys);
261	}
262
263
264	/**
265	* Converts an address to a guest physical address.
266	*
267	* @returns VBox status code.
268	* @retval VINF_SUCCESS
269	* @retval VERR_INVALID_PARAMETER if the address is invalid.
270	* @retval VERR_INVALID_STATE if the VM is being terminated or if the virtual
271	* CPU handle is invalid.
272	* @retval VERR_NOT_SUPPORTED is the type of address cannot be converted.
273	* @retval VERR_PAGE_NOT_PRESENT
274	* @retval VERR_PAGE_TABLE_NOT_PRESENT
275	* @retval VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT
276	* @retval VERR_PAGE_MAP_LEVEL4_NOT_PRESENT
277	*
278	* @param pUVM The user mode VM handle.
279	* @param idCpu The ID of the CPU context to convert virtual
280	* addresses.
281	* @param pAddress The address.
282	* @param pGCPhys Where to return the physical address.
283	*/
284	VMMR3DECL(int) DBGFR3AddrToPhys(PUVM pUVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, PRTGCPHYS pGCPhys)
285	{
286	/*
287	* Parameter validation.
288	*/
289	AssertPtr(pGCPhys);
290	*pGCPhys = NIL_RTGCPHYS;
291	AssertPtr(pAddress);
292	AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
293	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_STATE);
294	PVM pVM = pUVM->pVM;
295	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
296	AssertReturn(idCpu < pUVM->cCpus, VERR_INVALID_PARAMETER);
297
298	/*
299	* Convert by address type.
300	*/
301	int rc;
302	if (pAddress->fFlags & DBGFADDRESS_FLAGS_HMA)
303	rc = VERR_NOT_SUPPORTED;
304	else if (pAddress->fFlags & DBGFADDRESS_FLAGS_PHYS)
305	{
306	*pGCPhys = pAddress->FlatPtr;
307	rc = VINF_SUCCESS;
308	}
309	else
310	{
311	PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
312	if (VMCPU_IS_EMT(pVCpu))
313	rc = dbgfR3AddrToPhysOnVCpu(pVCpu, pAddress, pGCPhys);
314	else
315	rc = VMR3ReqPriorityCallWaitU(pUVM, pVCpu->idCpu,
316	(PFNRT)dbgfR3AddrToPhysOnVCpu, 3, pVCpu, pAddress, pGCPhys);
317	}
318	return rc;
319	}
320
321
322	/**
323	* Converts an address to a host physical address.
324	*
325	* @returns VBox status code.
326	* @retval VINF_SUCCESS
327	* @retval VERR_INVALID_PARAMETER if the address is invalid.
328	* @retval VERR_INVALID_STATE if the VM is being terminated or if the virtual
329	* CPU handle is invalid.
330	* @retval VERR_NOT_SUPPORTED is the type of address cannot be converted.
331	* @retval VERR_PAGE_NOT_PRESENT
332	* @retval VERR_PAGE_TABLE_NOT_PRESENT
333	* @retval VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT
334	* @retval VERR_PAGE_MAP_LEVEL4_NOT_PRESENT
335	* @retval VERR_PGM_PHYS_PAGE_RESERVED
336	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS
337	*
338	* @param pUVM The user mode VM handle.
339	* @param idCpu The ID of the CPU context to convert virtual
340	* addresses.
341	* @param pAddress The address.
342	* @param pHCPhys Where to return the physical address.
343	*/
344	VMMR3DECL(int) DBGFR3AddrToHostPhys(PUVM pUVM, VMCPUID idCpu, PDBGFADDRESS pAddress, PRTHCPHYS pHCPhys)
345	{
346	/*
347	* Parameter validation.
348	*/
349	AssertPtr(pHCPhys);
350	*pHCPhys = NIL_RTHCPHYS;
351	AssertPtr(pAddress);
352	AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
353	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_STATE);
354	PVM pVM = pUVM->pVM;
355	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
356	AssertReturn(idCpu < pUVM->cCpus, VERR_INVALID_PARAMETER);
357
358	/*
359	* Convert it if we can.
360	*/
361	int rc;
362	if (pAddress->fFlags & DBGFADDRESS_FLAGS_HMA)
363	rc = VERR_NOT_SUPPORTED; /** @todo implement this */
364	else
365	{
366	RTGCPHYS GCPhys;
367	rc = DBGFR3AddrToPhys(pUVM, idCpu, pAddress, &GCPhys);
368	if (RT_SUCCESS(rc))
369	rc = PGMPhysGCPhys2HCPhys(pVM, pAddress->FlatPtr, pHCPhys);
370	}
371	return rc;
372	}
373
374
375	/**
376	* Called on the EMT for the VCpu.
377	*
378	* @returns VBox status code.
379	*
380	* @param pUVM The user mode VM handle.
381	* @param idCpu The ID of the CPU context.
382	* @param pAddress The address.
383	* @param fReadOnly Whether returning a read-only page is fine or not.
384	* @param ppvR3Ptr Where to return the address.
385	*/
386	static DECLCALLBACK(int) dbgfR3AddrToVolatileR3PtrOnVCpu(PUVM pUVM, VMCPUID idCpu, PDBGFADDRESS pAddress, bool fReadOnly,
387	void **ppvR3Ptr)
388	{
389	PVM pVM = pUVM->pVM;
390	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
391	Assert(idCpu == VMMGetCpuId(pVM));
392
393	int rc;
394	if (pAddress->fFlags & DBGFADDRESS_FLAGS_HMA)
395	{
396	rc = VERR_NOT_SUPPORTED; /** @todo create some dedicated errors for this stuff. */
397	/** @todo this may assert, create a debug version of this which doesn't. */
398	if ( VM_IS_RAW_MODE_ENABLED(pVM)
399	&& MMHyperIsInsideArea(pVM, pAddress->FlatPtr))
400	{
401	void *pv = MMHyperRCToCC(pVM, (RTRCPTR)pAddress->FlatPtr);
402	if (pv)
403	{
404	*ppvR3Ptr = pv;
405	rc = VINF_SUCCESS;
406	}
407	}
408	}
409	else
410	{
411	/*
412	* This is a tad ugly, but it gets the job done.
413	*/
414	PGMPAGEMAPLOCK Lock;
415	if (pAddress->fFlags & DBGFADDRESS_FLAGS_PHYS)
416	{
417	if (fReadOnly)
418	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, pAddress->FlatPtr, (void const **)ppvR3Ptr, &Lock);
419	else
420	rc = PGMPhysGCPhys2CCPtr(pVM, pAddress->FlatPtr, ppvR3Ptr, &Lock);
421	}
422	else
423	{
424	PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
425	if (fReadOnly)
426	rc = PGMPhysGCPtr2CCPtrReadOnly(pVCpu, pAddress->FlatPtr, (void const **)ppvR3Ptr, &Lock);
427	else
428	rc = PGMPhysGCPtr2CCPtr(pVCpu, pAddress->FlatPtr, ppvR3Ptr, &Lock);
429	}
430	if (RT_SUCCESS(rc))
431	PGMPhysReleasePageMappingLock(pVM, &Lock);
432	}
433	return rc;
434	}
435
436
437
438
439	/**
440	* Converts an address to a volatile host virtual address.
441	*
442	* @returns VBox status code.
443	* @retval VINF_SUCCESS
444	* @retval VERR_INVALID_PARAMETER if the address is invalid.
445	* @retval VERR_INVALID_STATE if the VM is being terminated or if the virtual
446	* CPU handle is invalid.
447	* @retval VERR_NOT_SUPPORTED is the type of address cannot be converted.
448	* @retval VERR_PAGE_NOT_PRESENT
449	* @retval VERR_PAGE_TABLE_NOT_PRESENT
450	* @retval VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT
451	* @retval VERR_PAGE_MAP_LEVEL4_NOT_PRESENT
452	* @retval VERR_PGM_PHYS_PAGE_RESERVED
453	* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS
454	*
455	* @param pUVM The user mode VM handle.
456	* @param idCpu The ID of the CPU context to convert virtual
457	* addresses.
458	* @param pAddress The address.
459	* @param fReadOnly Whether returning a read-only page is fine or not.
460	* If set to thru the page may have to be made writable
461	* before we return.
462	* @param ppvR3Ptr Where to return the address.
463	*/
464	VMMR3DECL(int) DBGFR3AddrToVolatileR3Ptr(PUVM pUVM, VMCPUID idCpu, PDBGFADDRESS pAddress, bool fReadOnly, void **ppvR3Ptr)
465	{
466	/*
467	* Parameter validation.
468	*/
469	AssertPtr(ppvR3Ptr);
470	*ppvR3Ptr = NULL;
471	AssertPtr(pAddress);
472	AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
473	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_STATE);
474	AssertReturn(idCpu < pUVM->cCpus, VERR_INVALID_PARAMETER);
475
476	/*
477	* Convert it.
478	*/
479	return VMR3ReqPriorityCallWaitU(pUVM, idCpu, (PFNRT)dbgfR3AddrToVolatileR3PtrOnVCpu, 5,
480	pUVM, idCpu, pAddress, fReadOnly, ppvR3Ptr);
481	}
482
483
484	/**
485	* Adds an offset to an address.
486	*
487	* @returns pAddress.
488	*
489	* @param pAddress The address.
490	* @param uAddend How much to add.
491	*
492	* @remarks No address space or segment limit checks are performed,
493	*/
494	VMMR3DECL(PDBGFADDRESS) DBGFR3AddrAdd(PDBGFADDRESS pAddress, RTGCUINTPTR uAddend)
495	{
496	/*
497	* Parameter validation.
498	*/
499	AssertPtrReturn(pAddress, NULL);
500	AssertReturn(DBGFADDRESS_IS_VALID(pAddress), NULL);
501
502	/*
503	* Add the stuff.
504	*/
505	pAddress->off += uAddend;
506	pAddress->FlatPtr += uAddend;
507
508	return pAddress;
509	}
510
511
512	/**
513	* Subtracts an offset from an address.
514	*
515	* @returns VINF_SUCCESS on success.
516	*
517	* @param pAddress The address.
518	* @param uSubtrahend How much to subtract.
519	*
520	* @remarks No address space or segment limit checks are performed,
521	*/
522	VMMR3DECL(PDBGFADDRESS) DBGFR3AddrSub(PDBGFADDRESS pAddress, RTGCUINTPTR uSubtrahend)
523	{
524	/*
525	* Parameter validation.
526	*/
527	AssertPtrReturn(pAddress, NULL);
528	AssertReturn(DBGFADDRESS_IS_VALID(pAddress), NULL);
529
530	/*
531	* Add the stuff.
532	*/
533	pAddress->off -= uSubtrahend;
534	pAddress->FlatPtr -= uSubtrahend;
535
536	return pAddress;
537	}
538

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

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFAddr.cpp@ 73472

Download in other formats: