DBGFCoreWrite.cpp@ 56384

最後變更在這個檔案從56384是 56302,由 vboxsync 提交於 10 年前
DBGFCoreWrite: bump version, comments, hungarian fixes and cleanup.
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 19.9 KB

行
1	/* $Id: DBGFCoreWrite.cpp 56302 2015-06-09 15:14:40Z vboxsync $ */
2	/** @file
3	* DBGF - Debugger Facility, Guest Core Dump.
4	*/
5
6	/*
7	* Copyright (C) 2010-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.alldomusa.eu.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	/** @page pg_dbgf_vmcore VMCore Format
19	*
20	* The VirtualBox VMCore Format:
21	* [ ELF 64 Header] -- Only 1
22	*
23	* [ PT_NOTE ] -- Only 1
24	* - Offset into CoreDescriptor followed by list of Notes (Note Hdr + data) of VBox CPUs.
25	* - (Any Additional custom Note sections).
26	*
27	* [ PT_LOAD ] -- One for each contiguous memory chunk
28	* - Memory offset (physical).
29	* - File offset.
30	*
31	* CoreDescriptor
32	* - Magic, VBox version.
33	* - Number of CPus.
34	*
35	* Per-CPU register dump
36	* - CPU 1 Note Hdr + Data.
37	* - CPU 2 Note Hdr + Data.
38	* ...
39	* (Additional custom notes Hdr+data)
40	* - VBox 1 Note Hdr + Data.
41	* - VBox 2 Note Hdr + Data.
42	* ...
43	* Memory dump
44	*
45	*/
46
47	/*******************************************************************************
48	* Header Files *
49	*******************************************************************************/
50	#define LOG_GROUP LOG_GROUP_DBGF
51	#include <iprt/param.h>
52	#include <iprt/file.h>
53
54	#include "DBGFInternal.h"
55
56	#include <VBox/vmm/cpum.h>
57	#include <VBox/vmm/pgm.h>
58	#include <VBox/vmm/dbgf.h>
59	#include <VBox/vmm/dbgfcorefmt.h>
60	#include <VBox/vmm/mm.h>
61	#include <VBox/vmm/vm.h>
62	#include <VBox/vmm/uvm.h>
63
64	#include <VBox/err.h>
65	#include <VBox/log.h>
66	#include <VBox/version.h>
67
68	#include "../../Runtime/include/internal/ldrELF64.h"
69
70
71	/*******************************************************************************
72	* Defined Constants And Macros *
73	*******************************************************************************/
74	#define DBGFLOG_NAME "DBGFCoreWrite"
75
76
77	/*******************************************************************************
78	* Global Variables *
79	*******************************************************************************/
80	static const int g_NoteAlign = 8;
81	static const int g_cbNoteName = 16;
82
83	/* The size of these strings (incl. NULL terminator) must align to 8 bytes (g_NoteAlign) and -not- 4 bytes. */
84	static const char *g_pcszCoreVBoxCore = "VBCORE";
85	static const char *g_pcszCoreVBoxCpu = "VBCPU";
86
87
88	/*******************************************************************************
89	* Structures and Typedefs *
90	*******************************************************************************/
91	/**
92	* Guest core writer data.
93	*
94	* Used to pass parameters from DBGFR3CoreWrite to dbgfR3CoreWriteRendezvous().
95	*/
96	typedef struct DBGFCOREDATA
97	{
98	/** The name of the file to write the file to. */
99	const char *pszFilename;
100	/** Whether to replace (/overwrite) any existing file. */
101	bool fReplaceFile;
102	} DBGFCOREDATA;
103	/** Pointer to the guest core writer data. */
104	typedef DBGFCOREDATA *PDBGFCOREDATA;
105
106
107
108	/**
109	* ELF function to write 64-bit ELF header.
110	*
111	* @param hFile The file to write to.
112	* @param cProgHdrs Number of program headers.
113	* @param cSecHdrs Number of section headers.
114	*
115	* @return IPRT status code.
116	*/
117	static int Elf64WriteElfHdr(RTFILE hFile, uint16_t cProgHdrs, uint16_t cSecHdrs)
118	{
119	Elf64_Ehdr ElfHdr;
120	RT_ZERO(ElfHdr);
121	ElfHdr.e_ident[EI_MAG0] = ELFMAG0;
122	ElfHdr.e_ident[EI_MAG1] = ELFMAG1;
123	ElfHdr.e_ident[EI_MAG2] = ELFMAG2;
124	ElfHdr.e_ident[EI_MAG3] = ELFMAG3;
125	ElfHdr.e_ident[EI_DATA] = ELFDATA2LSB;
126	ElfHdr.e_type = ET_CORE;
127	ElfHdr.e_version = EV_CURRENT;
128	ElfHdr.e_ident[EI_CLASS] = ELFCLASS64;
129	/* 32-bit builds will produce cores with e_machine EM_386. */
130	#ifdef RT_ARCH_AMD64
131	ElfHdr.e_machine = EM_X86_64;
132	#else
133	ElfHdr.e_machine = EM_386;
134	#endif
135	ElfHdr.e_phnum = cProgHdrs;
136	ElfHdr.e_shnum = cSecHdrs;
137	ElfHdr.e_ehsize = sizeof(ElfHdr);
138	ElfHdr.e_phoff = sizeof(ElfHdr);
139	ElfHdr.e_phentsize = sizeof(Elf64_Phdr);
140	ElfHdr.e_shentsize = sizeof(Elf64_Shdr);
141
142	return RTFileWrite(hFile, &ElfHdr, sizeof(ElfHdr), NULL /* all */);
143	}
144
145
146	/**
147	* ELF function to write 64-bit program header.
148	*
149	* @param hFile The file to write to.
150	* @param Type Type of program header (PT_*).
151	* @param fFlags Flags (access permissions, PF_*).
152	* @param offFileData File offset of contents.
153	* @param cbFileData Size of contents in the file.
154	* @param cbMemData Size of contents in memory.
155	* @param Phys Physical address, pass zero if not applicable.
156	*
157	* @return IPRT status code.
158	*/
159	static int Elf64WriteProgHdr(RTFILE hFile, uint32_t Type, uint32_t fFlags, uint64_t offFileData, uint64_t cbFileData,
160	uint64_t cbMemData, RTGCPHYS Phys)
161	{
162	Elf64_Phdr ProgHdr;
163	RT_ZERO(ProgHdr);
164	ProgHdr.p_type = Type;
165	ProgHdr.p_flags = fFlags;
166	ProgHdr.p_offset = offFileData;
167	ProgHdr.p_filesz = cbFileData;
168	ProgHdr.p_memsz = cbMemData;
169	ProgHdr.p_paddr = Phys;
170
171	return RTFileWrite(hFile, &ProgHdr, sizeof(ProgHdr), NULL /* all */);
172	}
173
174
175	/**
176	* Returns the size of the NOTE section given the name and size of the data.
177	*
178	* @param pszName Name of the note section.
179	* @param cb Size of the data portion of the note section.
180	*
181	* @return The size of the NOTE section as rounded to the file alignment.
182	*/
183	static uint64_t Elf64NoteSectionSize(const char *pszName, uint64_t cbData)
184	{
185	uint64_t cbNote = sizeof(Elf64_Nhdr);
186
187	size_t cbName = strlen(pszName) + 1;
188	size_t cbNameAlign = RT_ALIGN_Z(cbName, g_NoteAlign);
189
190	cbNote += cbNameAlign;
191	cbNote += RT_ALIGN_64(cbData, g_NoteAlign);
192	return cbNote;
193	}
194
195
196	/**
197	* Elf function to write 64-bit note header.
198	*
199	* @param hFile The file to write to.
200	* @param Type Type of this section.
201	* @param pszName Name of this section.
202	* @param pcv Opaque pointer to the data, if NULL only computes size.
203	* @param cbData Size of the data.
204	*
205	* @return IPRT status code.
206	*/
207	static int Elf64WriteNoteHdr(RTFILE hFile, uint16_t Type, const char pszName, const void pcvData, uint64_t cbData)
208	{
209	AssertReturn(pcvData, VERR_INVALID_POINTER);
210	AssertReturn(cbData > 0, VERR_NO_DATA);
211
212	char szNoteName[g_cbNoteName];
213	RT_ZERO(szNoteName);
214	RTStrCopy(szNoteName, sizeof(szNoteName), pszName);
215
216	size_t cbName = strlen(szNoteName) + 1;
217	size_t cbNameAlign = RT_ALIGN_Z(cbName, g_NoteAlign);
218	uint64_t cbDataAlign = RT_ALIGN_64(cbData, g_NoteAlign);
219
220	/*
221	* Yell loudly and bail if we are going to be writing a core file that is not compatible with
222	* both Solaris and the 64-bit ELF spec. which dictates 8-byte alignment. See @bugref{5211} comment #3.
223	*/
224	if (cbNameAlign - cbName > 3)
225	{
226	LogRel((DBGFLOG_NAME ": Elf64WriteNoteHdr pszName=%s cbName=%u cbNameAlign=%u, cbName aligns to 4 not 8-bytes!\n",
227	pszName, cbName, cbNameAlign));
228	return VERR_INVALID_PARAMETER;
229	}
230
231	if (cbDataAlign - cbData > 3)
232	{
233	LogRel((DBGFLOG_NAME ": Elf64WriteNoteHdr pszName=%s cbData=%u cbDataAlign=%u, cbData aligns to 4 not 8-bytes!\n",
234	pszName, cbData, cbDataAlign));
235	return VERR_INVALID_PARAMETER;
236	}
237
238	static const char s_achPad[7] = { 0, 0, 0, 0, 0, 0, 0 };
239	AssertCompile(sizeof(s_achPad) >= g_NoteAlign - 1);
240
241	Elf64_Nhdr ElfNoteHdr;
242	RT_ZERO(ElfNoteHdr);
243	ElfNoteHdr.n_namesz = (Elf64_Word)cbName - 1; /* Again, a discrepancy between ELF-64 and Solaris,
244	we will follow ELF-64, see @bugref{5211} comment #3. */
245	ElfNoteHdr.n_type = Type;
246	ElfNoteHdr.n_descsz = (Elf64_Word)cbDataAlign;
247
248	/*
249	* Write note header.
250	*/
251	int rc = RTFileWrite(hFile, &ElfNoteHdr, sizeof(ElfNoteHdr), NULL /* all */);
252	if (RT_SUCCESS(rc))
253	{
254	/*
255	* Write note name.
256	*/
257	rc = RTFileWrite(hFile, szNoteName, cbName, NULL /* all */);
258	if (RT_SUCCESS(rc))
259	{
260	/*
261	* Write note name padding if required.
262	*/
263	if (cbNameAlign > cbName)
264	rc = RTFileWrite(hFile, s_achPad, cbNameAlign - cbName, NULL);
265
266	if (RT_SUCCESS(rc))
267	{
268	/*
269	* Write note data.
270	*/
271	rc = RTFileWrite(hFile, pcvData, cbData, NULL /* all */);
272	if (RT_SUCCESS(rc))
273	{
274	/*
275	* Write note data padding if required.
276	*/
277	if (cbDataAlign > cbData)
278	rc = RTFileWrite(hFile, s_achPad, cbDataAlign - cbData, NULL /* all*/);
279	}
280	}
281	}
282	}
283
284	if (RT_FAILURE(rc))
285	LogRel((DBGFLOG_NAME ": RTFileWrite failed. rc=%Rrc pszName=%s cbName=%u cbNameAlign=%u cbData=%u cbDataAlign=%u\n",
286	rc, pszName, cbName, cbNameAlign, cbData, cbDataAlign));
287
288	return rc;
289	}
290
291
292	/**
293	* Count the number of memory ranges that go into the core file.
294	*
295	* We cannot do a page-by-page dump of the entire guest memory as there will be
296	* way too many program header entries. Also we don't want to dump MMIO regions
297	* which means we cannot have a 1:1 mapping between core file offset and memory
298	* offset. Instead we dump the memory in ranges. A memory range is a contiguous
299	* memory area suitable for dumping to a core file.
300	*
301	* @param pVM Pointer to the VM.
302	*
303	* @return Number of memory ranges
304	*/
305	static uint32_t dbgfR3GetRamRangeCount(PVM pVM)
306	{
307	return PGMR3PhysGetRamRangeCount(pVM);
308	}
309
310
311	/**
312	* Worker function for dbgfR3CoreWrite() which does the writing.
313	*
314	* @returns VBox status code
315	* @param pVM Pointer to the VM.
316	* @param hFile The file to write to. Caller closes this.
317	*/
318	static int dbgfR3CoreWriteWorker(PVM pVM, RTFILE hFile)
319	{
320	/*
321	* Collect core information.
322	*/
323	uint32_t const cu32MemRanges = dbgfR3GetRamRangeCount(pVM);
324	uint16_t const cMemRanges = cu32MemRanges < UINT16_MAX - 1 ? cu32MemRanges : UINT16_MAX - 1; /* One PT_NOTE Program header */
325	uint16_t const cProgHdrs = cMemRanges + 1;
326
327	DBGFCOREDESCRIPTOR CoreDescriptor;
328	RT_ZERO(CoreDescriptor);
329	CoreDescriptor.u32Magic = DBGFCORE_MAGIC;
330	CoreDescriptor.u32FmtVersion = DBGFCORE_FMT_VERSION;
331	CoreDescriptor.cbSelf = sizeof(CoreDescriptor);
332	CoreDescriptor.u32VBoxVersion = VBOX_FULL_VERSION;
333	CoreDescriptor.u32VBoxRevision = VMMGetSvnRev();
334	CoreDescriptor.cCpus = pVM->cCpus;
335
336	Log((DBGFLOG_NAME ": CoreDescriptor Version=%u Revision=%u\n", CoreDescriptor.u32VBoxVersion, CoreDescriptor.u32VBoxRevision));
337
338	/*
339	* Compute the file layout (see pg_dbgf_vmcore).
340	*/
341	uint64_t const offElfHdr = RTFileTell(hFile);
342	uint64_t const offNoteSection = offElfHdr + sizeof(Elf64_Ehdr);
343	uint64_t const offLoadSections = offNoteSection + sizeof(Elf64_Phdr);
344	uint64_t const cbLoadSections = cMemRanges * sizeof(Elf64_Phdr);
345	uint64_t const offCoreDescriptor = offLoadSections + cbLoadSections;
346	uint64_t const cbCoreDescriptor = Elf64NoteSectionSize(g_pcszCoreVBoxCore, sizeof(CoreDescriptor));
347	uint64_t const offCpuDumps = offCoreDescriptor + cbCoreDescriptor;
348	uint64_t const cbCpuDumps = pVM->cCpus * Elf64NoteSectionSize(g_pcszCoreVBoxCpu, sizeof(CPUMCTX));
349	uint64_t const offMemory = offCpuDumps + cbCpuDumps;
350
351	uint64_t const offNoteSectionData = offCoreDescriptor;
352	uint64_t const cbNoteSectionData = cbCoreDescriptor + cbCpuDumps;
353
354	/*
355	* Write ELF header.
356	*/
357	int rc = Elf64WriteElfHdr(hFile, cProgHdrs, 0 /* cSecHdrs */);
358	if (RT_FAILURE(rc))
359	{
360	LogRel((DBGFLOG_NAME ": Elf64WriteElfHdr failed. rc=%Rrc\n", rc));
361	return rc;
362	}
363
364	/*
365	* Write PT_NOTE program header.
366	*/
367	Assert(RTFileTell(hFile) == offNoteSection);
368	rc = Elf64WriteProgHdr(hFile, PT_NOTE, PF_R,
369	offNoteSectionData, /* file offset to contents */
370	cbNoteSectionData, /* size in core file */
371	cbNoteSectionData, /* size in memory */
372	0); /* physical address */
373	if (RT_FAILURE(rc))
374	{
375	LogRel((DBGFLOG_NAME ": Elf64WritreProgHdr failed for PT_NOTE. rc=%Rrc\n", rc));
376	return rc;
377	}
378
379	/*
380	* Write PT_LOAD program header for each memory range.
381	*/
382	Assert(RTFileTell(hFile) == offLoadSections);
383	uint64_t offMemRange = offMemory;
384	for (uint16_t iRange = 0; iRange < cMemRanges; iRange++)
385	{
386	RTGCPHYS GCPhysStart;
387	RTGCPHYS GCPhysEnd;
388	bool fIsMmio;
389	rc = PGMR3PhysGetRange(pVM, iRange, &GCPhysStart, &GCPhysEnd, NULL /* pszDesc */, &fIsMmio);
390	if (RT_FAILURE(rc))
391	{
392	LogRel((DBGFLOG_NAME ": PGMR3PhysGetRange failed for iRange(%u) rc=%Rrc\n", iRange, rc));
393	return rc;
394	}
395
396	uint64_t cbMemRange = GCPhysEnd - GCPhysStart + 1;
397	uint64_t cbFileRange = fIsMmio ? 0 : cbMemRange;
398
399	Log((DBGFLOG_NAME ": PGMR3PhysGetRange iRange=%u GCPhysStart=%#x GCPhysEnd=%#x cbMemRange=%u\n",
400	iRange, GCPhysStart, GCPhysEnd, cbMemRange));
401
402	rc = Elf64WriteProgHdr(hFile, PT_LOAD, PF_R,
403	offMemRange, /* file offset to contents */
404	cbFileRange, /* size in core file */
405	cbMemRange, /* size in memory */
406	GCPhysStart); /* physical address */
407	if (RT_FAILURE(rc))
408	{
409	LogRel((DBGFLOG_NAME ": Elf64WriteProgHdr failed for memory range(%u) cbFileRange=%u cbMemRange=%u rc=%Rrc\n",
410	iRange, cbFileRange, cbMemRange, rc));
411	return rc;
412	}
413
414	offMemRange += cbFileRange;
415	}
416
417	/*
418	* Write the Core descriptor note header and data.
419	*/
420	Assert(RTFileTell(hFile) == offCoreDescriptor);
421	rc = Elf64WriteNoteHdr(hFile, NT_VBOXCORE, g_pcszCoreVBoxCore, &CoreDescriptor, sizeof(CoreDescriptor));
422	if (RT_FAILURE(rc))
423	{
424	LogRel((DBGFLOG_NAME ": Elf64WriteNoteHdr failed for Note '%s' rc=%Rrc\n", g_pcszCoreVBoxCore, rc));
425	return rc;
426	}
427
428	/*
429	* Write the CPU context note headers and data.
430	*/
431	/** @todo r=ramshankar: Dump a more standardized CPU structure rather than
432	* dumping CPUMCTX and bump the core file version number. */
433	Assert(RTFileTell(hFile) == offCpuDumps);
434	for (uint32_t iCpu = 0; iCpu < pVM->cCpus; iCpu++)
435	{
436	PCPUMCTX pCpuCtx = CPUMQueryGuestCtxPtr(&pVM->aCpus[iCpu]);
437	rc = Elf64WriteNoteHdr(hFile, NT_VBOXCPU, g_pcszCoreVBoxCpu, pCpuCtx, sizeof(CPUMCTX));
438	if (RT_FAILURE(rc))
439	{
440	LogRel((DBGFLOG_NAME ": Elf64WriteNoteHdr failed for vCPU[%u] rc=%Rrc\n", iCpu, rc));
441	return rc;
442	}
443	}
444
445	/*
446	* Write memory ranges.
447	*/
448	Assert(RTFileTell(hFile) == offMemory);
449	for (uint16_t iRange = 0; iRange < cMemRanges; iRange++)
450	{
451	RTGCPHYS GCPhysStart;
452	RTGCPHYS GCPhysEnd;
453	bool fIsMmio;
454	rc = PGMR3PhysGetRange(pVM, iRange, &GCPhysStart, &GCPhysEnd, NULL /* pszDesc */, &fIsMmio);
455	if (RT_FAILURE(rc))
456	{
457	LogRel((DBGFLOG_NAME ": PGMR3PhysGetRange(2) failed for iRange(%u) rc=%Rrc\n", iRange, rc));
458	return rc;
459	}
460
461	if (fIsMmio)
462	continue;
463
464	/*
465	* Write page-by-page of this memory range.
466	*
467	* The read function may fail on MMIO ranges, we write these as zero
468	* pages for now (would be nice to have the VGA bits there though).
469	*/
470	uint64_t cbMemRange = GCPhysEnd - GCPhysStart + 1;
471	uint64_t cPages = cbMemRange >> PAGE_SHIFT;
472	for (uint64_t iPage = 0; iPage < cPages; iPage++)
473	{
474	uint8_t abPage[PAGE_SIZE];
475	rc = PGMPhysSimpleReadGCPhys(pVM, abPage, GCPhysStart + (iPage << PAGE_SHIFT), sizeof(abPage));
476	if (RT_FAILURE(rc))
477	{
478	if (rc != VERR_PGM_PHYS_PAGE_RESERVED)
479	LogRel((DBGFLOG_NAME ": PGMPhysRead failed for iRange=%u iPage=%u. rc=%Rrc. Ignoring...\n", iRange, iPage, rc));
480	RT_ZERO(abPage);
481	}
482
483	rc = RTFileWrite(hFile, abPage, sizeof(abPage), NULL /* all */);
484	if (RT_FAILURE(rc))
485	{
486	LogRel((DBGFLOG_NAME ": RTFileWrite failed. iRange=%u iPage=%u rc=%Rrc\n", iRange, iPage, rc));
487	return rc;
488	}
489	}
490	}
491
492	return rc;
493	}
494
495
496	/**
497	* EMT Rendezvous worker function for DBGFR3CoreWrite().
498	*
499	* @param pVM Pointer to the VM.
500	* @param pVCpu The handle of the calling VCPU.
501	* @param pvData Opaque data.
502	*
503	* @return VBox status code.
504	*/
505	static DECLCALLBACK(VBOXSTRICTRC) dbgfR3CoreWriteRendezvous(PVM pVM, PVMCPU pVCpu, void *pvData)
506	{
507	/*
508	* Validate input.
509	*/
510	AssertReturn(pVM, VERR_INVALID_VM_HANDLE);
511	AssertReturn(pVCpu, VERR_INVALID_VMCPU_HANDLE);
512	AssertReturn(pvData, VERR_INVALID_POINTER);
513
514	PDBGFCOREDATA pDbgfData = (PDBGFCOREDATA)pvData;
515
516	/*
517	* Create the core file.
518	*/
519	uint32_t fFlags = (pDbgfData->fReplaceFile ? RTFILE_O_CREATE_REPLACE : RTFILE_O_CREATE)
520	\| RTFILE_O_WRITE
521	\| RTFILE_O_DENY_ALL
522	\| (0600 << RTFILE_O_CREATE_MODE_SHIFT);
523	RTFILE hFile;
524	int rc = RTFileOpen(&hFile, pDbgfData->pszFilename, fFlags);
525	if (RT_SUCCESS(rc))
526	{
527	rc = dbgfR3CoreWriteWorker(pVM, hFile);
528	RTFileClose(hFile);
529	}
530	else
531	LogRel((DBGFLOG_NAME ": RTFileOpen failed for '%s' rc=%Rrc\n", pDbgfData->pszFilename, rc));
532	return rc;
533	}
534
535
536	/**
537	* Write core dump of the guest.
538	*
539	* @returns VBox status code.
540	* @param pUVM The user mode VM handle.
541	* @param pszFilename The name of the file to which the guest core
542	* dump should be written.
543	* @param fReplaceFile Whether to replace the file or not.
544	*
545	* @remarks The VM may need to be suspended before calling this function in
546	* order to truly stop all device threads and drivers. This function
547	* only synchronizes EMTs.
548	*/
549	VMMR3DECL(int) DBGFR3CoreWrite(PUVM pUVM, const char *pszFilename, bool fReplaceFile)
550	{
551	UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
552	PVM pVM = pUVM->pVM;
553	VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
554	AssertReturn(pszFilename, VERR_INVALID_HANDLE);
555
556	/*
557	* Pass the core write request down to EMT rendezvous which makes sure
558	* other EMTs, if any, are not running. IO threads could still be running
559	* but we don't care about them.
560	*/
561	DBGFCOREDATA CoreData;
562	RT_ZERO(CoreData);
563	CoreData.pszFilename = pszFilename;
564	CoreData.fReplaceFile = fReplaceFile;
565
566	int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, dbgfR3CoreWriteRendezvous, &CoreData);
567	if (RT_SUCCESS(rc))
568	LogRel((DBGFLOG_NAME ": Successfully wrote guest core dump '%s'\n", pszFilename));
569	else
570	LogRel((DBGFLOG_NAME ": Failed to write guest core dump '%s'. rc=%Rrc\n", pszFilename, rc));
571	return rc;
572	}
573

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFCoreWrite.cpp@ 56384

以其他格式下載: