PGMDbg.cpp@ 18746

Last change on this file since 18746 was 18665, checked in by vboxsync, 16 years ago
VMM: Clean out the VBOX_WITH_NEW_PHYS_CODE #ifdefs. (part 1)
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 20.7 KB

Line
1	/* $Id: PGMDbg.cpp 18665 2009-04-02 19:44:18Z 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	*pGCPhys = NIL_RTGCPHYS;
58	return VERR_NOT_IMPLEMENTED;
59	}
60
61
62	/**
63	* Converts a R3 pointer to a HC physical address.
64	*
65	* Only for the debugger.
66	*
67	* @returns VBox status code.
68	* @retval VINF_SUCCESS on success, *pHCPhys is set.
69	* @retval VERR_PGM_PHYS_PAGE_RESERVED it it's a valid GC physical page but has no physical backing.
70	* @retval VERR_INVALID_POINTER if the pointer is not within the GC physical memory.
71	*
72	* @param pVM The VM handle.
73	* @param R3Ptr The R3 pointer to convert.
74	* @param pHCPhys Where to store the HC physical address on success.
75	*/
76	VMMR3DECL(int) PGMR3DbgR3Ptr2HCPhys(PVM pVM, RTR3PTR R3Ptr, PRTHCPHYS pHCPhys)
77	{
78	*pHCPhys = NIL_RTHCPHYS;
79	return VERR_NOT_IMPLEMENTED;
80	}
81
82
83	/**
84	* Converts a HC physical address to a GC physical address.
85	*
86	* Only for the debugger.
87	*
88	* @returns VBox status code
89	* @retval VINF_SUCCESS on success, *pGCPhys is set.
90	* @retval VERR_INVALID_POINTER if the HC physical address is not within the GC physical memory.
91	*
92	* @param pVM The VM handle.
93	* @param HCPhys The HC physical address to convert.
94	* @param pGCPhys Where to store the GC physical address on success.
95	*/
96	VMMR3DECL(int) PGMR3DbgHCPhys2GCPhys(PVM pVM, RTHCPHYS HCPhys, PRTGCPHYS pGCPhys)
97	{
98	/*
99	* Validate and adjust the input a bit.
100	*/
101	if (HCPhys == NIL_RTHCPHYS)
102	return VERR_INVALID_POINTER;
103	unsigned off = HCPhys & PAGE_OFFSET_MASK;
104	HCPhys &= X86_PTE_PAE_PG_MASK;
105	if (HCPhys == 0)
106	return VERR_INVALID_POINTER;
107
108	for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
109	pRam;
110	pRam = pRam->CTX_SUFF(pNext))
111	{
112	uint32_t iPage = pRam->cb >> PAGE_SHIFT;
113	while (iPage-- > 0)
114	if (PGM_PAGE_GET_HCPHYS(&pRam->aPages[iPage]) == HCPhys)
115	{
116	*pGCPhys = pRam->GCPhys + (iPage << PAGE_SHIFT) + off;
117	return VINF_SUCCESS;
118	}
119	}
120	return VERR_INVALID_POINTER;
121	}
122
123
124	/**
125	* Read physical memory API for the debugger, similar to
126	* PGMPhysSimpleReadGCPhys.
127	*
128	* @returns VBox status code.
129	*
130	* @param pVM The VM handle.
131	* @param pvDst Where to store what's read.
132	* @param GCPhysDst Where to start reading from.
133	* @param cb The number of bytes to attempt reading.
134	* @param fFlags Flags, MBZ.
135	* @param pcbRead For store the actual number of bytes read, pass NULL if
136	* partial reads are unwanted.
137	*/
138	VMMR3DECL(int) PGMR3DbgReadGCPhys(PVM pVM, void pvDst, RTGCPHYS GCPhysSrc, size_t cb, uint32_t fFlags, size_t pcbRead)
139	{
140	/* validate */
141	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
142	AssertReturn(pVM, VERR_INVALID_PARAMETER);
143
144	/* try simple first. */
145	int rc = PGMPhysSimpleReadGCPhys(pVM, pvDst, GCPhysSrc, cb);
146	if (RT_SUCCESS(rc) \|\| !pcbRead)
147	return rc;
148
149	/* partial read that failed, chop it up in pages. */
150	*pcbRead = 0;
151	size_t const cbReq = cb;
152	rc = VINF_SUCCESS;
153	while (cb > 0)
154	{
155	size_t cbChunk = PAGE_SIZE;
156	cbChunk -= GCPhysSrc & PAGE_OFFSET_MASK;
157	if (cbChunk > cb)
158	cbChunk = cb;
159
160	rc = PGMPhysSimpleReadGCPhys(pVM, pvDst, GCPhysSrc, cbChunk);
161
162	/* advance */
163	if (RT_FAILURE(rc))
164	break;
165	*pcbRead += cbChunk;
166	cb -= cbChunk;
167	GCPhysSrc += cbChunk;
168	pvDst = (uint8_t *)pvDst + cbChunk;
169	}
170
171	return *pcbRead && RT_FAILURE(rc) ? -rc : rc;
172	}
173
174
175	/**
176	* Write physical memory API for the debugger, similar to
177	* PGMPhysSimpleWriteGCPhys.
178	*
179	* @returns VBox status code.
180	*
181	* @param pVM The VM handle.
182	* @param GCPhysDst Where to start writing.
183	* @param pvSrc What to write.
184	* @param cb The number of bytes to attempt writing.
185	* @param fFlags Flags, MBZ.
186	* @param pcbWritten For store the actual number of bytes written, pass NULL
187	* if partial writes are unwanted.
188	*/
189	VMMR3DECL(int) PGMR3DbgWriteGCPhys(PVM pVM, RTGCPHYS GCPhysDst, const void pvSrc, size_t cb, uint32_t fFlags, size_t pcbWritten)
190	{
191	/* validate */
192	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
193	AssertReturn(pVM, VERR_INVALID_PARAMETER);
194
195	/* try simple first. */
196	int rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysDst, pvSrc, cb);
197	if (RT_SUCCESS(rc) \|\| !pcbWritten)
198	return rc;
199
200	/* partial write that failed, chop it up in pages. */
201	*pcbWritten = 0;
202	rc = VINF_SUCCESS;
203	while (cb > 0)
204	{
205	size_t cbChunk = PAGE_SIZE;
206	cbChunk -= GCPhysDst & PAGE_OFFSET_MASK;
207	if (cbChunk > cb)
208	cbChunk = cb;
209
210	rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysDst, pvSrc, cbChunk);
211
212	/* advance */
213	if (RT_FAILURE(rc))
214	break;
215	*pcbWritten += cbChunk;
216	cb -= cbChunk;
217	GCPhysDst += cbChunk;
218	pvSrc = (uint8_t const *)pvSrc + cbChunk;
219	}
220
221	return *pcbWritten && RT_FAILURE(rc) ? -rc : rc;
222
223	}
224
225
226	/**
227	* Read virtual memory API for the debugger, similar to PGMPhysSimpleReadGCPtr.
228	*
229	* @returns VBox status code.
230	*
231	* @param pVM The VM handle.
232	* @param pvDst Where to store what's read.
233	* @param GCPtrDst Where to start reading from.
234	* @param cb The number of bytes to attempt reading.
235	* @param fFlags Flags, MBZ.
236	* @param pcbRead For store the actual number of bytes read, pass NULL if
237	* partial reads are unwanted.
238	*/
239	VMMR3DECL(int) PGMR3DbgReadGCPtr(PVM pVM, void pvDst, RTGCPTR GCPtrSrc, size_t cb, uint32_t fFlags, size_t pcbRead)
240	{
241	/* validate */
242	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
243	AssertReturn(pVM, VERR_INVALID_PARAMETER);
244
245	/** @todo deal with HMA */
246	/* try simple first. */
247	int rc = PGMPhysSimpleReadGCPtr(pVM, pvDst, GCPtrSrc, cb);
248	if (RT_SUCCESS(rc) \|\| !pcbRead)
249	return rc;
250
251	/* partial read that failed, chop it up in pages. */
252	*pcbRead = 0;
253	rc = VINF_SUCCESS;
254	while (cb > 0)
255	{
256	size_t cbChunk = PAGE_SIZE;
257	cbChunk -= GCPtrSrc & PAGE_OFFSET_MASK;
258	if (cbChunk > cb)
259	cbChunk = cb;
260
261	rc = PGMPhysSimpleReadGCPtr(pVM, pvDst, GCPtrSrc, cbChunk);
262
263	/* advance */
264	if (RT_FAILURE(rc))
265	break;
266	*pcbRead += cbChunk;
267	cb -= cbChunk;
268	GCPtrSrc += cbChunk;
269	pvDst = (uint8_t *)pvDst + cbChunk;
270	}
271
272	return *pcbRead && RT_FAILURE(rc) ? -rc : rc;
273
274	}
275
276
277	/**
278	* Write virtual memory API for the debugger, similar to
279	* PGMPhysSimpleWriteGCPtr.
280	*
281	* @returns VBox status code.
282	*
283	* @param pVM The VM handle.
284	* @param GCPtrDst Where to start writing.
285	* @param pvSrc What to write.
286	* @param cb The number of bytes to attempt writing.
287	* @param fFlags Flags, MBZ.
288	* @param pcbWritten For store the actual number of bytes written, pass NULL
289	* if partial writes are unwanted.
290	*/
291	VMMR3DECL(int) PGMR3DbgWriteGCPtr(PVM pVM, RTGCPTR GCPtrDst, void const pvSrc, size_t cb, uint32_t fFlags, size_t pcbWritten)
292	{
293	/* validate */
294	AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
295	AssertReturn(pVM, VERR_INVALID_PARAMETER);
296
297	/** @todo deal with HMA */
298	/* try simple first. */
299	int rc = PGMPhysSimpleWriteGCPtr(pVM, GCPtrDst, pvSrc, cb);
300	if (RT_SUCCESS(rc) \|\| !pcbWritten)
301	return rc;
302
303	/* partial write that failed, chop it up in pages. */
304	*pcbWritten = 0;
305	rc = VINF_SUCCESS;
306	while (cb > 0)
307	{
308	size_t cbChunk = PAGE_SIZE;
309	cbChunk -= GCPtrDst & PAGE_OFFSET_MASK;
310	if (cbChunk > cb)
311	cbChunk = cb;
312
313	rc = PGMPhysSimpleWriteGCPtr(pVM, GCPtrDst, pvSrc, cbChunk);
314
315	/* advance */
316	if (RT_FAILURE(rc))
317	break;
318	*pcbWritten += cbChunk;
319	cb -= cbChunk;
320	GCPtrDst += cbChunk;
321	pvSrc = (uint8_t const *)pvSrc + cbChunk;
322	}
323
324	return *pcbWritten && RT_FAILURE(rc) ? -rc : rc;
325
326	}
327
328
329
330	/**
331	* Scans a page for a byte string, keeping track of potential
332	* cross page matches.
333	*
334	* @returns true and *poff on match.
335	* false on mismatch.
336	* @param pbPage Pointer to the current page.
337	* @param poff Input: The offset into the page.
338	* Output: The page offset of the match on success.
339	* @param cb The number of bytes to search, starting of *poff.
340	* @param pabNeedle The byte string to search for.
341	* @param cbNeedle The length of the byte string.
342	* @param pabPrev The buffer that keeps track of a partial match that we
343	* bring over from the previous page. This buffer must be
344	* at least cbNeedle - 1 big.
345	* @param pcbPrev Input: The number of partial matching bytes from the previous page.
346	* Output: The number of partial matching bytes from this page.
347	* Initialize to 0 before the first call to this function.
348	*/
349	static bool pgmR3DbgScanPage(const uint8_t pbPage, int32_t poff, uint32_t cb,
350	const uint8_t *pabNeedle, size_t cbNeedle,
351	uint8_t pabPrev, size_t pcbPrev)
352	{
353	/*
354	* Try complete any partial match from the previous page.
355	*/
356	if (*pcbPrev > 0)
357	{
358	size_t cbPrev = *pcbPrev;
359	Assert(!*poff);
360	Assert(cbPrev < cbNeedle);
361	if (!memcmp(pbPage, pabNeedle + cbPrev, cbNeedle - cbPrev))
362	{
363	if (cbNeedle - cbPrev > cb)
364	return false;
365	*poff = -(int32_t)cbPrev;
366	return true;
367	}
368
369	/* check out the remainder of the previous page. */
370	const uint8_t *pb = pabPrev;
371	while (cbPrev-- > 0)
372	{
373	pb = (const uint8_t )memchr(pb + 1, pabNeedle, cbPrev);
374	if (!pb)
375	break;
376	cbPrev = *pcbPrev - (pb - pabPrev);
377	if ( !memcmp(pb + 1, &pabNeedle[1], cbPrev - 1)
378	&& !memcmp(pbPage, pabNeedle + cbPrev, cbNeedle - cbPrev))
379	{
380	if (cbNeedle - cbPrev > cb)
381	return false;
382	*poff = -(int32_t)cbPrev;
383	return true;
384	}
385	}
386
387	*pcbPrev = 0;
388	}
389
390	/*
391	* Match the body of the page.
392	*/
393	const uint8_t pb = pbPage + poff;
394	const uint8_t *pbEnd = pb + cb;
395	for (;;)
396	{
397	pb = (const uint8_t )memchr(pb, pabNeedle, cb);
398	if (!pb)
399	break;
400	cb = pbEnd - pb;
401	if (cb >= cbNeedle)
402	{
403	/* match? */
404	if (!memcmp(pb + 1, &pabNeedle[1], cbNeedle - 1))
405	{
406	*poff = pb - pbPage;
407	return true;
408	}
409	}
410	else
411	{
412	/* paritial match at the end of the page? */
413	if (!memcmp(pb + 1, &pabNeedle[1], cb - 1))
414	{
415	/* We're copying one byte more that we really need here, but wtf. */
416	memcpy(pabPrev, pb, cb);
417	*pcbPrev = cb;
418	return false;
419	}
420	}
421
422	/* no match, skip a byte ahead. */
423	if (cb <= 1)
424	break;
425	pb++;
426	cb--;
427	}
428
429	return false;
430	}
431
432
433	/**
434	* Scans guest physical memory for a byte string.
435	*
436	* @returns VBox status codes:
437	* @retval VINF_SUCCESS and *pGCPtrHit on success.
438	* @retval VERR_DBGF_MEM_NOT_FOUND if not found.
439	* @retval VERR_INVALID_POINTER if any of the pointer arguments are invalid.
440	* @retval VERR_INVALID_ARGUMENT if any other arguments are invalid.
441	*
442	* @param pVM Pointer to the shared VM structure.
443	* @param GCPhys Where to start searching.
444	* @param cbRange The number of bytes to search.
445	* @param pabNeedle The byte string to search for.
446	* @param cbNeedle The length of the byte string. Max 256 bytes.
447	* @param pGCPhysHit Where to store the address of the first occurence on success.
448	*/
449	VMMR3DECL(int) PGMR3DbgScanPhysical(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCPHYS pGCPhysHit)
450	{
451	/*
452	* Validate and adjust the input a bit.
453	*/
454	if (!VALID_PTR(pGCPhysHit))
455	return VERR_INVALID_POINTER;
456	*pGCPhysHit = NIL_RTGCPHYS;
457
458	if ( !VALID_PTR(pabNeedle)
459	\|\| GCPhys == NIL_RTGCPHYS)
460	return VERR_INVALID_POINTER;
461	if (!cbNeedle)
462	return VERR_INVALID_PARAMETER;
463	if (cbNeedle > MAX_NEEDLE_SIZE)
464	return VERR_INVALID_PARAMETER;
465
466	if (!cbRange)
467	return VERR_DBGF_MEM_NOT_FOUND;
468	if (GCPhys + cbNeedle - 1 < GCPhys)
469	return VERR_DBGF_MEM_NOT_FOUND;
470
471	const RTGCPHYS GCPhysLast = GCPhys + cbRange - 1 >= GCPhys
472	? GCPhys + cbRange - 1
473	: ~(RTGCPHYS)0;
474
475	/*
476	* Search the memory - ignore MMIO and zero pages, also don't
477	* bother to match across ranges.
478	*/
479	for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
480	pRam;
481	pRam = pRam->CTX_SUFF(pNext))
482	{
483	/*
484	* If the search range starts prior to the current ram range record,
485	* adjust the search range and possibly conclude the search.
486	*/
487	RTGCPHYS off;
488	if (GCPhys < pRam->GCPhys)
489	{
490	if (GCPhysLast < pRam->GCPhys)
491	break;
492	GCPhys = pRam->GCPhys;
493	off = 0;
494	}
495	else
496	off = GCPhys - pRam->GCPhys;
497	if (off < pRam->cb)
498	{
499	/*
500	* Iterate the relevant pages.
501	*/
502	uint8_t abPrev[MAX_NEEDLE_SIZE];
503	size_t cbPrev = 0;
504	const uint32_t cPages = pRam->cb >> PAGE_SHIFT;
505	for (uint32_t iPage = off >> PAGE_SHIFT; iPage < cPages; iPage++)
506	{
507	PPGMPAGE pPage = &pRam->aPages[iPage];
508	if ( !PGM_PAGE_IS_ZERO(pPage)
509	&& !PGM_PAGE_IS_MMIO(pPage))
510	{
511	void const *pvPage;
512	PGMPAGEMAPLOCK Lock;
513	int rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK, &pvPage, &Lock);
514	if (RT_SUCCESS(rc))
515	{
516	int32_t offPage = (GCPhys & PAGE_OFFSET_MASK);
517	uint32_t cbSearch = (GCPhys ^ GCPhysLast) & ~(RTGCPHYS)PAGE_OFFSET_MASK
518	? PAGE_SIZE - (uint32_t)offPage
519	: (GCPhysLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
520	bool fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offPage, cbSearch,
521	pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
522	PGMPhysReleasePageMappingLock(pVM, &Lock);
523	if (fRc)
524	{
525	*pGCPhysHit = (GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK) + offPage;
526	return VINF_SUCCESS;
527	}
528	}
529	else
530	cbPrev = 0; /* ignore error. */
531	}
532	else
533	cbPrev = 0;
534
535	/* advance to the next page. */
536	GCPhys \|= PAGE_OFFSET_MASK;
537	if (GCPhys++ >= GCPhysLast)
538	return VERR_DBGF_MEM_NOT_FOUND;
539	}
540	}
541	}
542	return VERR_DBGF_MEM_NOT_FOUND;
543	}
544
545
546	/**
547	* Scans (guest) virtual memory for a byte string.
548	*
549	* @returns VBox status codes:
550	* @retval VINF_SUCCESS and *pGCPtrHit on success.
551	* @retval VERR_DBGF_MEM_NOT_FOUND if not found.
552	* @retval VERR_INVALID_POINTER if any of the pointer arguments are invalid.
553	* @retval VERR_INVALID_ARGUMENT if any other arguments are invalid.
554	*
555	* @param pVM Pointer to the shared VM structure.
556	* @param GCPtr Where to start searching.
557	* @param cbRange The number of bytes to search. Max 256 bytes.
558	* @param pabNeedle The byte string to search for.
559	* @param cbNeedle The length of the byte string.
560	* @param pGCPtrHit Where to store the address of the first occurence on success.
561	*/
562	VMMR3DECL(int) PGMR3DbgScanVirtual(PVM pVM, RTGCPTR GCPtr, RTGCPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCUINTPTR pGCPtrHit)
563	{
564	/*
565	* Validate and adjust the input a bit.
566	*/
567	if (!VALID_PTR(pGCPtrHit))
568	return VERR_INVALID_POINTER;
569	*pGCPtrHit = 0;
570
571	if (!VALID_PTR(pabNeedle))
572	return VERR_INVALID_POINTER;
573	if (!cbNeedle)
574	return VERR_INVALID_PARAMETER;
575	if (cbNeedle > MAX_NEEDLE_SIZE)
576	return VERR_INVALID_PARAMETER;
577
578	if (!cbRange)
579	return VERR_DBGF_MEM_NOT_FOUND;
580	if (GCPtr + cbNeedle - 1 < GCPtr)
581	return VERR_DBGF_MEM_NOT_FOUND;
582
583	/*
584	* Search the memory - ignore MMIO, zero and not-present pages.
585	*/
586	uint8_t abPrev[MAX_NEEDLE_SIZE];
587	size_t cbPrev = 0;
588	const RTGCPTR GCPtrLast = GCPtr + cbRange - 1 >= GCPtr
589	? GCPtr + cbRange - 1
590	: ~(RTGCPTR)0;
591	RTGCPTR cPages = (((GCPtrLast - GCPtr) + (GCPtr & PAGE_OFFSET_MASK)) >> PAGE_SHIFT) + 1;
592	while (cPages-- > 0)
593	{
594	RTGCPHYS GCPhys;
595	int rc = PGMPhysGCPtr2GCPhys(pVM, GCPtr, &GCPhys);
596	if (RT_SUCCESS(rc))
597	{
598	PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
599	if ( pPage
600	///@todo && !PGM_PAGE_IS_ZERO(pPage)
601	&& !PGM_PAGE_IS_MMIO(pPage))
602	{
603	void const *pvPage;
604	PGMPAGEMAPLOCK Lock;
605	rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys & ~(RTGCPTR)PAGE_OFFSET_MASK, &pvPage, &Lock);
606	if (RT_SUCCESS(rc))
607	{
608	int32_t offPage = (GCPtr & PAGE_OFFSET_MASK);
609	uint32_t cbSearch = cPages > 0
610	? PAGE_SIZE - (uint32_t)offPage
611	: (GCPtrLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
612	bool fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offPage, cbSearch,
613	pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
614	PGMPhysReleasePageMappingLock(pVM, &Lock);
615	if (fRc)
616	{
617	*pGCPtrHit = (GCPtr & ~(RTGCPTR)PAGE_OFFSET_MASK) + offPage;
618	return VINF_SUCCESS;
619	}
620	}
621	else
622	cbPrev = 0; /* ignore error. */
623	}
624	else
625	cbPrev = 0;
626	}
627	else
628	cbPrev = 0; /* ignore error. */
629
630	/* advance to the next page. */
631	GCPtr \|= PAGE_OFFSET_MASK;
632	GCPtr++;
633	}
634	return VERR_DBGF_MEM_NOT_FOUND;
635	}
636

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

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

Download in other formats: