DBGPlugInSolaris.cpp@ 99806

Last change on this file since 99806 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 46.8 KB

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

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

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

Download in other formats: