DBGPlugInSolaris.cpp@ 95638

Last change on this file since 95638 was 93485, checked in by vboxsync, 3 years ago
Debugger,Main: Doxygen fixes. bugref:10074
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 46.5 KB

Line
1	/* $Id: DBGPlugInSolaris.cpp 93485 2022-01-29 12:32:20Z vboxsync $ */
2	/** @file
3	* DBGPlugInSolaris - Debugger and Guest OS Digger Plugin For Solaris.
4	*/
5
6	/*
7	* Copyright (C) 2008-2022 Oracle Corporation
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
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DBGF /// @todo add new log group.
23	#include "DBGPlugIns.h"
24	#include "DBGPlugInCommonELF.h"
25	#include <VBox/vmm/dbgf.h>
26	#include <VBox/vmm/vmmr3vtable.h>
27	#include <iprt/asm.h>
28	#include <iprt/err.h>
29	#include <iprt/mem.h>
30	#include <iprt/stream.h>
31	#include <iprt/string.h>
32
33
34	/*********************************************************************************************************************************
35	* Defined Constants And Macros *
36	*********************************************************************************************************************************/
37	/** Solaris on little endian ASCII systems. */
38	#define DIG_SOL_MOD_TAG UINT64_C(0x00736972616c6f53)
39
40
41	/*********************************************************************************************************************************
42	* Structures and Typedefs *
43	*********************************************************************************************************************************/
44
45	/** @name InternalSolaris structures
46	* @{ */
47
48	/** sys/modctl.h */
49	typedef struct SOL32v11_modctl
50	{
51	uint32_t mod_next; /*< 0 /
52	uint32_t mod_prev; /*< 4 /
53	int32_t mod_id; /*< 8 /
54	uint32_t mod_mp; /*< c Pointer to the kernel runtime loader bits. /
55	uint32_t mod_inprogress_thread; /*< 10 /
56	uint32_t mod_modinfo; /*< 14 /
57	uint32_t mod_linkage; /*< 18 /
58	uint32_t mod_filename; /*< 1c /
59	uint32_t mod_modname; /*< 20 /
60	int8_t mod_busy; /*< 24 /
61	int8_t mod_want; /*< 25 /
62	int8_t mod_prim; /*< 26 this is 1 for 'unix' and a few others. /
63	int8_t mod_unused_padding; /*< 27 /
64	int32_t mod_ref; /*< 28 /
65	int8_t mod_loaded; /*< 2c /
66	int8_t mod_installed; /*< 2d /
67	int8_t mod_loadflags; /*< 2e /
68	int8_t mod_delay_unload; /*< 2f /
69	uint32_t mod_requisites; /*< 30 /
70	uint32_t mod___unused; /*< 34 /
71	int32_t mod_loadcnt; /*< 38 /
72	int32_t mod_nenabled; /*< 3c /
73	uint32_t mod_text; /*< 40 /
74	uint32_t mod_text_size; /*< 44 /
75	int32_t mod_gencount; /*< 48 /
76	uint32_t mod_requisite_loading; /*< 4c /
77	} SOL32v11_modctl_t;
78	AssertCompileSize(SOL32v11_modctl_t, 0x50);
79
80	typedef struct SOL64v11_modctl
81	{
82	uint64_t mod_next; /*< 0 /
83	uint64_t mod_prev; /*< 8 /
84	int32_t mod_id; /*< 10 /
85	int32_t mod_padding0;
86	uint64_t mod_mp; /*< 18 Pointer to the kernel runtime loader bits. /
87	uint64_t mod_inprogress_thread; /*< 20 /
88	uint64_t mod_modinfo; /*< 28 /
89	uint64_t mod_linkage; /*< 30 /
90	uint64_t mod_filename; /*< 38 /
91	uint64_t mod_modname; /*< 40 /
92	int8_t mod_busy; /*< 48 /
93	int8_t mod_want; /*< 49 /
94	int8_t mod_prim; /*< 4a this is 1 for 'unix' and a few others. /
95	int8_t mod_unused_padding; /*< 4b /
96	int32_t mod_ref; /*< 4c /
97	int8_t mod_loaded; /*< 50 /
98	int8_t mod_installed; /*< 51 /
99	int8_t mod_loadflags; /*< 52 /
100	int8_t mod_delay_unload; /*< 53 /
101	int32_t mod_padding1;
102	uint64_t mod_requisites; /*< 58 /
103	uint64_t mod___unused; /*< 60 /
104	int32_t mod_loadcnt; /*< 68 /
105	int32_t mod_nenabled; /*< 6c /
106	uint64_t mod_text; /*< 70 /
107	uint64_t mod_text_size; /*< 78 /
108	int32_t mod_gencount; /*< 80 /
109	int32_t mod_padding2;
110	uint64_t mod_requisite_loading; /*< 88 /
111	} SOL64v11_modctl_t;
112	AssertCompileSize(SOL64v11_modctl_t, 0x90);
113
114	typedef struct SOL32v9_modctl
115	{
116	uint32_t mod_next; /*< 0 /
117	uint32_t mod_prev; /*< 4 /
118	int32_t mod_id; /*< 8 /
119	uint32_t mod_mp; /*< c Pointer to the kernel runtime loader bits. /
120	uint32_t mod_inprogress_thread; /*< 10 /
121	uint32_t mod_modinfo; /*< 14 /
122	uint32_t mod_linkage; /*< 18 /
123	uint32_t mod_filename; /*< 1c /
124	uint32_t mod_modname; /*< 20 /
125	int32_t mod_busy; /*< 24 /
126	int32_t mod_stub; /*< 28 DIFF 1 /
127	int8_t mod_loaded; /*< 2c /
128	int8_t mod_installed; /*< 2d /
129	int8_t mod_loadflags; /*< 2e /
130	int8_t mod_want; /*< 2f DIFF 2 /
131	uint32_t mod_requisites; /*< 30 /
132	uint32_t mod_dependents; /*< 34 DIFF 3 /
133	int32_t mod_loadcnt; /*< 38 /
134	/* DIFF 4: 4 bytes added in v11 */
135	uint32_t mod_text; /*< 3c /
136	uint32_t mod_text_size; /*< 40 /
137	/* DIFF 5: 8 bytes added in v11 */
138	} SOL32v9_modctl_t;
139	AssertCompileSize(SOL32v9_modctl_t, 0x44);
140
141	typedef struct SOL64v9_modctl
142	{
143	uint64_t mod_next; /*< 0 /
144	uint64_t mod_prev; /*< 8 /
145	int32_t mod_id; /*< 10 /
146	int32_t mod_padding0;
147	uint64_t mod_mp; /*< 18 Pointer to the kernel runtime loader bits. /
148	uint64_t mod_inprogress_thread; /*< 20 /
149	uint64_t mod_modinfo; /*< 28 /
150	uint64_t mod_linkage; /*< 30 /
151	uint64_t mod_filename; /*< 38 /
152	uint64_t mod_modname; /*< 40 /
153	int32_t mod_busy; /*< 48 /
154	int32_t mod_stub; /*< 4c DIFF 1 - is this a pointer? /
155	int8_t mod_loaded; /*< 50 /
156	int8_t mod_installed; /*< 51 /
157	int8_t mod_loadflags; /*< 52 /
158	int8_t mod_want; /*< 53 DIFF 2 /
159	int32_t mod_padding1;
160	uint64_t mod_requisites; /*< 58 /
161	uint64_t mod_dependencies; /*< 60 DIFF 3 /
162	int32_t mod_loadcnt; /*< 68 /
163	int32_t mod_padding3; /*< 6c DIFF 4 /
164	uint64_t mod_text; /*< 70 /
165	uint64_t mod_text_size; /*< 78 /
166	/* DIFF 5: 8 bytes added in v11 */
167	} SOL64v9_modctl_t;
168	AssertCompileSize(SOL64v9_modctl_t, 0x80);
169
170	typedef union SOL_modctl
171	{
172	SOL32v9_modctl_t v9_32;
173	SOL32v11_modctl_t v11_32;
174	SOL64v9_modctl_t v9_64;
175	SOL64v11_modctl_t v11_64;
176	} SOL_modctl_t;
177
178	/** sys/kobj.h */
179	typedef struct SOL32_module
180	{
181	int32_t total_allocated; /*< 0 /
182	Elf32_Ehdr hdr; /*< 4 Easy to validate /
183	uint32_t shdrs; /*< 38 /
184	uint32_t symhdr; /*< 3c /
185	uint32_t strhdr; /*< 40 /
186	uint32_t depends_on; /*< 44 /
187	uint32_t symsize; /*< 48 /
188	uint32_t symspace; /*< 4c /
189	int32_t flags; /*< 50 /
190	uint32_t text_size; /*< 54 /
191	uint32_t data_size; /*< 58 /
192	uint32_t text; /*< 5c /
193	uint32_t data; /*< 60 /
194	uint32_t symtbl_section; /*< 64 /
195	uint32_t symtbl; /*< 68 /
196	uint32_t strings; /*< 6c /
197	uint32_t hashsize; /*< 70 /
198	uint32_t buckets; /*< 74 /
199	uint32_t chains; /*< 78 /
200	uint32_t nsyms; /*< 7c /
201	uint32_t bss_align; /*< 80 /
202	uint32_t bss_size; /*< 84 /
203	uint32_t bss; /*< 88 /
204	uint32_t filename; /*< 8c /
205	uint32_t head; /*< 90 /
206	uint32_t tail; /*< 94 /
207	uint32_t destination; /*< 98 /
208	uint32_t machdata; /*< 9c /
209	uint32_t ctfdata; /*< a0 /
210	uint32_t ctfsize; /*< a4 /
211	uint32_t fbt_tab; /*< a8 /
212	uint32_t fbt_size; /*< ac /
213	uint32_t fbt_nentries; /*< b0 /
214	uint32_t textwin; /*< b4 /
215	uint32_t textwin_base; /*< b8 /
216	uint32_t sdt_probes; /*< bc /
217	uint32_t sdt_nprobes; /*< c0 /
218	uint32_t sdt_tab; /*< c4 /
219	uint32_t sdt_size; /*< c8 /
220	uint32_t sigdata; /*< cc /
221	uint32_t sigsize; /*< d0 /
222	} SOL32_module_t;
223	AssertCompileSize(Elf32_Ehdr, 0x34);
224	AssertCompileSize(SOL32_module_t, 0xd4);
225
226	typedef struct SOL64_module
227	{
228	int32_t total_allocated; /*< 0 /
229	int32_t padding0;
230	Elf64_Ehdr hdr; /*< 8 Easy to validate /
231	uint64_t shdrs; /*< 48 /
232	uint64_t symhdr; /*< 50 /
233	uint64_t strhdr; /*< 58 /
234	uint64_t depends_on; /*< 60 /
235	uint64_t symsize; /*< 68 /
236	uint64_t symspace; /*< 70 /
237	int32_t flags; /*< 78 /
238	int32_t padding1;
239	uint64_t text_size; /*< 80 /
240	uint64_t data_size; /*< 88 /
241	uint64_t text; /*< 90 /
242	uint64_t data; /*< 98 /
243	uint32_t symtbl_section; /*< a0 /
244	int32_t padding2;
245	uint64_t symtbl; /*< a8 /
246	uint64_t strings; /*< b0 /
247	uint32_t hashsize; /*< b8 /
248	int32_t padding3;
249	uint64_t buckets; /*< c0 /
250	uint64_t chains; /*< c8 /
251	uint32_t nsyms; /*< d0 /
252	uint32_t bss_align; /*< d4 /
253	uint64_t bss_size; /*< d8 /
254	uint64_t bss; /*< e0 /
255	uint64_t filename; /*< e8 /
256	uint64_t head; /*< f0 /
257	uint64_t tail; /*< f8 /
258	uint64_t destination; /*< 100 /
259	uint64_t machdata; /*< 108 /
260	uint64_t ctfdata; /*< 110 /
261	uint64_t ctfsize; /*< 118 /
262	uint64_t fbt_tab; /*< 120 /
263	uint64_t fbt_size; /*< 128 /
264	uint64_t fbt_nentries; /*< 130 /
265	uint64_t textwin; /*< 138 /
266	uint64_t textwin_base; /*< 140 /
267	uint64_t sdt_probes; /*< 148 /
268	uint64_t sdt_nprobes; /*< 150 /
269	uint64_t sdt_tab; /*< 158 /
270	uint64_t sdt_size; /*< 160 /
271	uint64_t sigdata; /*< 168 /
272	uint64_t sigsize; /*< 170 /
273	} SOL64_module_t;
274	AssertCompileSize(Elf64_Ehdr, 0x40);
275	AssertCompileSize(SOL64_module_t, 0x178);
276
277	typedef struct SOL_utsname
278	{
279	char sysname[257];
280	char nodename[257];
281	char release[257];
282	char version[257];
283	char machine[257];
284	} SOL_utsname_t;
285	AssertCompileSize(SOL_utsname_t, 5 * 257);
286
287	/** @} */
288
289
290	/**
291	* Solaris guest OS digger instance data.
292	*/
293	typedef struct DBGDIGGERSOLARIS
294	{
295	/** Whether the information is valid or not.
296	* (For fending off illegal interface method calls.) */
297	bool fValid;
298
299	/** Address of the 'unix' text segment.
300	* This is set during probing. */
301	DBGFADDRESS AddrUnixText;
302	/** Address of the 'unix' text segment.
303	* This is set during probing. */
304	DBGFADDRESS AddrUnixData;
305	/** Address of the 'unix' modctl_t (aka modules). */
306	DBGFADDRESS AddrUnixModCtl;
307	/** modctl_t version number. */
308	int iModCtlVer;
309	/** 64-bit/32-bit indicator. */
310	bool f64Bit;
311
312	} DBGDIGGERSOLARIS;
313	/** Pointer to the solaris guest OS digger instance data. */
314	typedef DBGDIGGERSOLARIS *PDBGDIGGERSOLARIS;
315
316
317	/*********************************************************************************************************************************
318	* Defined Constants And Macros *
319	*********************************************************************************************************************************/
320	/** Min kernel address. */
321	#define SOL32_MIN_KRNL_ADDR UINT32_C(0x80000000)
322	/** Max kernel address. */
323	#define SOL32_MAX_KRNL_ADDR UINT32_C(0xfffff000)
324
325	/** Min kernel address. */
326	#define SOL64_MIN_KRNL_ADDR UINT64_C(0xFFFFC00000000000)
327	/** Max kernel address. */
328	#define SOL64_MAX_KRNL_ADDR UINT64_C(0xFFFFFFFFFFF00000)
329
330
331	/** Validates a 32-bit solaris kernel address */
332	#if 0 /* OpenSolaris, early boot have symspace at 0x27a2000 */
333	# define SOL32_VALID_ADDRESS(Addr) ((Addr) > SOL32_MIN_KRNL_ADDR && (Addr) < SOL32_MAX_KRNL_ADDR)
334	#else
335	# define SOL32_VALID_ADDRESS(Addr) ( ((Addr) > SOL32_MIN_KRNL_ADDR && (Addr) < SOL32_MAX_KRNL_ADDR) \
336	\|\| ((Addr) > UINT32_C(0x02000000) && (Addr) < UINT32_C(0x04000000)) /* boot */ )
337	#endif
338
339	/** Validates a 64-bit solaris kernel address */
340	#define SOL64_VALID_ADDRESS(Addr) ( (Addr) > SOL64_MIN_KRNL_ADDR \
341	&& (Addr) < SOL64_MAX_KRNL_ADDR)
342
343	/** The max data segment size of the 'unix' module. */
344	#define SOL_UNIX_MAX_DATA_SEG_SIZE 0x01000000
345
346	/** The max code segment size of the 'unix' module.
347	* This is the same for both 64-bit and 32-bit. */
348	#define SOL_UNIX_MAX_CODE_SEG_SIZE 0x00400000
349
350
351	/*********************************************************************************************************************************
352	* Internal Functions *
353	*********************************************************************************************************************************/
354	static DECLCALLBACK(int) dbgDiggerSolarisInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
355
356
357
358	/**
359	* @copydoc DBGFOSREG::pfnStackUnwindAssist
360	*/
361	static DECLCALLBACK(int) dbgDiggerSolarisStackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
362	PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState,
363	PCCPUMCTX pInitialCtx, RTDBGAS hAs, uint64_t *puScratch)
364	{
365	RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
366	return VINF_SUCCESS;
367	}
368
369
370	/**
371	* @copydoc DBGFOSREG::pfnQueryInterface
372	*/
373	static DECLCALLBACK(void ) dbgDiggerSolarisQueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void pvData, DBGFOSINTERFACE enmIf)
374	{
375	RT_NOREF(pUVM, pVMM, pvData, enmIf);
376	return NULL;
377	}
378
379
380	/**
381	* @copydoc DBGFOSREG::pfnQueryVersion
382	*/
383	static DECLCALLBACK(int) dbgDiggerSolarisQueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
384	char *pszVersion, size_t cchVersion)
385	{
386	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
387	Assert(pThis->fValid);
388
389	/*
390	* It's all in the utsname symbol...
391	*/
392	SOL_utsname_t UtsName;
393	RT_ZERO(UtsName); /* Make MSC happy. */
394	DBGFADDRESS Addr;
395	RTDBGSYMBOL SymUtsName;
396	int rc = pVMM->pfnDBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "utsname", &SymUtsName, NULL);
397	if (RT_SUCCESS(rc))
398	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SymUtsName.Value),
399	&UtsName, sizeof(UtsName));
400	if (RT_FAILURE(rc))
401	{
402	/*
403	* Try searching by the name...
404	*/
405	memset(&UtsName, '\0', sizeof(UtsName));
406	strcpy(&UtsName.sysname[0], "SunOS");
407	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &pThis->AddrUnixData, SOL_UNIX_MAX_DATA_SEG_SIZE, 1,
408	&UtsName.sysname[0], sizeof(UtsName.sysname), &Addr);
409	if (RT_SUCCESS(rc))
410	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr,
411	Addr.FlatPtr - RT_OFFSETOF(SOL_utsname_t, sysname)),
412	&UtsName, sizeof(UtsName));
413	}
414
415	/*
416	* Copy out the result (if any).
417	*/
418	if (RT_SUCCESS(rc))
419	{
420	if ( UtsName.sysname[sizeof(UtsName.sysname) - 1] != '\0'
421	\|\| UtsName.nodename[sizeof(UtsName.nodename) - 1] != '\0'
422	\|\| UtsName.release[sizeof(UtsName.release) - 1] != '\0'
423	\|\| UtsName.version[sizeof(UtsName.version) - 1] != '\0'
424	\|\| UtsName.machine[sizeof(UtsName.machine) - 1] != '\0')
425	{
426	//rc = VERR_DBGF_UNEXPECTED_OS_DATA;
427	rc = VERR_GENERAL_FAILURE;
428	RTStrPrintf(pszVersion, cchVersion, "failed - bogus utsname");
429	}
430	else
431	RTStrPrintf(pszVersion, cchVersion, "%s %s", UtsName.version, UtsName.release);
432	}
433	else
434	RTStrPrintf(pszVersion, cchVersion, "failed - %Rrc", rc);
435
436	return rc;
437	}
438
439
440
441	/**
442	* Processes a modctl_t.
443	*
444	* @param pUVM The user mode VM handle.
445	* @param pVMM The VMM function table.
446	* @param pThis Our instance data.
447	* @param pModCtl Pointer to the modctl structure.
448	*/
449	static void dbgDiggerSolarisProcessModCtl32(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
450	{
451	RT_NOREF1(pThis);
452
453	/* skip it if it's not loaded and installed */
454	AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_loaded, v9_32.mod_loaded);
455	AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_installed, v9_32.mod_installed);
456	AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_id, v9_32.mod_id);
457	if ( ( !pModCtl->v9_32.mod_loaded
458	\|\| !pModCtl->v9_32.mod_installed)
459	&& pModCtl->v9_32.mod_id > 3)
460	return;
461
462	/*
463	* Read the module and file names first
464	*/
465	AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_modname, v9_32.mod_modname);
466	char szModName[64];
467	DBGFADDRESS Addr;
468	int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_modname),
469	szModName, sizeof(szModName));
470	if (RT_FAILURE(rc))
471	return;
472	if (!RTStrEnd(szModName, sizeof(szModName)))
473	szModName[sizeof(szModName) - 1] = '\0';
474
475	AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_filename, v9_32.mod_filename);
476	char szFilename[256];
477	rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_filename),
478	szFilename, sizeof(szFilename));
479	if (RT_FAILURE(rc))
480	strcpy(szFilename, szModName);
481	else if (!RTStrEnd(szFilename, sizeof(szFilename)))
482	szFilename[sizeof(szFilename) - 1] = '\0';
483
484	/*
485	* Then read the module struct and validate it.
486	*/
487	AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_mp, v9_32.mod_mp);
488	struct SOL32_module Module;
489	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_mp), &Module, sizeof(Module));
490	if (RT_FAILURE(rc))
491	return;
492
493	/* Basic validations of the elf header. */
494	if ( Module.hdr.e_ident[EI_MAG0] != ELFMAG0
495	\|\| Module.hdr.e_ident[EI_MAG1] != ELFMAG1
496	\|\| Module.hdr.e_ident[EI_MAG2] != ELFMAG2
497	\|\| Module.hdr.e_ident[EI_MAG3] != ELFMAG3
498	\|\| Module.hdr.e_ident[EI_CLASS] != ELFCLASS32
499	\|\| Module.hdr.e_ident[EI_DATA] != ELFDATA2LSB
500	\|\| Module.hdr.e_ident[EI_VERSION] != EV_CURRENT
501	\|\| !ASMMemIsZero(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD)
502	)
503	return;
504	if (Module.hdr.e_version != EV_CURRENT)
505	return;
506	if (Module.hdr.e_ehsize != sizeof(Module.hdr))
507	return;
508	if ( Module.hdr.e_type != ET_DYN
509	&& Module.hdr.e_type != ET_REL
510	&& Module.hdr.e_type != ET_EXEC) //??
511	return;
512	if ( Module.hdr.e_machine != EM_386
513	&& Module.hdr.e_machine != EM_486)
514	return;
515	if ( Module.hdr.e_phentsize != sizeof(Elf32_Phdr)
516	&& Module.hdr.e_phentsize) //??
517	return;
518	if (Module.hdr.e_shentsize != sizeof(Elf32_Shdr))
519	return;
520
521	if (Module.hdr.e_shentsize != sizeof(Elf32_Shdr))
522	return;
523
524	/* Basic validations of the rest of the stuff. */
525	if ( !SOL32_VALID_ADDRESS(Module.shdrs)
526	\|\| !SOL32_VALID_ADDRESS(Module.symhdr)
527	\|\| !SOL32_VALID_ADDRESS(Module.strhdr)
528	\|\| (!SOL32_VALID_ADDRESS(Module.symspace) && Module.symspace)
529	\|\| !SOL32_VALID_ADDRESS(Module.text)
530	\|\| !SOL32_VALID_ADDRESS(Module.data)
531	\|\| (!SOL32_VALID_ADDRESS(Module.symtbl) && Module.symtbl)
532	\|\| (!SOL32_VALID_ADDRESS(Module.strings) && Module.strings)
533	\|\| (!SOL32_VALID_ADDRESS(Module.head) && Module.head)
534	\|\| (!SOL32_VALID_ADDRESS(Module.tail) && Module.tail)
535	\|\| !SOL32_VALID_ADDRESS(Module.filename))
536	return;
537	if ( Module.symsize > _4M
538	\|\| Module.hdr.e_shnum > 4096
539	\|\| Module.nsyms > _256K)
540	return;
541
542	/* Ignore modules without symbols. */
543	if (!Module.symtbl \|\| !Module.strings \|\| !Module.symspace \|\| !Module.symsize)
544	return;
545
546	/* Check that the symtbl and strings points inside the symspace. */
547	if (Module.strings - Module.symspace >= Module.symsize)
548	return;
549	if (Module.symtbl - Module.symspace >= Module.symsize)
550	return;
551
552	/*
553	* Read the section headers, symbol table and string tables.
554	*/
555	size_t cb = Module.hdr.e_shnum * sizeof(Elf32_Shdr);
556	Elf32_Shdr paShdrs = (Elf32_Shdr )RTMemTmpAlloc(cb);
557	if (!paShdrs)
558	return;
559	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
560	if (RT_SUCCESS(rc))
561	{
562	void *pvSymSpace = RTMemTmpAlloc(Module.symsize + 1);
563	if (pvSymSpace)
564	{
565	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace),
566	pvSymSpace, Module.symsize);
567	if (RT_SUCCESS(rc))
568	{
569	((uint8_t *)pvSymSpace)[Module.symsize] = 0;
570
571	/*
572	* Hand it over to the common ELF32 module parser.
573	*/
574	char const pbStrings = (char const )pvSymSpace + (Module.strings - Module.symspace);
575	size_t cbMaxStrings = Module.symsize - (Module.strings - Module.symspace);
576
577	Elf32_Sym const paSyms = (Elf32_Sym const )((uintptr_t)pvSymSpace + (Module.symtbl - Module.symspace));
578	size_t cMaxSyms = (Module.symsize - (Module.symtbl - Module.symspace)) / sizeof(Elf32_Sym);
579	cMaxSyms = RT_MIN(cMaxSyms, Module.nsyms);
580
581	DBGDiggerCommonParseElf32Mod(pUVM, pVMM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
582	&Module.hdr, paShdrs, paSyms, cMaxSyms, pbStrings, cbMaxStrings,
583	SOL32_MIN_KRNL_ADDR, SOL32_MAX_KRNL_ADDR - 1, DIG_SOL_MOD_TAG);
584	}
585	RTMemTmpFree(pvSymSpace);
586	}
587	}
588
589	RTMemTmpFree(paShdrs);
590	return;
591	}
592
593
594	/**
595	* Processes a modctl_t.
596	*
597	* @param pUVM The user mode VM handle.
598	* @param pVMM The VMM function table.
599	* @param pThis Our instance data.
600	* @param pModCtl Pointer to the modctl structure.
601	*/
602	static void dbgDiggerSolarisProcessModCtl64(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
603	{
604	RT_NOREF1(pThis);
605
606	/* skip it if it's not loaded and installed */
607	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_loaded, v9_64.mod_loaded);
608	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_installed, v9_64.mod_installed);
609	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_id, v9_64.mod_id);
610	if ( ( !pModCtl->v9_64.mod_loaded
611	\|\| !pModCtl->v9_64.mod_installed)
612	&& pModCtl->v9_64.mod_id > 3)
613	return;
614
615	/*
616	* Read the module and file names first
617	*/
618	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_modname, v9_64.mod_modname);
619	char szModName[64];
620	DBGFADDRESS Addr;
621	int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_modname),
622	szModName, sizeof(szModName));
623	if (RT_FAILURE(rc))
624	return;
625	if (!RTStrEnd(szModName, sizeof(szModName)))
626	szModName[sizeof(szModName) - 1] = '\0';
627
628	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_filename, v9_64.mod_filename);
629	char szFilename[256];
630	rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_filename),
631	szFilename, sizeof(szFilename));
632	if (RT_FAILURE(rc))
633	strcpy(szFilename, szModName);
634	else if (!RTStrEnd(szFilename, sizeof(szFilename)))
635	szFilename[sizeof(szFilename) - 1] = '\0';
636
637	/*
638	* Then read the module struct and validate it.
639	*/
640	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_mp, v9_64.mod_mp);
641	struct SOL64_module Module;
642	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_mp), &Module, sizeof(Module));
643	if (RT_FAILURE(rc))
644	return;
645
646	/* Basic validations of the elf header. */
647	if ( Module.hdr.e_ident[EI_MAG0] != ELFMAG0
648	\|\| Module.hdr.e_ident[EI_MAG1] != ELFMAG1
649	\|\| Module.hdr.e_ident[EI_MAG2] != ELFMAG2
650	\|\| Module.hdr.e_ident[EI_MAG3] != ELFMAG3
651	\|\| Module.hdr.e_ident[EI_CLASS] != ELFCLASS64
652	\|\| Module.hdr.e_ident[EI_DATA] != ELFDATA2LSB
653	\|\| Module.hdr.e_ident[EI_VERSION] != EV_CURRENT
654	\|\| !ASMMemIsZero(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD)
655	)
656	return;
657	if (Module.hdr.e_version != EV_CURRENT)
658	return;
659	if (Module.hdr.e_ehsize != sizeof(Module.hdr))
660	return;
661	if ( Module.hdr.e_type != ET_DYN
662	&& Module.hdr.e_type != ET_REL
663	&& Module.hdr.e_type != ET_EXEC) //??
664	return;
665	if (Module.hdr.e_machine != EM_X86_64)
666	return;
667	if ( Module.hdr.e_phentsize != sizeof(Elf64_Phdr)
668	&& Module.hdr.e_phentsize) //??
669	return;
670	if (Module.hdr.e_shentsize != sizeof(Elf64_Shdr))
671	return;
672
673	if (Module.hdr.e_shentsize != sizeof(Elf64_Shdr))
674	return;
675
676	/* Basic validations of the rest of the stuff. */
677	if ( !SOL64_VALID_ADDRESS(Module.shdrs)
678	\|\| !SOL64_VALID_ADDRESS(Module.symhdr)
679	\|\| !SOL64_VALID_ADDRESS(Module.strhdr)
680	\|\| (!SOL64_VALID_ADDRESS(Module.symspace) && Module.symspace)
681	\|\| !SOL64_VALID_ADDRESS(Module.text)
682	\|\| !SOL64_VALID_ADDRESS(Module.data)
683	\|\| (!SOL64_VALID_ADDRESS(Module.symtbl) && Module.symtbl)
684	\|\| (!SOL64_VALID_ADDRESS(Module.strings) && Module.strings)
685	\|\| (!SOL64_VALID_ADDRESS(Module.head) && Module.head)
686	\|\| (!SOL64_VALID_ADDRESS(Module.tail) && Module.tail)
687	\|\| !SOL64_VALID_ADDRESS(Module.filename))
688	return;
689	if ( Module.symsize > _4M
690	\|\| Module.hdr.e_shnum > 4096
691	\|\| Module.nsyms > _256K)
692	return;
693
694	/* Ignore modules without symbols. */
695	if (!Module.symtbl \|\| !Module.strings \|\| !Module.symspace \|\| !Module.symsize)
696	return;
697
698	/* Check that the symtbl and strings points inside the symspace. */
699	if (Module.strings - Module.symspace >= Module.symsize)
700	return;
701	if (Module.symtbl - Module.symspace >= Module.symsize)
702	return;
703
704	/*
705	* Read the section headers, symbol table and string tables.
706	*/
707	size_t cb = Module.hdr.e_shnum * sizeof(Elf64_Shdr);
708	Elf64_Shdr paShdrs = (Elf64_Shdr )RTMemTmpAlloc(cb);
709	if (!paShdrs)
710	return;
711	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
712	if (RT_SUCCESS(rc))
713	{
714	void *pvSymSpace = RTMemTmpAlloc(Module.symsize + 1);
715	if (pvSymSpace)
716	{
717	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace),
718	pvSymSpace, Module.symsize);
719	if (RT_SUCCESS(rc))
720	{
721	((uint8_t *)pvSymSpace)[Module.symsize] = 0;
722
723	/*
724	* Hand it over to the common ELF64 module parser.
725	*/
726	char const pbStrings = (char const )pvSymSpace + (Module.strings - Module.symspace);
727	size_t cbMaxStrings = Module.symsize - (Module.strings - Module.symspace);
728
729	Elf64_Sym const paSyms = (Elf64_Sym const )((uintptr_t)pvSymSpace + (uintptr_t)(Module.symtbl - Module.symspace));
730	size_t cMaxSyms = (Module.symsize - (Module.symtbl - Module.symspace)) / sizeof(Elf32_Sym);
731	cMaxSyms = RT_MIN(cMaxSyms, Module.nsyms);
732
733	DBGDiggerCommonParseElf64Mod(pUVM, pVMM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
734	&Module.hdr, paShdrs, paSyms, cMaxSyms, pbStrings, cbMaxStrings,
735	SOL64_MIN_KRNL_ADDR, SOL64_MAX_KRNL_ADDR - 1, DIG_SOL_MOD_TAG);
736	}
737	RTMemTmpFree(pvSymSpace);
738	}
739	}
740
741	RTMemTmpFree(paShdrs);
742	return;
743	}
744
745
746	/**
747	* @copydoc DBGFOSREG::pfnTerm
748	*/
749	static DECLCALLBACK(void) dbgDiggerSolarisTerm(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
750	{
751	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
752	RT_NOREF(pUVM, pVMM);
753	Assert(pThis->fValid);
754
755	pThis->fValid = false;
756	}
757
758
759	/**
760	* @copydoc DBGFOSREG::pfnRefresh
761	*/
762	static DECLCALLBACK(int) dbgDiggerSolarisRefresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
763	{
764	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
765	RT_NOREF(pThis);
766	Assert(pThis->fValid);
767
768	/*
769	* For now we'll flush and reload everything.
770	*/
771	RTDBGAS hDbgAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
772	if (hDbgAs != NIL_RTDBGAS)
773	{
774	uint32_t iMod = RTDbgAsModuleCount(hDbgAs);
775	while (iMod-- > 0)
776	{
777	RTDBGMOD hMod = RTDbgAsModuleByIndex(hDbgAs, iMod);
778	if (hMod != NIL_RTDBGMOD)
779	{
780	if (RTDbgModGetTag(hMod) == DIG_SOL_MOD_TAG)
781	{
782	int rc = RTDbgAsModuleUnlink(hDbgAs, hMod);
783	AssertRC(rc);
784	}
785	RTDbgModRelease(hMod);
786	}
787	}
788	RTDbgAsRelease(hDbgAs);
789	}
790
791	dbgDiggerSolarisTerm(pUVM, pVMM, pvData);
792	return dbgDiggerSolarisInit(pUVM, pVMM, pvData);
793	}
794
795
796	/**
797	* @copydoc DBGFOSREG::pfnInit
798	*/
799	static DECLCALLBACK(int) dbgDiggerSolarisInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
800	{
801	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
802	Assert(!pThis->fValid);
803	int rc;
804	size_t cbModCtl = 0;
805
806	/*
807	* On Solaris the kernel and is the global address space.
808	*/
809	pVMM->pfnDBGFR3AsSetAlias(pUVM, DBGF_AS_KERNEL, DBGF_AS_GLOBAL);
810
811	/** @todo Use debug_info, build 7x / S10U6. */
812
813	/*
814	* Find the 'unix' modctl_t structure (aka modules).
815	* We know it resides in the unix data segment.
816	*/
817	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &pThis->AddrUnixModCtl, 0);
818
819	DBGFADDRESS CurAddr = pThis->AddrUnixData;
820	DBGFADDRESS MaxAddr;
821	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &MaxAddr, CurAddr.FlatPtr + SOL_UNIX_MAX_DATA_SEG_SIZE);
822	const uint8_t pbExpr = (const uint8_t )&pThis->AddrUnixText.FlatPtr;
823	const uint32_t cbExpr = pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t);
824	while ( CurAddr.FlatPtr < MaxAddr.FlatPtr
825	&& CurAddr.FlatPtr >= pThis->AddrUnixData.FlatPtr)
826	{
827	DBGFADDRESS HitAddr;
828	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &CurAddr, MaxAddr.FlatPtr - CurAddr.FlatPtr, 1, pbExpr, cbExpr, &HitAddr);
829	if (RT_FAILURE(rc))
830	break;
831
832	/*
833	* Read out the modctl_t structure.
834	*/
835	DBGFADDRESS ModCtlAddr;
836
837	/* v11 */
838	if (pThis->f64Bit)
839	{
840	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
841	SOL64v11_modctl_t ModCtlv11;
842	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
843	if (RT_SUCCESS(rc))
844	{
845	if ( SOL64_VALID_ADDRESS(ModCtlv11.mod_next)
846	&& SOL64_VALID_ADDRESS(ModCtlv11.mod_prev)
847	&& ModCtlv11.mod_id == 0
848	&& SOL64_VALID_ADDRESS(ModCtlv11.mod_mp)
849	&& SOL64_VALID_ADDRESS(ModCtlv11.mod_filename)
850	&& SOL64_VALID_ADDRESS(ModCtlv11.mod_modname)
851	&& ModCtlv11.mod_prim == 1
852	&& ModCtlv11.mod_loaded == 1
853	&& ModCtlv11.mod_installed == 1
854	&& ModCtlv11.mod_requisites == 0
855	&& ModCtlv11.mod_loadcnt == 1
856	/&& ModCtlv11.mod_text == pThis->AddrUnixText.FlatPtr/
857	&& ModCtlv11.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE
858	&& ModCtlv11.mod_text_size >= _128K)
859	{
860	char szUnix[5];
861	DBGFADDRESS NameAddr;
862	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
863	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
864	if (RT_SUCCESS(rc))
865	{
866	if (!strcmp(szUnix, "unix"))
867	{
868	pThis->AddrUnixModCtl = ModCtlAddr;
869	pThis->iModCtlVer = 11;
870	cbModCtl = sizeof(ModCtlv11);
871	break;
872	}
873	Log(("sol64 mod_name=%.*s v11\n", sizeof(szUnix), szUnix));
874	}
875	}
876	}
877	}
878	else
879	{
880	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
881	SOL32v11_modctl_t ModCtlv11;
882	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
883	if (RT_SUCCESS(rc))
884	{
885	if ( SOL32_VALID_ADDRESS(ModCtlv11.mod_next)
886	&& SOL32_VALID_ADDRESS(ModCtlv11.mod_prev)
887	&& ModCtlv11.mod_id == 0
888	&& SOL32_VALID_ADDRESS(ModCtlv11.mod_mp)
889	&& SOL32_VALID_ADDRESS(ModCtlv11.mod_filename)
890	&& SOL32_VALID_ADDRESS(ModCtlv11.mod_modname)
891	&& ModCtlv11.mod_prim == 1
892	&& ModCtlv11.mod_loaded == 1
893	&& ModCtlv11.mod_installed == 1
894	&& ModCtlv11.mod_requisites == 0
895	&& ModCtlv11.mod_loadcnt == 1
896	/&& ModCtlv11.mod_text == pThis->AddrUnixText.FlatPtr/
897	&& ModCtlv11.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE
898	&& ModCtlv11.mod_text_size >= _128K)
899	{
900	char szUnix[5];
901	DBGFADDRESS NameAddr;
902	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
903	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
904	if (RT_SUCCESS(rc))
905	{
906	if (!strcmp(szUnix, "unix"))
907	{
908	pThis->AddrUnixModCtl = ModCtlAddr;
909	pThis->iModCtlVer = 11;
910	cbModCtl = sizeof(ModCtlv11);
911	break;
912	}
913	Log(("sol32 mod_name=%.*s v11\n", sizeof(szUnix), szUnix));
914	}
915	}
916	}
917	}
918
919	/* v9 */
920	if (pThis->f64Bit)
921	{
922	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL64v9_modctl_t, mod_text));
923	SOL64v9_modctl_t ModCtlv9;
924	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
925	if (RT_SUCCESS(rc))
926	{
927	if ( SOL64_VALID_ADDRESS(ModCtlv9.mod_next)
928	&& SOL64_VALID_ADDRESS(ModCtlv9.mod_prev)
929	&& ModCtlv9.mod_id == 0
930	&& SOL64_VALID_ADDRESS(ModCtlv9.mod_mp)
931	&& SOL64_VALID_ADDRESS(ModCtlv9.mod_filename)
932	&& SOL64_VALID_ADDRESS(ModCtlv9.mod_modname)
933	&& (ModCtlv9.mod_loaded == 1 \|\| ModCtlv9.mod_loaded == 0)
934	&& (ModCtlv9.mod_installed == 1 \|\| ModCtlv9.mod_installed == 0)
935	&& ModCtlv9.mod_requisites == 0
936	&& (ModCtlv9.mod_loadcnt == 1 \|\| ModCtlv9.mod_loadcnt == 0)
937	/&& ModCtlv9.mod_text == pThis->AddrUnixText.FlatPtr/
938	&& ModCtlv9.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE)
939	{
940	char szUnix[5];
941	DBGFADDRESS NameAddr;
942	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
943	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
944	if (RT_SUCCESS(rc))
945	{
946	if (!strcmp(szUnix, "unix"))
947	{
948	pThis->AddrUnixModCtl = ModCtlAddr;
949	pThis->iModCtlVer = 9;
950	cbModCtl = sizeof(ModCtlv9);
951	break;
952	}
953	Log(("sol64 mod_name=%.*s v9\n", sizeof(szUnix), szUnix));
954	}
955	}
956	}
957	}
958	else
959	{
960	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v9_modctl_t, mod_text));
961	SOL32v9_modctl_t ModCtlv9;
962	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
963	if (RT_SUCCESS(rc))
964	{
965	if ( SOL32_VALID_ADDRESS(ModCtlv9.mod_next)
966	&& SOL32_VALID_ADDRESS(ModCtlv9.mod_prev)
967	&& ModCtlv9.mod_id == 0
968	&& SOL32_VALID_ADDRESS(ModCtlv9.mod_mp)
969	&& SOL32_VALID_ADDRESS(ModCtlv9.mod_filename)
970	&& SOL32_VALID_ADDRESS(ModCtlv9.mod_modname)
971	&& (ModCtlv9.mod_loaded == 1 \|\| ModCtlv9.mod_loaded == 0)
972	&& (ModCtlv9.mod_installed == 1 \|\| ModCtlv9.mod_installed == 0)
973	&& ModCtlv9.mod_requisites == 0
974	&& (ModCtlv9.mod_loadcnt == 1 \|\| ModCtlv9.mod_loadcnt == 0)
975	/&& ModCtlv9.mod_text == pThis->AddrUnixText.FlatPtr/
976	&& ModCtlv9.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE )
977	{
978	char szUnix[5];
979	DBGFADDRESS NameAddr;
980	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
981	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
982	if (RT_SUCCESS(rc))
983	{
984	if (!strcmp(szUnix, "unix"))
985	{
986	pThis->AddrUnixModCtl = ModCtlAddr;
987	pThis->iModCtlVer = 9;
988	cbModCtl = sizeof(ModCtlv9);
989	break;
990	}
991	Log(("sol32 mod_name=%.*s v9\n", sizeof(szUnix), szUnix));
992	}
993	}
994	}
995	}
996
997	/* next */
998	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, HitAddr.FlatPtr + cbExpr);
999	}
1000
1001	/*
1002	* Walk the module chain and add the modules and their symbols.
1003	*/
1004	if (pThis->AddrUnixModCtl.FlatPtr)
1005	{
1006	int iMod = 0;
1007	CurAddr = pThis->AddrUnixModCtl;
1008	do
1009	{
1010	/* read it */
1011	SOL_modctl_t ModCtl;
1012	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &CurAddr, &ModCtl, cbModCtl);
1013	if (RT_FAILURE(rc))
1014	{
1015	LogRel(("sol: bad modctl_t chain for module %d: %RGv - %Rrc\n", iMod, CurAddr.FlatPtr, rc));
1016	break;
1017	}
1018
1019	/* process it. */
1020	if (pThis->f64Bit)
1021	dbgDiggerSolarisProcessModCtl64(pUVM, pVMM, pThis, &ModCtl);
1022	else
1023	dbgDiggerSolarisProcessModCtl32(pUVM, pVMM, pThis, &ModCtl);
1024
1025	/* next */
1026	if (pThis->f64Bit)
1027	{
1028	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_next, v9_64.mod_next);
1029	if (!SOL64_VALID_ADDRESS(ModCtl.v9_64.mod_next))
1030	{
1031	LogRel(("sol64: bad modctl_t chain for module %d at %RGv: %RGv\n", iMod, CurAddr.FlatPtr, (RTGCUINTPTR)ModCtl.v9_64.mod_next));
1032	break;
1033	}
1034	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_64.mod_next);
1035	}
1036	else
1037	{
1038	AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_next, v9_32.mod_next);
1039	if (!SOL32_VALID_ADDRESS(ModCtl.v9_32.mod_next))
1040	{
1041	LogRel(("sol32: bad modctl_t chain for module %d at %RGv: %RGv\n", iMod, CurAddr.FlatPtr, (RTGCUINTPTR)ModCtl.v9_32.mod_next));
1042	break;
1043	}
1044	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_32.mod_next);
1045	}
1046	if (++iMod >= 1024)
1047	{
1048	LogRel(("sol32: too many modules (%d)\n", iMod));
1049	break;
1050	}
1051	} while (CurAddr.FlatPtr != pThis->AddrUnixModCtl.FlatPtr);
1052	}
1053
1054	pThis->fValid = true;
1055	return VINF_SUCCESS;
1056	}
1057
1058
1059	/**
1060	* @copydoc DBGFOSREG::pfnProbe
1061	*/
1062	static DECLCALLBACK(bool) dbgDiggerSolarisProbe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1063	{
1064	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
1065
1066	/*
1067	* Look for "SunOS Release" in the text segment.
1068	*/
1069	DBGFADDRESS Addr;
1070	bool f64Bit = false;
1071
1072	/* 32-bit search range. */
1073	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, 0xfe800000);
1074	RTGCUINTPTR cbRange = 0xfec00000 - 0xfe800000;
1075
1076	DBGFADDRESS HitAddr;
1077	static const uint8_t s_abSunRelease[] = "SunOS Release ";
1078	int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
1079	if (RT_FAILURE(rc))
1080	{
1081	/* 64-bit.... */
1082	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, UINT64_C(0xfffffffffb800000));
1083	cbRange = UINT64_C(0xfffffffffbd00000) - UINT64_C(0xfffffffffb800000);
1084	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
1085	if (RT_FAILURE(rc))
1086	return false;
1087	f64Bit = true;
1088	}
1089
1090	/*
1091	* Look for the copyright string too, just to be sure.
1092	*/
1093	static const uint8_t s_abSMI[] = "Sun Microsystems, Inc.";
1094	static const uint8_t s_abORCL[] = "Oracle and/or its affiliates.";
1095	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSMI, sizeof(s_abSMI) - 1, &HitAddr);
1096	if (RT_FAILURE(rc))
1097	{
1098	/* Try the alternate copyright string. */
1099	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abORCL, sizeof(s_abORCL) - 1, &HitAddr);
1100	if (RT_FAILURE(rc))
1101	return false;
1102	}
1103
1104	/*
1105	* Remember the unix text and data addresses and bitness.
1106	*/
1107	pThis->AddrUnixText = Addr;
1108	pVMM->pfnDBGFR3AddrAdd(&Addr, SOL_UNIX_MAX_CODE_SEG_SIZE);
1109	pThis->AddrUnixData = Addr;
1110	pThis->f64Bit = f64Bit;
1111
1112	return true;
1113	}
1114
1115
1116	/**
1117	* @copydoc DBGFOSREG::pfnDestruct
1118	*/
1119	static DECLCALLBACK(void) dbgDiggerSolarisDestruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1120	{
1121	RT_NOREF(pUVM, pVMM, pvData);
1122	}
1123
1124
1125	/**
1126	* @copydoc DBGFOSREG::pfnConstruct
1127	*/
1128	static DECLCALLBACK(int) dbgDiggerSolarisConstruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1129	{
1130	RT_NOREF(pUVM, pVMM, pvData);
1131	return VINF_SUCCESS;
1132	}
1133
1134
1135	const DBGFOSREG g_DBGDiggerSolaris =
1136	{
1137	/* .u32Magic = */ DBGFOSREG_MAGIC,
1138	/* .fFlags = */ 0,
1139	/* .cbData = */ sizeof(DBGDIGGERSOLARIS),
1140	/* .szName = */ "Solaris",
1141	/* .pfnConstruct = */ dbgDiggerSolarisConstruct,
1142	/* .pfnDestruct = */ dbgDiggerSolarisDestruct,
1143	/* .pfnProbe = */ dbgDiggerSolarisProbe,
1144	/* .pfnInit = */ dbgDiggerSolarisInit,
1145	/* .pfnRefresh = */ dbgDiggerSolarisRefresh,
1146	/* .pfnTerm = */ dbgDiggerSolarisTerm,
1147	/* .pfnQueryVersion = */ dbgDiggerSolarisQueryVersion,
1148	/* .pfnQueryInterface = */ dbgDiggerSolarisQueryInterface,
1149	/* .pfnStackUnwindAssist = */ dbgDiggerSolarisStackUnwindAssist,
1150	/* .u32EndMagic = */ DBGFOSREG_MAGIC
1151	};
1152

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

source: vbox/trunk/src/VBox/Debugger/DBGPlugInSolaris.cpp@ 95638

Download in other formats: