PGMDbg.cpp@ 13035

Last change on this file since 13035 was 13035, checked in by vboxsync, 16 years ago
#1865: More PGM...
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 17.5 KB

Line
1	/* $Id: PGMDbg.cpp 13035 2008-10-07 09:54:32Z vboxsync $ */
2	/** @file
3	* PGM - Page Manager and Monitor - Debugger & Debugging APIs.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25	#define LOG_GROUP LOG_GROUP_PGM
26	#include <VBox/pgm.h>
27	#include <VBox/stam.h>
28	#include "PGMInternal.h"
29	#include <VBox/vm.h>
30	#include <iprt/assert.h>
31	#include <iprt/asm.h>
32	#include <iprt/string.h>
33	#include <VBox/log.h>
34	#include <VBox/param.h>
35	#include <VBox/err.h>
36
37	/** The max needle size that we will bother searching for
38	* This must not be more than half a page! */
39	#define MAX_NEEDLE_SIZE 256
40
41
42	/**
43	* Converts a R3 pointer to a GC physical address.
44	*
45	* Only for the debugger.
46	*
47	* @returns VBox status code.
48	* @retval VINF_SUCCESS on success, *pGCPhys is set.
49	* @retval VERR_INVALID_POINTER if the pointer is not within the GC physical memory.
50	*
51	* @param pVM The VM handle.
52	* @param R3Ptr The R3 pointer to convert.
53	* @param pGCPhys Where to store the GC physical address on success.
54	*/
55	VMMR3DECL(int) PGMR3DbgR3Ptr2GCPhys(PVM pVM, RTR3PTR R3Ptr, PRTGCPHYS pGCPhys)
56	{
57	#ifdef VBOX_WITH_NEW_PHYS_CODE
58	*pGCPhys = NIL_RTGCPHYS;
59	return VERR_NOT_IMPLEMENTED;
60
61	#else
62	for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
63	pRam;
64	pRam = pRam->CTX_SUFF(pNext))
65	{
66	if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
67	{
68	for (unsigned iChunk = 0; iChunk < (pRam->cb >> PGM_DYNAMIC_CHUNK_SHIFT); iChunk++)
69	{
70	if (pRam->pavHCChunkHC[iChunk])
71	{
72	RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pRam->pavHCChunkHC[iChunk];
73	if (off < PGM_DYNAMIC_CHUNK_SIZE)
74	{
75	pGCPhys = pRam->GCPhys + iChunkPGM_DYNAMIC_CHUNK_SIZE + off;
76	return VINF_SUCCESS;
77	}
78	}
79	}
80	}
81	else if (pRam->pvR3)
82	{
83	RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pRam->pvR3;
84	if (off < pRam->cb)
85	{
86	*pGCPhys = pRam->GCPhys + off;
87	return VINF_SUCCESS;
88	}
89	}
90	}
91	return VERR_INVALID_POINTER;
92	#endif
93	}
94
95
96	/**
97	* Converts a R3 pointer to a HC physical address.
98	*
99	* Only for the debugger.
100	*
101	* @returns VBox status code.
102	* @retval VINF_SUCCESS on success, *pHCPhys is set.
103	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical page but has no physical backing.
104	* @retval VERR_INVALID_POINTER if the pointer is not within the GC physical memory.
105	*
106	* @param pVM The VM handle.
107	* @param R3Ptr The R3 pointer to convert.
108	* @param pHCPhys Where to store the HC physical address on success.
109	*/
110	VMMR3DECL(int) PGMR3DbgR3Ptr2HCPhys(PVM pVM, RTR3PTR R3Ptr, PRTHCPHYS pHCPhys)
111	{
112	#ifdef VBOX_WITH_NEW_PHYS_CODE
113	*pHCPhys = NIL_RTHCPHYS;
114	return VERR_NOT_IMPLEMENTED;
115
116	#else
117	for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
118	pRam;
119	pRam = pRam->CTX_SUFF(pNext))
120	{
121	if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
122	{
123	for (unsigned iChunk = 0; iChunk < (pRam->cb >> PGM_DYNAMIC_CHUNK_SHIFT); iChunk++)
124	{
125	if (pRam->pavHCChunkHC[iChunk])
126	{
127	RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pRam->pavHCChunkHC[iChunk];
128	if (off < PGM_DYNAMIC_CHUNK_SIZE)
129	{
130	PPGMPAGE pPage = &pRam->aPages[off >> PAGE_SHIFT];
131	if (PGM_PAGE_IS_RESERVED(pPage))
132	return VERR_PGM_PHYS_PAGE_RESERVED;
133	*pHCPhys = PGM_PAGE_GET_HCPHYS(pPage)
134	\| (off & PAGE_OFFSET_MASK);
135	return VINF_SUCCESS;
136	}
137	}
138	}
139	}
140	else if (pRam->pvR3)
141	{
142	RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - (RTR3UINTPTR)pRam->pvR3;
143	if (off < pRam->cb)
144	{
145	PPGMPAGE pPage = &pRam->aPages[off >> PAGE_SHIFT];
146	if (PGM_PAGE_IS_RESERVED(pPage))
147	return VERR_PGM_PHYS_PAGE_RESERVED;
148	*pHCPhys = PGM_PAGE_GET_HCPHYS(pPage)
149	\| (off & PAGE_OFFSET_MASK);
150	return VINF_SUCCESS;
151	}
152	}
153	}
154	return VERR_INVALID_POINTER;
155	#endif
156	}
157
158
159	/**
160	* Converts a HC physical address to a GC physical address.
161	*
162	* Only for the debugger.
163	*
164	* @returns VBox status code
165	* @retval VINF_SUCCESS on success, *pGCPhys is set.
166	* @retval VERR_INVALID_POINTER if the HC physical address is not within the GC physical memory.
167	*
168	* @param pVM The VM handle.
169	* @param HCPhys The HC physical address to convert.
170	* @param pGCPhys Where to store the GC physical address on success.
171	*/
172	VMMR3DECL(int) PGMR3DbgHCPhys2GCPhys(PVM pVM, RTHCPHYS HCPhys, PRTGCPHYS pGCPhys)
173	{
174	/*
175	* Validate and adjust the input a bit.
176	*/
177	if (HCPhys == NIL_RTHCPHYS)
178	return VERR_INVALID_POINTER;
179	unsigned off = HCPhys & PAGE_OFFSET_MASK;
180	HCPhys &= X86_PTE_PAE_PG_MASK;
181	if (HCPhys == 0)
182	return VERR_INVALID_POINTER;
183
184	for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
185	pRam;
186	pRam = pRam->CTX_SUFF(pNext))
187	{
188	uint32_t iPage = pRam->cb >> PAGE_SHIFT;
189	while (iPage-- > 0)
190	if ( PGM_PAGE_GET_HCPHYS(&pRam->aPages[iPage]) == HCPhys
191	&& !PGM_PAGE_IS_RESERVED(&pRam->aPages[iPage]))
192	{
193	*pGCPhys = pRam->GCPhys + (iPage << PAGE_SHIFT) + off;
194	return VINF_SUCCESS;
195	}
196	}
197	return VERR_INVALID_POINTER;
198	}
199
200
201	/**
202	* Scans a page for a byte string, keeping track of potential
203	* cross page matches.
204	*
205	* @returns true and *poff on match.
206	* false on mismatch.
207	* @param pbPage Pointer to the current page.
208	* @param poff Input: The offset into the page.
209	* Output: The page offset of the match on success.
210	* @param cb The number of bytes to search, starting of *poff.
211	* @param pabNeedle The byte string to search for.
212	* @param cbNeedle The length of the byte string.
213	* @param pabPrev The buffer that keeps track of a partial match that we
214	* bring over from the previous page. This buffer must be
215	* at least cbNeedle - 1 big.
216	* @param pcbPrev Input: The number of partial matching bytes from the previous page.
217	* Output: The number of partial matching bytes from this page.
218	* Initialize to 0 before the first call to this function.
219	*/
220	static bool pgmR3DbgScanPage(const uint8_t pbPage, int32_t poff, uint32_t cb,
221	const uint8_t *pabNeedle, size_t cbNeedle,
222	uint8_t pabPrev, size_t pcbPrev)
223	{
224	/*
225	* Try complete any partial match from the previous page.
226	*/
227	if (*pcbPrev > 0)
228	{
229	size_t cbPrev = *pcbPrev;
230	Assert(!*poff);
231	Assert(cbPrev < cbNeedle);
232	if (!memcmp(pbPage, pabNeedle + cbPrev, cbNeedle - cbPrev))
233	{
234	if (cbNeedle - cbPrev > cb)
235	return false;
236	*poff = -(int32_t)cbPrev;
237	return true;
238	}
239
240	/* check out the remainder of the previous page. */
241	const uint8_t *pb = pabPrev;
242	while (cbPrev-- > 0)
243	{
244	pb = (const uint8_t )memchr(pb + 1, pabNeedle, cbPrev);
245	if (!pb)
246	break;
247	cbPrev = *pcbPrev - (pb - pabPrev);
248	if ( !memcmp(pb + 1, &pabNeedle[1], cbPrev - 1)
249	&& !memcmp(pbPage, pabNeedle + cbPrev, cbNeedle - cbPrev))
250	{
251	if (cbNeedle - cbPrev > cb)
252	return false;
253	*poff = -(int32_t)cbPrev;
254	return true;
255	}
256	}
257
258	*pcbPrev = 0;
259	}
260
261	/*
262	* Match the body of the page.
263	*/
264	const uint8_t pb = pbPage + poff;
265	const uint8_t *pbEnd = pb + cb;
266	for (;;)
267	{
268	pb = (const uint8_t )memchr(pb, pabNeedle, cb);
269	if (!pb)
270	break;
271	cb = pbEnd - pb;
272	if (cb >= cbNeedle)
273	{
274	/* match? */
275	if (!memcmp(pb + 1, &pabNeedle[1], cbNeedle - 1))
276	{
277	*poff = pb - pbPage;
278	return true;
279	}
280	}
281	else
282	{
283	/* paritial match at the end of the page? */
284	if (!memcmp(pb + 1, &pabNeedle[1], cb - 1))
285	{
286	/* We're copying one byte more that we really need here, but wtf. */
287	memcpy(pabPrev, pb, cb);
288	*pcbPrev = cb;
289	return false;
290	}
291	}
292
293	/* no match, skip a byte ahead. */
294	if (cb <= 1)
295	break;
296	pb++;
297	cb--;
298	}
299
300	return false;
301	}
302
303
304	/**
305	* Scans guest physical memory for a byte string.
306	*
307	* @returns VBox status codes:
308	* @retval VINF_SUCCESS and *pGCPtrHit on success.
309	* @retval VERR_DBGF_MEM_NOT_FOUND if not found.
310	* @retval VERR_INVALID_POINTER if any of the pointer arguments are invalid.
311	* @retval VERR_INVALID_ARGUMENT if any other arguments are invalid.
312	*
313	* @param pVM Pointer to the shared VM structure.
314	* @param GCPhys Where to start searching.
315	* @param cbRange The number of bytes to search.
316	* @param pabNeedle The byte string to search for.
317	* @param cbNeedle The length of the byte string. Max 256 bytes.
318	* @param pGCPhysHit Where to store the address of the first occurence on success.
319	*/
320	VMMR3DECL(int) PGMR3DbgScanPhysical(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCPHYS pGCPhysHit)
321	{
322	/*
323	* Validate and adjust the input a bit.
324	*/
325	if (!VALID_PTR(pGCPhysHit))
326	return VERR_INVALID_POINTER;
327	*pGCPhysHit = NIL_RTGCPHYS;
328
329	if ( !VALID_PTR(pabNeedle)
330	\|\| GCPhys == NIL_RTGCPHYS)
331	return VERR_INVALID_POINTER;
332	if (!cbNeedle)
333	return VERR_INVALID_PARAMETER;
334	if (cbNeedle > MAX_NEEDLE_SIZE)
335	return VERR_INVALID_PARAMETER;
336
337	if (!cbRange)
338	return VERR_DBGF_MEM_NOT_FOUND;
339	if (GCPhys + cbNeedle - 1 < GCPhys)
340	return VERR_DBGF_MEM_NOT_FOUND;
341
342	const RTGCPHYS GCPhysLast = GCPhys + cbRange - 1 >= GCPhys
343	? GCPhys + cbRange - 1
344	: ~(RTGCPHYS)0;
345
346	/*
347	* Search the memory - ignore MMIO and zero pages, also don't
348	* bother to match across ranges.
349	*/
350	for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
351	pRam;
352	pRam = pRam->CTX_SUFF(pNext))
353	{
354	/*
355	* If the search range starts prior to the current ram range record,
356	* adjust the search range and possibly conclude the search.
357	*/
358	RTGCPHYS off;
359	if (GCPhys < pRam->GCPhys)
360	{
361	if (GCPhysLast < pRam->GCPhys)
362	break;
363	GCPhys = pRam->GCPhys;
364	off = 0;
365	}
366	else
367	off = GCPhys - pRam->GCPhys;
368	if (off < pRam->cb)
369	{
370	/*
371	* Iterate the relevant pages.
372	*/
373	uint8_t abPrev[MAX_NEEDLE_SIZE];
374	size_t cbPrev = 0;
375	const uint32_t cPages = pRam->cb >> PAGE_SHIFT;
376	for (uint32_t iPage = off >> PAGE_SHIFT; iPage < cPages; iPage++)
377	{
378	PPGMPAGE pPage = &pRam->aPages[iPage];
379	if ( /** @todo !PGM_PAGE_IS_ZERO(pPage)
380	&&*/ !PGM_PAGE_IS_MMIO(pPage))
381	{
382	void const *pvPage;
383	PGMPAGEMAPLOCK Lock;
384	int rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK, &pvPage, &Lock);
385	if (RT_SUCCESS(rc))
386	{
387	int32_t offPage = (GCPhys & PAGE_OFFSET_MASK);
388	uint32_t cbSearch = (GCPhys ^ GCPhysLast) & ~(RTGCPHYS)PAGE_OFFSET_MASK
389	? PAGE_SIZE - (uint32_t)offPage
390	: (GCPhysLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
391	bool fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offPage, cbSearch,
392	pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
393	PGMPhysReleasePageMappingLock(pVM, &Lock);
394	if (fRc)
395	{
396	*pGCPhysHit = (GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK) + offPage;
397	return VINF_SUCCESS;
398	}
399	}
400	else
401	cbPrev = 0; /* ignore error. */
402	}
403	else
404	cbPrev = 0;
405
406	/* advance to the the next page. */
407	GCPhys \|= PAGE_OFFSET_MASK;
408	if (GCPhys++ >= GCPhysLast)
409	return VERR_DBGF_MEM_NOT_FOUND;
410	}
411	}
412	}
413	return VERR_DBGF_MEM_NOT_FOUND;
414	}
415
416
417	/**
418	* Scans (guest) virtual memory for a byte string.
419	*
420	* @returns VBox status codes:
421	* @retval VINF_SUCCESS and *pGCPtrHit on success.
422	* @retval VERR_DBGF_MEM_NOT_FOUND if not found.
423	* @retval VERR_INVALID_POINTER if any of the pointer arguments are invalid.
424	* @retval VERR_INVALID_ARGUMENT if any other arguments are invalid.
425	*
426	* @param pVM Pointer to the shared VM structure.
427	* @param GCPtr Where to start searching.
428	* @param cbRange The number of bytes to search. Max 256 bytes.
429	* @param pabNeedle The byte string to search for.
430	* @param cbNeedle The length of the byte string.
431	* @param pGCPtrHit Where to store the address of the first occurence on success.
432	*/
433	VMMR3DECL(int) PGMR3DbgScanVirtual(PVM pVM, RTGCUINTPTR GCPtr, RTGCUINTPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCUINTPTR pGCPtrHit)
434	{
435	/*
436	* Validate and adjust the input a bit.
437	*/
438	if (!VALID_PTR(pGCPtrHit))
439	return VERR_INVALID_POINTER;
440	*pGCPtrHit = 0;
441
442	if (!VALID_PTR(pabNeedle))
443	return VERR_INVALID_POINTER;
444	if (!cbNeedle)
445	return VERR_INVALID_PARAMETER;
446	if (cbNeedle > MAX_NEEDLE_SIZE)
447	return VERR_INVALID_PARAMETER;
448
449	if (!cbRange)
450	return VERR_DBGF_MEM_NOT_FOUND;
451	if (GCPtr + cbNeedle - 1 < GCPtr)
452	return VERR_DBGF_MEM_NOT_FOUND;
453
454	/*
455	* Search the memory - ignore MMIO, zero and not-present pages.
456	*/
457	uint8_t abPrev[MAX_NEEDLE_SIZE];
458	size_t cbPrev = 0;
459	const RTGCUINTPTR GCPtrLast = GCPtr + cbRange - 1 >= GCPtr
460	? GCPtr + cbRange - 1
461	: ~(RTGCUINTPTR)0;
462	RTGCUINTPTR cPages = (((GCPtrLast - GCPtr) + (GCPtr & PAGE_OFFSET_MASK)) >> PAGE_SHIFT) + 1;
463	while (cPages-- > 0)
464	{
465	RTGCPHYS GCPhys;
466	int rc = PGMPhysGCPtr2GCPhys(pVM, GCPtr, &GCPhys);
467	if (RT_SUCCESS(rc))
468	{
469	PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
470	if ( pPage
471	///@todo && !PGM_PAGE_IS_ZERO(pPage)
472	&& !PGM_PAGE_IS_MMIO(pPage))
473	{
474	void const *pvPage;
475	PGMPAGEMAPLOCK Lock;
476	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys & ~(RTGCUINTPTR)PAGE_OFFSET_MASK, &pvPage, &Lock);
477	if (RT_SUCCESS(rc))
478	{
479	int32_t offPage = (GCPtr & PAGE_OFFSET_MASK);
480	uint32_t cbSearch = cPages > 0
481	? PAGE_SIZE - (uint32_t)offPage
482	: (GCPtrLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
483	bool fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offPage, cbSearch,
484	pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
485	PGMPhysReleasePageMappingLock(pVM, &Lock);
486	if (fRc)
487	{
488	*pGCPtrHit = (GCPtr & ~(RTGCUINTPTR)PAGE_OFFSET_MASK) + offPage;
489	return VINF_SUCCESS;
490	}
491	}
492	else
493	cbPrev = 0; /* ignore error. */
494	}
495	else
496	cbPrev = 0;
497	}
498	else
499	cbPrev = 0; /* ignore error. */
500
501	/* advance to the the next page. */
502	GCPtr \|= PAGE_OFFSET_MASK;
503	GCPtr++;
504	}
505	return VERR_DBGF_MEM_NOT_FOUND;
506	}
507

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

source: vbox/trunk/src/VBox/VMM/PGMDbg.cpp@ 13035

Download in other formats: