DBGFMem.cpp@ 23495

Last change on this file since 23495 was 23012, checked in by vboxsync, 15 years ago
VMM,Devices,Main: VMR3ReqCall w/ RT_INDEFINITE_WAIT -> VMR3ReqCallWait.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 16.8 KB

Line
1	/* $Id: DBGFMem.cpp 23012 2009-09-14 16:38:13Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Memory Methods.
4	*/
5
6	/*
7	* Copyright (C) 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	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_DBGF
27	#include <VBox/dbgf.h>
28	#include <VBox/pgm.h>
29	#include <VBox/selm.h>
30	#include <VBox/hwaccm.h>
31	#include "DBGFInternal.h"
32	#include <VBox/vm.h>
33	#include <VBox/err.h>
34	#include <VBox/log.h>
35	#include <VBox/mm.h>
36
37
38
39	/**
40	* Scan guest memory for an exact byte string.
41	*
42	* @returns VBox status code.
43	* @param pVM The VM handle.
44	* @param idCpu The ID of the CPU context to search in.
45	* @param pAddress Where to store the mixed address.
46	* @param pcbRange The number of bytes to scan. Passed as a pointer because
47	* it may be 64-bit.
48	* @param pabNeedle What to search for - exact search.
49	* @param cbNeedle Size of the search byte string.
50	* @param pHitAddress Where to put the address of the first hit.
51	*/
52	static DECLCALLBACK(int) dbgfR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, PCRTGCUINTPTR pcbRange,
53	const uint8_t *pabNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress)
54	{
55	Assert(idCpu == VMMGetCpuId(pVM));
56
57	/*
58	* Validate the input we use, PGM does the rest.
59	*/
60	RTGCUINTPTR cbRange = *pcbRange;
61	if (!DBGFR3AddrIsValid(pVM, pAddress))
62	return VERR_INVALID_POINTER;
63	if (!VALID_PTR(pHitAddress))
64	return VERR_INVALID_POINTER;
65	if (DBGFADDRESS_IS_HMA(pAddress))
66	return VERR_INVALID_POINTER;
67
68	/*
69	* Select DBGF worker by addressing mode.
70	*/
71	int rc;
72	PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
73	PGMMODE enmMode = PGMGetGuestMode(pVCpu);
74	if ( enmMode == PGMMODE_REAL
75	\|\| enmMode == PGMMODE_PROTECTED
76	\|\| DBGFADDRESS_IS_PHYS(pAddress)
77	)
78	{
79	RTGCPHYS PhysHit;
80	rc = PGMR3DbgScanPhysical(pVM, pAddress->FlatPtr, cbRange, pabNeedle, cbNeedle, &PhysHit);
81	if (RT_SUCCESS(rc))
82	DBGFR3AddrFromPhys(pVM, pHitAddress, PhysHit);
83	}
84	else
85	{
86	#if GC_ARCH_BITS > 32
87	if ( ( pAddress->FlatPtr >= _4G
88	\|\| pAddress->FlatPtr + cbRange > _4G)
89	&& enmMode != PGMMODE_AMD64
90	&& enmMode != PGMMODE_AMD64_NX)
91	return VERR_DBGF_MEM_NOT_FOUND;
92	#endif
93	RTGCUINTPTR GCPtrHit;
94	rc = PGMR3DbgScanVirtual(pVM, pVCpu, pAddress->FlatPtr, cbRange, pabNeedle, cbNeedle, &GCPtrHit);
95	if (RT_SUCCESS(rc))
96	DBGFR3AddrFromFlat(pVM, pHitAddress, GCPtrHit);
97	}
98
99	return rc;
100	}
101
102
103	/**
104	* Scan guest memory for an exact byte string.
105	*
106	* @returns VBox status codes:
107	* @retval VINF_SUCCESS and *pGCPtrHit on success.
108	* @retval VERR_DBGF_MEM_NOT_FOUND if not found.
109	* @retval VERR_INVALID_POINTER if any of the pointer arguments are invalid.
110	* @retval VERR_INVALID_ARGUMENT if any other arguments are invalid.
111	*
112	* @param pVM The VM handle.
113	* @param idCpu The ID of the CPU context to search in.
114	* @param pAddress Where to store the mixed address.
115	* @param cbRange The number of bytes to scan.
116	* @param pabNeedle What to search for - exact search.
117	* @param cbNeedle Size of the search byte string.
118	* @param pHitAddress Where to put the address of the first hit.
119	*
120	* @thread Any thread.
121	*/
122	VMMR3DECL(int) DBGFR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, RTGCUINTPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress)
123	{
124	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
125	return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3MemScan, 7,
126	pVM, idCpu, pAddress, &cbRange, pabNeedle, cbNeedle, pHitAddress);
127
128	}
129
130
131	/**
132	* Read guest memory.
133	*
134	* @returns VBox status code.
135	* @param pVM Pointer to the shared VM structure.
136	* @param pAddress Where to start reading.
137	* @param pvBuf Where to store the data we've read.
138	* @param cbRead The number of bytes to read.
139	*/
140	static DECLCALLBACK(int) dbgfR3MemRead(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void *pvBuf, size_t cbRead)
141	{
142	Assert(idCpu == VMMGetCpuId(pVM));
143
144	/*
145	* Validate the input we use, PGM does the rest.
146	*/
147	if (!DBGFR3AddrIsValid(pVM, pAddress))
148	return VERR_INVALID_POINTER;
149	if (!VALID_PTR(pvBuf))
150	return VERR_INVALID_POINTER;
151
152	/*
153	* HMA is special
154	*/
155	int rc;
156	if (DBGFADDRESS_IS_HMA(pAddress))
157	{
158	if (DBGFADDRESS_IS_PHYS(pAddress))
159	rc = VERR_INVALID_POINTER;
160	else
161	rc = MMR3HyperReadGCVirt(pVM, pvBuf, pAddress->FlatPtr, cbRead);
162	}
163	else
164	{
165	/*
166	* Select DBGF worker by addressing mode.
167	*/
168	PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
169	PGMMODE enmMode = PGMGetGuestMode(pVCpu);
170	if ( enmMode == PGMMODE_REAL
171	\|\| enmMode == PGMMODE_PROTECTED
172	\|\| DBGFADDRESS_IS_PHYS(pAddress) )
173	rc = PGMPhysSimpleReadGCPhys(pVM, pvBuf, pAddress->FlatPtr, cbRead);
174	else
175	{
176	#if GC_ARCH_BITS > 32
177	if ( ( pAddress->FlatPtr >= _4G
178	\|\| pAddress->FlatPtr + cbRead > _4G)
179	&& enmMode != PGMMODE_AMD64
180	&& enmMode != PGMMODE_AMD64_NX)
181	return VERR_PAGE_TABLE_NOT_PRESENT;
182	#endif
183	rc = PGMPhysSimpleReadGCPtr(pVCpu, pvBuf, pAddress->FlatPtr, cbRead);
184	}
185	}
186	return rc;
187	}
188
189
190	/**
191	* Read guest memory.
192	*
193	* @returns VBox status code.
194	*
195	* @param pVM Pointer to the shared VM structure.
196	* @param idCpu The ID of the source CPU context (for the address).
197	* @param pAddress Where to start reading.
198	* @param pvBuf Where to store the data we've read.
199	* @param cbRead The number of bytes to read.
200	*/
201	VMMR3DECL(int) DBGFR3MemRead(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void *pvBuf, size_t cbRead)
202	{
203	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
204	if ((pAddress->fFlags & DBGFADDRESS_FLAGS_TYPE_MASK) == DBGFADDRESS_FLAGS_RING0)
205	{
206	AssertCompile(sizeof(RTHCUINTPTR) <= sizeof(pAddress->FlatPtr));
207	return VMMR3ReadR0Stack(pVM, idCpu, (RTHCUINTPTR)pAddress->FlatPtr, pvBuf, cbRead);
208	}
209	return VMR3ReqCallWaitU(pVM->pUVM, idCpu, (PFNRT)dbgfR3MemRead, 5, pVM, idCpu, pAddress, pvBuf, cbRead);
210	}
211
212
213	/**
214	* Read a zero terminated string from guest memory.
215	*
216	* @returns VBox status code.
217	*
218	* @param pVM Pointer to the shared VM structure.
219	* @param idCpu The ID of the source CPU context (for the address).
220	* @param pAddress Where to start reading.
221	* @param pszBuf Where to store the string.
222	* @param cchBuf The size of the buffer.
223	*/
224	static DECLCALLBACK(int) dbgfR3MemReadString(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, char *pszBuf, size_t cchBuf)
225	{
226	/*
227	* Validate the input we use, PGM does the rest.
228	*/
229	if (!DBGFR3AddrIsValid(pVM, pAddress))
230	return VERR_INVALID_POINTER;
231	if (!VALID_PTR(pszBuf))
232	return VERR_INVALID_POINTER;
233
234	/*
235	* Let dbgfR3MemRead do the job.
236	*/
237	int rc = dbgfR3MemRead(pVM, idCpu, pAddress, pszBuf, cchBuf);
238
239	/*
240	* Make sure the result is terminated and that overflow is signaled.
241	* This may look a bit reckless with the rc but, it should be fine.
242	*/
243	if (!memchr(pszBuf, '\0', cchBuf))
244	{
245	pszBuf[cchBuf - 1] = '\0';
246	rc = VINF_BUFFER_OVERFLOW;
247	}
248	/*
249	* Handle partial reads (not perfect).
250	*/
251	else if (RT_FAILURE(rc))
252	{
253	if (pszBuf[0])
254	rc = VINF_SUCCESS;
255	}
256
257	return rc;
258	}
259
260
261	/**
262	* Read a zero terminated string from guest memory.
263	*
264	* @returns VBox status code.
265	*
266	* @param pVM Pointer to the shared VM structure.
267	* @param idCpu The ID of the source CPU context (for the address).
268	* @param pAddress Where to start reading.
269	* @param pszBuf Where to store the string.
270	* @param cchBuf The size of the buffer.
271	*/
272	VMMR3DECL(int) DBGFR3MemReadString(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, char *pszBuf, size_t cchBuf)
273	{
274	/*
275	* Validate and zero output.
276	*/
277	if (!VALID_PTR(pszBuf))
278	return VERR_INVALID_POINTER;
279	if (cchBuf <= 0)
280	return VERR_INVALID_PARAMETER;
281	memset(pszBuf, 0, cchBuf);
282	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
283
284	/*
285	* Pass it on to the EMT.
286	*/
287	return VMR3ReqCallWaitU(pVM->pUVM, idCpu, (PFNRT)dbgfR3MemReadString, 5, pVM, idCpu, pAddress, pszBuf, cchBuf);
288	}
289
290
291	/**
292	* Writes guest memory.
293	*
294	* @returns VBox status code.
295	*
296	* @param pVM Pointer to the shared VM structure.
297	* @param idCpu The ID of the target CPU context (for the address).
298	* @param pAddress Where to start writing.
299	* @param pvBuf The data to write.
300	* @param cbRead The number of bytes to write.
301	*/
302	static DECLCALLBACK(int) dbgfR3MemWrite(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void const *pvBuf, size_t cbWrite)
303	{
304	/*
305	* Validate the input we use, PGM does the rest.
306	*/
307	if (!DBGFR3AddrIsValid(pVM, pAddress))
308	return VERR_INVALID_POINTER;
309	if (!VALID_PTR(pvBuf))
310	return VERR_INVALID_POINTER;
311
312	/*
313	* HMA is always special.
314	*/
315	int rc;
316	if (DBGFADDRESS_IS_HMA(pAddress))
317	{
318	/** @todo write to HMA. */
319	rc = VERR_ACCESS_DENIED;
320	}
321	else
322	{
323	/*
324	* Select PGM function by addressing mode.
325	*/
326	PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
327	PGMMODE enmMode = PGMGetGuestMode(pVCpu);
328	if ( enmMode == PGMMODE_REAL
329	\|\| enmMode == PGMMODE_PROTECTED
330	\|\| DBGFADDRESS_IS_PHYS(pAddress) )
331	rc = PGMPhysSimpleWriteGCPhys(pVM, pAddress->FlatPtr, pvBuf, cbWrite);
332	else
333	{
334	#if GC_ARCH_BITS > 32
335	if ( ( pAddress->FlatPtr >= _4G
336	\|\| pAddress->FlatPtr + cbWrite > _4G)
337	&& enmMode != PGMMODE_AMD64
338	&& enmMode != PGMMODE_AMD64_NX)
339	return VERR_PAGE_TABLE_NOT_PRESENT;
340	#endif
341	rc = PGMPhysSimpleWriteGCPtr(pVCpu, pAddress->FlatPtr, pvBuf, cbWrite);
342	}
343	}
344	return rc;
345	}
346
347
348	/**
349	* Read guest memory.
350	*
351	* @returns VBox status code.
352	*
353	* @param pVM Pointer to the shared VM structure.
354	* @param idCpu The ID of the target CPU context (for the address).
355	* @param pAddress Where to start writing.
356	* @param pvBuf The data to write.
357	* @param cbRead The number of bytes to write.
358	*/
359	VMMR3DECL(int) DBGFR3MemWrite(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void const *pvBuf, size_t cbWrite)
360	{
361	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
362	return VMR3ReqCallWaitU(pVM->pUVM, idCpu, (PFNRT)dbgfR3MemWrite, 5, pVM, idCpu, pAddress, pvBuf, cbWrite);
363	}
364
365
366	/**
367	* Worker for DBGFR3SelQueryInfo that calls into SELM.
368	*/
369	static DECLCALLBACK(int) dbgfR3SelQueryInfo(PVM pVM, VMCPUID idCpu, RTSEL Sel, uint32_t fFlags, PDBGFSELINFO pSelInfo)
370	{
371	/*
372	* Make the query.
373	*/
374	int rc;
375	if (!(fFlags & DBGFSELQI_FLAGS_DT_SHADOW))
376	{
377	PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
378	VMCPU_ASSERT_EMT(pVCpu);
379	rc = SELMR3GetSelectorInfo(pVM, pVCpu, Sel, pSelInfo);
380
381	/*
382	* 64-bit mode HACKS for making data and stack selectors wide open when
383	* queried. This is voodoo magic.
384	*/
385	if (fFlags & DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE)
386	{
387	/* Expand 64-bit data and stack selectors. The check is a bit bogus... */
388	if ( RT_SUCCESS(rc)
389	&& (pSelInfo->fFlags & ( DBGFSELINFO_FLAGS_LONG_MODE \| DBGFSELINFO_FLAGS_REAL_MODE \| DBGFSELINFO_FLAGS_PROT_MODE
390	\| DBGFSELINFO_FLAGS_GATE \| DBGFSELINFO_FLAGS_HYPER
391	\| DBGFSELINFO_FLAGS_INVALID \| DBGFSELINFO_FLAGS_NOT_PRESENT))
392	== DBGFSELINFO_FLAGS_LONG_MODE
393	&& pSelInfo->cbLimit != ~(RTGCPTR)0
394	&& CPUMIsGuestIn64BitCode(pVCpu, CPUMGetGuestCtxCore(pVCpu)) )
395	{
396	pSelInfo->GCPtrBase = 0;
397	pSelInfo->cbLimit = ~(RTGCPTR)0;
398	}
399	else if ( Sel == 0
400	&& CPUMIsGuestIn64BitCode(pVCpu, CPUMGetGuestCtxCore(pVCpu)))
401	{
402	pSelInfo->GCPtrBase = 0;
403	pSelInfo->cbLimit = ~(RTGCPTR)0;
404	pSelInfo->Sel = 0;
405	pSelInfo->SelGate = 0;
406	pSelInfo->fFlags = DBGFSELINFO_FLAGS_LONG_MODE;
407	pSelInfo->u.Raw64.Gen.u1Present = 1;
408	pSelInfo->u.Raw64.Gen.u1Long = 1;
409	pSelInfo->u.Raw64.Gen.u1DescType = 1;
410	rc = VINF_SUCCESS;
411	}
412	}
413	}
414	else
415	{
416	if (HWACCMIsEnabled(pVM))
417	rc = VERR_INVALID_STATE;
418	else
419	rc = SELMR3GetShadowSelectorInfo(pVM, Sel, pSelInfo);
420	}
421	return rc;
422	}
423
424
425	/**
426	* Gets information about a selector.
427	*
428	* Intended for the debugger mostly and will prefer the guest
429	* descriptor tables over the shadow ones.
430	*
431	* @returns VBox status code, the following are the common ones.
432	* @retval VINF_SUCCESS on success.
433	* @retval VERR_INVALID_SELECTOR if the selector isn't fully inside the
434	* descriptor table.
435	* @retval VERR_SELECTOR_NOT_PRESENT if the LDT is invalid or not present. This
436	* is not returned if the selector itself isn't present, you have to
437	* check that for yourself (see DBGFSELINFO::fFlags).
438	* @retval VERR_PAGE_TABLE_NOT_PRESENT or VERR_PAGE_NOT_PRESENT if the
439	* pagetable or page backing the selector table wasn't present.
440	*
441	* @param pVM VM handle.
442	* @param idCpu The ID of the virtual CPU context.
443	* @param Sel The selector to get info about.
444	* @param fFlags Flags, see DBGFQSEL_FLAGS_*.
445	* @param pSelInfo Where to store the information. This will always be
446	* updated.
447	*
448	* @remarks This is a wrapper around SELMR3GetSelectorInfo and
449	* SELMR3GetShadowSelectorInfo.
450	*/
451	VMMR3DECL(int) DBGFR3SelQueryInfo(PVM pVM, VMCPUID idCpu, RTSEL Sel, uint32_t fFlags, PDBGFSELINFO pSelInfo)
452	{
453	AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
454	AssertReturn(!(fFlags & ~(DBGFSELQI_FLAGS_DT_GUEST \| DBGFSELQI_FLAGS_DT_SHADOW \| DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE)), VERR_INVALID_PARAMETER);
455	AssertReturn( (fFlags & (DBGFSELQI_FLAGS_DT_SHADOW \| DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE))
456	!= (DBGFSELQI_FLAGS_DT_SHADOW \| DBGFSELQI_FLAGS_DT_ADJ_64BIT_MODE), VERR_INVALID_PARAMETER);
457
458	/* Clear the return data here on this thread. */
459	memset(pSelInfo, 0, sizeof(*pSelInfo));
460
461	/*
462	* Dispatch the request to a worker running on the target CPU.
463	*/
464	return VMR3ReqCallWaitU(pVM->pUVM, idCpu, (PFNRT)dbgfR3SelQueryInfo, 5, pVM, idCpu, Sel, fFlags, pSelInfo);
465	}
466
467
468	/**
469	* Validates a CS selector.
470	*
471	* @returns VBox status code.
472	* @param pSelInfo Pointer to the selector information for the CS selector.
473	* @param SelCPL The selector defining the CPL (SS).
474	*/
475	VMMDECL(int) DBGFR3SelInfoValidateCS(PCDBGFSELINFO pSelInfo, RTSEL SelCPL)
476	{
477	/*
478	* Check if present.
479	*/
480	if (pSelInfo->u.Raw.Gen.u1Present)
481	{
482	/*
483	* Type check.
484	*/
485	if ( pSelInfo->u.Raw.Gen.u1DescType == 1
486	&& (pSelInfo->u.Raw.Gen.u4Type & X86_SEL_TYPE_CODE))
487	{
488	/*
489	* Check level.
490	*/
491	unsigned uLevel = RT_MAX(SelCPL & X86_SEL_RPL, pSelInfo->Sel & X86_SEL_RPL);
492	if ( !(pSelInfo->u.Raw.Gen.u4Type & X86_SEL_TYPE_CONF)
493	? uLevel <= pSelInfo->u.Raw.Gen.u2Dpl
494	: uLevel >= pSelInfo->u.Raw.Gen.u2Dpl /* hope I got this right now... */
495	)
496	return VINF_SUCCESS;
497	return VERR_INVALID_RPL;
498	}
499	return VERR_NOT_CODE_SELECTOR;
500	}
501	return VERR_SELECTOR_NOT_PRESENT;
502	}
503
504

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

source: vbox/trunk/src/VBox/VMM/DBGFMem.cpp@ 23495

Download in other formats: