PGMDbg.cpp@ 17562

Last change on this file since 17562 was 17370, checked in by vboxsync, 16 years ago
PGMDbg: new phys code.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 23.4 KB

Line
1	/* $Id: PGMDbg.cpp 17370 2009-03-05 01:09:27Z 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->paChunkR3Ptrs[iChunk])
71	{
72	RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - pRam->paChunkR3Ptrs[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->paChunkR3Ptrs[iChunk])
126	{
127	RTR3UINTPTR off = (RTR3UINTPTR)R3Ptr - pRam->paChunkR3Ptrs[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	{
192	*pGCPhys = pRam->GCPhys + (iPage << PAGE_SHIFT) + off;
193	return VINF_SUCCESS;
194	}
195	}
196	return VERR_INVALID_POINTER;
197	}
198
199
200	/**
201	* Read physical memory API for the debugger, similar to
202	* PGMPhysSimpleReadGCPhys.
203	*
204	* @returns VBox status code.
205	*
206	* @param pVM The VM handle.
207	* @param pvDst Where to store what's read.
208	* @param GCPhysDst Where to start reading from.
209	* @param cb The number of bytes to attempt reading.
210	* @param fFlags Flags, MBZ.
211	* @param pcbRead For store the actual number of bytes read, pass NULL if
212	* partial reads are unwanted.
213	*/
214	VMMR3DECL(int) PGMR3DbgReadGCPhys(PVM pVM, void pvDst, RTGCPHYS GCPhysSrc, size_t cb, uint32_t fFlags, size_t pcbRead)
215	{
216	/* validate */
217	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
218	AssertReturn(pVM, VERR_INVALID_PARAMETER);
219
220	/* try simple first. */
221	int rc = PGMPhysSimpleReadGCPhys(pVM, pvDst, GCPhysSrc, cb);
222	if (RT_SUCCESS(rc) \|\| !pcbRead)
223	return rc;
224
225	/* partial read that failed, chop it up in pages. */
226	*pcbRead = 0;
227	size_t const cbReq = cb;
228	rc = VINF_SUCCESS;
229	while (cb > 0)
230	{
231	size_t cbChunk = PAGE_SIZE;
232	cbChunk -= GCPhysSrc & PAGE_OFFSET_MASK;
233	if (cbChunk > cb)
234	cbChunk = cb;
235
236	rc = PGMPhysSimpleReadGCPhys(pVM, pvDst, GCPhysSrc, cbChunk);
237
238	/* advance */
239	if (RT_FAILURE(rc))
240	break;
241	*pcbRead += cbChunk;
242	cb -= cbChunk;
243	GCPhysSrc += cbChunk;
244	pvDst = (uint8_t *)pvDst + cbChunk;
245	}
246
247	return *pcbRead && RT_FAILURE(rc) ? -rc : rc;
248	}
249
250
251	/**
252	* Write physical memory API for the debugger, similar to
253	* PGMPhysSimpleWriteGCPhys.
254	*
255	* @returns VBox status code.
256	*
257	* @param pVM The VM handle.
258	* @param GCPhysDst Where to start writing.
259	* @param pvSrc What to write.
260	* @param cb The number of bytes to attempt writing.
261	* @param fFlags Flags, MBZ.
262	* @param pcbWritten For store the actual number of bytes written, pass NULL
263	* if partial writes are unwanted.
264	*/
265	VMMR3DECL(int) PGMR3DbgWriteGCPhys(PVM pVM, RTGCPHYS GCPhysDst, const void pvSrc, size_t cb, uint32_t fFlags, size_t pcbWritten)
266	{
267	/* validate */
268	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
269	AssertReturn(pVM, VERR_INVALID_PARAMETER);
270
271	/* try simple first. */
272	int rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysDst, pvSrc, cb);
273	if (RT_SUCCESS(rc) \|\| !pcbWritten)
274	return rc;
275
276	/* partial write that failed, chop it up in pages. */
277	*pcbWritten = 0;
278	rc = VINF_SUCCESS;
279	while (cb > 0)
280	{
281	size_t cbChunk = PAGE_SIZE;
282	cbChunk -= GCPhysDst & PAGE_OFFSET_MASK;
283	if (cbChunk > cb)
284	cbChunk = cb;
285
286	rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysDst, pvSrc, cbChunk);
287
288	/* advance */
289	if (RT_FAILURE(rc))
290	break;
291	*pcbWritten += cbChunk;
292	cb -= cbChunk;
293	GCPhysDst += cbChunk;
294	pvSrc = (uint8_t const *)pvSrc + cbChunk;
295	}
296
297	return *pcbWritten && RT_FAILURE(rc) ? -rc : rc;
298
299	}
300
301
302	/**
303	* Read virtual memory API for the debugger, similar to PGMPhysSimpleReadGCPtr.
304	*
305	* @returns VBox status code.
306	*
307	* @param pVM The VM handle.
308	* @param pvDst Where to store what's read.
309	* @param GCPtrDst Where to start reading from.
310	* @param cb The number of bytes to attempt reading.
311	* @param fFlags Flags, MBZ.
312	* @param pcbRead For store the actual number of bytes read, pass NULL if
313	* partial reads are unwanted.
314	*/
315	VMMR3DECL(int) PGMR3DbgReadGCPtr(PVM pVM, void pvDst, RTGCPTR GCPtrSrc, size_t cb, uint32_t fFlags, size_t pcbRead)
316	{
317	/* validate */
318	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
319	AssertReturn(pVM, VERR_INVALID_PARAMETER);
320
321	/** @todo deal with HMA */
322	/* try simple first. */
323	int rc = PGMPhysSimpleReadGCPtr(pVM, pvDst, GCPtrSrc, cb);
324	if (RT_SUCCESS(rc) \|\| !pcbRead)
325	return rc;
326
327	/* partial read that failed, chop it up in pages. */
328	*pcbRead = 0;
329	rc = VINF_SUCCESS;
330	while (cb > 0)
331	{
332	size_t cbChunk = PAGE_SIZE;
333	cbChunk -= GCPtrSrc & PAGE_OFFSET_MASK;
334	if (cbChunk > cb)
335	cbChunk = cb;
336
337	rc = PGMPhysSimpleReadGCPtr(pVM, pvDst, GCPtrSrc, cbChunk);
338
339	/* advance */
340	if (RT_FAILURE(rc))
341	break;
342	*pcbRead += cbChunk;
343	cb -= cbChunk;
344	GCPtrSrc += cbChunk;
345	pvDst = (uint8_t *)pvDst + cbChunk;
346	}
347
348	return *pcbRead && RT_FAILURE(rc) ? -rc : rc;
349
350	}
351
352
353	/**
354	* Write virtual memory API for the debugger, similar to
355	* PGMPhysSimpleWriteGCPtr.
356	*
357	* @returns VBox status code.
358	*
359	* @param pVM The VM handle.
360	* @param GCPtrDst Where to start writing.
361	* @param pvSrc What to write.
362	* @param cb The number of bytes to attempt writing.
363	* @param fFlags Flags, MBZ.
364	* @param pcbWritten For store the actual number of bytes written, pass NULL
365	* if partial writes are unwanted.
366	*/
367	VMMR3DECL(int) PGMR3DbgWriteGCPtr(PVM pVM, RTGCPTR GCPtrDst, void const pvSrc, size_t cb, uint32_t fFlags, size_t pcbWritten)
368	{
369	/* validate */
370	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
371	AssertReturn(pVM, VERR_INVALID_PARAMETER);
372
373	/** @todo deal with HMA */
374	/* try simple first. */
375	int rc = PGMPhysSimpleWriteGCPtr(pVM, GCPtrDst, pvSrc, cb);
376	if (RT_SUCCESS(rc) \|\| !pcbWritten)
377	return rc;
378
379	/* partial write that failed, chop it up in pages. */
380	*pcbWritten = 0;
381	rc = VINF_SUCCESS;
382	while (cb > 0)
383	{
384	size_t cbChunk = PAGE_SIZE;
385	cbChunk -= GCPtrDst & PAGE_OFFSET_MASK;
386	if (cbChunk > cb)
387	cbChunk = cb;
388
389	rc = PGMPhysSimpleWriteGCPtr(pVM, GCPtrDst, pvSrc, cbChunk);
390
391	/* advance */
392	if (RT_FAILURE(rc))
393	break;
394	*pcbWritten += cbChunk;
395	cb -= cbChunk;
396	GCPtrDst += cbChunk;
397	pvSrc = (uint8_t const *)pvSrc + cbChunk;
398	}
399
400	return *pcbWritten && RT_FAILURE(rc) ? -rc : rc;
401
402	}
403
404
405
406	/**
407	* Scans a page for a byte string, keeping track of potential
408	* cross page matches.
409	*
410	* @returns true and *poff on match.
411	* false on mismatch.
412	* @param pbPage Pointer to the current page.
413	* @param poff Input: The offset into the page.
414	* Output: The page offset of the match on success.
415	* @param cb The number of bytes to search, starting of *poff.
416	* @param pabNeedle The byte string to search for.
417	* @param cbNeedle The length of the byte string.
418	* @param pabPrev The buffer that keeps track of a partial match that we
419	* bring over from the previous page. This buffer must be
420	* at least cbNeedle - 1 big.
421	* @param pcbPrev Input: The number of partial matching bytes from the previous page.
422	* Output: The number of partial matching bytes from this page.
423	* Initialize to 0 before the first call to this function.
424	*/
425	static bool pgmR3DbgScanPage(const uint8_t pbPage, int32_t poff, uint32_t cb,
426	const uint8_t *pabNeedle, size_t cbNeedle,
427	uint8_t pabPrev, size_t pcbPrev)
428	{
429	/*
430	* Try complete any partial match from the previous page.
431	*/
432	if (*pcbPrev > 0)
433	{
434	size_t cbPrev = *pcbPrev;
435	Assert(!*poff);
436	Assert(cbPrev < cbNeedle);
437	if (!memcmp(pbPage, pabNeedle + cbPrev, cbNeedle - cbPrev))
438	{
439	if (cbNeedle - cbPrev > cb)
440	return false;
441	*poff = -(int32_t)cbPrev;
442	return true;
443	}
444
445	/* check out the remainder of the previous page. */
446	const uint8_t *pb = pabPrev;
447	while (cbPrev-- > 0)
448	{
449	pb = (const uint8_t )memchr(pb + 1, pabNeedle, cbPrev);
450	if (!pb)
451	break;
452	cbPrev = *pcbPrev - (pb - pabPrev);
453	if ( !memcmp(pb + 1, &pabNeedle[1], cbPrev - 1)
454	&& !memcmp(pbPage, pabNeedle + cbPrev, cbNeedle - cbPrev))
455	{
456	if (cbNeedle - cbPrev > cb)
457	return false;
458	*poff = -(int32_t)cbPrev;
459	return true;
460	}
461	}
462
463	*pcbPrev = 0;
464	}
465
466	/*
467	* Match the body of the page.
468	*/
469	const uint8_t pb = pbPage + poff;
470	const uint8_t *pbEnd = pb + cb;
471	for (;;)
472	{
473	pb = (const uint8_t )memchr(pb, pabNeedle, cb);
474	if (!pb)
475	break;
476	cb = pbEnd - pb;
477	if (cb >= cbNeedle)
478	{
479	/* match? */
480	if (!memcmp(pb + 1, &pabNeedle[1], cbNeedle - 1))
481	{
482	*poff = pb - pbPage;
483	return true;
484	}
485	}
486	else
487	{
488	/* paritial match at the end of the page? */
489	if (!memcmp(pb + 1, &pabNeedle[1], cb - 1))
490	{
491	/* We're copying one byte more that we really need here, but wtf. */
492	memcpy(pabPrev, pb, cb);
493	*pcbPrev = cb;
494	return false;
495	}
496	}
497
498	/* no match, skip a byte ahead. */
499	if (cb <= 1)
500	break;
501	pb++;
502	cb--;
503	}
504
505	return false;
506	}
507
508
509	/**
510	* Scans guest physical memory for a byte string.
511	*
512	* @returns VBox status codes:
513	* @retval VINF_SUCCESS and *pGCPtrHit on success.
514	* @retval VERR_DBGF_MEM_NOT_FOUND if not found.
515	* @retval VERR_INVALID_POINTER if any of the pointer arguments are invalid.
516	* @retval VERR_INVALID_ARGUMENT if any other arguments are invalid.
517	*
518	* @param pVM Pointer to the shared VM structure.
519	* @param GCPhys Where to start searching.
520	* @param cbRange The number of bytes to search.
521	* @param pabNeedle The byte string to search for.
522	* @param cbNeedle The length of the byte string. Max 256 bytes.
523	* @param pGCPhysHit Where to store the address of the first occurence on success.
524	*/
525	VMMR3DECL(int) PGMR3DbgScanPhysical(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCPHYS pGCPhysHit)
526	{
527	/*
528	* Validate and adjust the input a bit.
529	*/
530	if (!VALID_PTR(pGCPhysHit))
531	return VERR_INVALID_POINTER;
532	*pGCPhysHit = NIL_RTGCPHYS;
533
534	if ( !VALID_PTR(pabNeedle)
535	\|\| GCPhys == NIL_RTGCPHYS)
536	return VERR_INVALID_POINTER;
537	if (!cbNeedle)
538	return VERR_INVALID_PARAMETER;
539	if (cbNeedle > MAX_NEEDLE_SIZE)
540	return VERR_INVALID_PARAMETER;
541
542	if (!cbRange)
543	return VERR_DBGF_MEM_NOT_FOUND;
544	if (GCPhys + cbNeedle - 1 < GCPhys)
545	return VERR_DBGF_MEM_NOT_FOUND;
546
547	const RTGCPHYS GCPhysLast = GCPhys + cbRange - 1 >= GCPhys
548	? GCPhys + cbRange - 1
549	: ~(RTGCPHYS)0;
550
551	/*
552	* Search the memory - ignore MMIO and zero pages, also don't
553	* bother to match across ranges.
554	*/
555	for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
556	pRam;
557	pRam = pRam->CTX_SUFF(pNext))
558	{
559	/*
560	* If the search range starts prior to the current ram range record,
561	* adjust the search range and possibly conclude the search.
562	*/
563	RTGCPHYS off;
564	if (GCPhys < pRam->GCPhys)
565	{
566	if (GCPhysLast < pRam->GCPhys)
567	break;
568	GCPhys = pRam->GCPhys;
569	off = 0;
570	}
571	else
572	off = GCPhys - pRam->GCPhys;
573	if (off < pRam->cb)
574	{
575	/*
576	* Iterate the relevant pages.
577	*/
578	uint8_t abPrev[MAX_NEEDLE_SIZE];
579	size_t cbPrev = 0;
580	const uint32_t cPages = pRam->cb >> PAGE_SHIFT;
581	for (uint32_t iPage = off >> PAGE_SHIFT; iPage < cPages; iPage++)
582	{
583	PPGMPAGE pPage = &pRam->aPages[iPage];
584	#ifdef VBOX_WITH_NEW_PHYS_CODE
585	if ( !PGM_PAGE_IS_ZERO(pPage)
586	&& !PGM_PAGE_IS_MMIO(pPage))
587	#else
588	if ( /** @todo !PGM_PAGE_IS_ZERO(pPage)
589	&&*/ !PGM_PAGE_IS_MMIO(pPage))
590	#endif
591	{
592	void const *pvPage;
593	PGMPAGEMAPLOCK Lock;
594	int rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK, &pvPage, &Lock);
595	if (RT_SUCCESS(rc))
596	{
597	int32_t offPage = (GCPhys & PAGE_OFFSET_MASK);
598	uint32_t cbSearch = (GCPhys ^ GCPhysLast) & ~(RTGCPHYS)PAGE_OFFSET_MASK
599	? PAGE_SIZE - (uint32_t)offPage
600	: (GCPhysLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
601	bool fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offPage, cbSearch,
602	pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
603	PGMPhysReleasePageMappingLock(pVM, &Lock);
604	if (fRc)
605	{
606	*pGCPhysHit = (GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK) + offPage;
607	return VINF_SUCCESS;
608	}
609	}
610	else
611	cbPrev = 0; /* ignore error. */
612	}
613	else
614	cbPrev = 0;
615
616	/* advance to the next page. */
617	GCPhys \|= PAGE_OFFSET_MASK;
618	if (GCPhys++ >= GCPhysLast)
619	return VERR_DBGF_MEM_NOT_FOUND;
620	}
621	}
622	}
623	return VERR_DBGF_MEM_NOT_FOUND;
624	}
625
626
627	/**
628	* Scans (guest) virtual memory for a byte string.
629	*
630	* @returns VBox status codes:
631	* @retval VINF_SUCCESS and *pGCPtrHit on success.
632	* @retval VERR_DBGF_MEM_NOT_FOUND if not found.
633	* @retval VERR_INVALID_POINTER if any of the pointer arguments are invalid.
634	* @retval VERR_INVALID_ARGUMENT if any other arguments are invalid.
635	*
636	* @param pVM Pointer to the shared VM structure.
637	* @param GCPtr Where to start searching.
638	* @param cbRange The number of bytes to search. Max 256 bytes.
639	* @param pabNeedle The byte string to search for.
640	* @param cbNeedle The length of the byte string.
641	* @param pGCPtrHit Where to store the address of the first occurence on success.
642	*/
643	VMMR3DECL(int) PGMR3DbgScanVirtual(PVM pVM, RTGCPTR GCPtr, RTGCPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCUINTPTR pGCPtrHit)
644	{
645	/*
646	* Validate and adjust the input a bit.
647	*/
648	if (!VALID_PTR(pGCPtrHit))
649	return VERR_INVALID_POINTER;
650	*pGCPtrHit = 0;
651
652	if (!VALID_PTR(pabNeedle))
653	return VERR_INVALID_POINTER;
654	if (!cbNeedle)
655	return VERR_INVALID_PARAMETER;
656	if (cbNeedle > MAX_NEEDLE_SIZE)
657	return VERR_INVALID_PARAMETER;
658
659	if (!cbRange)
660	return VERR_DBGF_MEM_NOT_FOUND;
661	if (GCPtr + cbNeedle - 1 < GCPtr)
662	return VERR_DBGF_MEM_NOT_FOUND;
663
664	/*
665	* Search the memory - ignore MMIO, zero and not-present pages.
666	*/
667	uint8_t abPrev[MAX_NEEDLE_SIZE];
668	size_t cbPrev = 0;
669	const RTGCPTR GCPtrLast = GCPtr + cbRange - 1 >= GCPtr
670	? GCPtr + cbRange - 1
671	: ~(RTGCPTR)0;
672	RTGCPTR cPages = (((GCPtrLast - GCPtr) + (GCPtr & PAGE_OFFSET_MASK)) >> PAGE_SHIFT) + 1;
673	while (cPages-- > 0)
674	{
675	RTGCPHYS GCPhys;
676	int rc = PGMPhysGCPtr2GCPhys(pVM, GCPtr, &GCPhys);
677	if (RT_SUCCESS(rc))
678	{
679	PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
680	if ( pPage
681	///@todo && !PGM_PAGE_IS_ZERO(pPage)
682	&& !PGM_PAGE_IS_MMIO(pPage))
683	{
684	void const *pvPage;
685	PGMPAGEMAPLOCK Lock;
686	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys & ~(RTGCPTR)PAGE_OFFSET_MASK, &pvPage, &Lock);
687	if (RT_SUCCESS(rc))
688	{
689	int32_t offPage = (GCPtr & PAGE_OFFSET_MASK);
690	uint32_t cbSearch = cPages > 0
691	? PAGE_SIZE - (uint32_t)offPage
692	: (GCPtrLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
693	bool fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offPage, cbSearch,
694	pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
695	PGMPhysReleasePageMappingLock(pVM, &Lock);
696	if (fRc)
697	{
698	*pGCPtrHit = (GCPtr & ~(RTGCPTR)PAGE_OFFSET_MASK) + offPage;
699	return VINF_SUCCESS;
700	}
701	}
702	else
703	cbPrev = 0; /* ignore error. */
704	}
705	else
706	cbPrev = 0;
707	}
708	else
709	cbPrev = 0; /* ignore error. */
710
711	/* advance to the next page. */
712	GCPtr \|= PAGE_OFFSET_MASK;
713	GCPtr++;
714	}
715	return VERR_DBGF_MEM_NOT_FOUND;
716	}
717

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

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

Download in other formats: