DBGPlugInSolaris.cpp@ 104792

Last change on this file since 104792 was 104606, checked in by vboxsync, 7 months ago
Debugger/DBGPlugInSolaris.cpp: Duplicated if conditions, bugref:3409
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 46.7 KB

Line
1	/* $Id: DBGPlugInSolaris.cpp 104606 2024-05-13 16:05:27Z 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	/* Basic validations of the rest of the stuff. */
532	if ( !SOL32_VALID_ADDRESS(Module.shdrs)
533	\|\| !SOL32_VALID_ADDRESS(Module.symhdr)
534	\|\| !SOL32_VALID_ADDRESS(Module.strhdr)
535	\|\| (!SOL32_VALID_ADDRESS(Module.symspace) && Module.symspace)
536	\|\| !SOL32_VALID_ADDRESS(Module.text)
537	\|\| !SOL32_VALID_ADDRESS(Module.data)
538	\|\| (!SOL32_VALID_ADDRESS(Module.symtbl) && Module.symtbl)
539	\|\| (!SOL32_VALID_ADDRESS(Module.strings) && Module.strings)
540	\|\| (!SOL32_VALID_ADDRESS(Module.head) && Module.head)
541	\|\| (!SOL32_VALID_ADDRESS(Module.tail) && Module.tail)
542	\|\| !SOL32_VALID_ADDRESS(Module.filename))
543	return;
544	if ( Module.symsize > _4M
545	\|\| Module.hdr.e_shnum > 4096
546	\|\| Module.nsyms > _256K)
547	return;
548
549	/* Ignore modules without symbols. */
550	if (!Module.symtbl \|\| !Module.strings \|\| !Module.symspace \|\| !Module.symsize)
551	return;
552
553	/* Check that the symtbl and strings points inside the symspace. */
554	if (Module.strings - Module.symspace >= Module.symsize)
555	return;
556	if (Module.symtbl - Module.symspace >= Module.symsize)
557	return;
558
559	/*
560	* Read the section headers, symbol table and string tables.
561	*/
562	size_t cb = Module.hdr.e_shnum * sizeof(Elf32_Shdr);
563	Elf32_Shdr paShdrs = (Elf32_Shdr )RTMemTmpAlloc(cb);
564	if (!paShdrs)
565	return;
566	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
567	if (RT_SUCCESS(rc))
568	{
569	void *pvSymSpace = RTMemTmpAlloc(Module.symsize + 1);
570	if (pvSymSpace)
571	{
572	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace),
573	pvSymSpace, Module.symsize);
574	if (RT_SUCCESS(rc))
575	{
576	((uint8_t *)pvSymSpace)[Module.symsize] = 0;
577
578	/*
579	* Hand it over to the common ELF32 module parser.
580	*/
581	char const pbStrings = (char const )pvSymSpace + (Module.strings - Module.symspace);
582	size_t cbMaxStrings = Module.symsize - (Module.strings - Module.symspace);
583
584	Elf32_Sym const paSyms = (Elf32_Sym const )((uintptr_t)pvSymSpace + (Module.symtbl - Module.symspace));
585	size_t cMaxSyms = (Module.symsize - (Module.symtbl - Module.symspace)) / sizeof(Elf32_Sym);
586	cMaxSyms = RT_MIN(cMaxSyms, Module.nsyms);
587
588	DBGDiggerCommonParseElf32Mod(pUVM, pVMM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
589	&Module.hdr, paShdrs, paSyms, cMaxSyms, pbStrings, cbMaxStrings,
590	SOL32_MIN_KRNL_ADDR, SOL32_MAX_KRNL_ADDR - 1, DIG_SOL_MOD_TAG);
591	}
592	RTMemTmpFree(pvSymSpace);
593	}
594	}
595
596	RTMemTmpFree(paShdrs);
597	return;
598	}
599
600
601	/**
602	* Processes a modctl_t.
603	*
604	* @param pUVM The user mode VM handle.
605	* @param pVMM The VMM function table.
606	* @param pThis Our instance data.
607	* @param pModCtl Pointer to the modctl structure.
608	*/
609	static void dbgDiggerSolarisProcessModCtl64(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
610	{
611	RT_NOREF1(pThis);
612
613	/* skip it if it's not loaded and installed */
614	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_loaded, v9_64.mod_loaded);
615	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_installed, v9_64.mod_installed);
616	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_id, v9_64.mod_id);
617	if ( ( !pModCtl->v9_64.mod_loaded
618	\|\| !pModCtl->v9_64.mod_installed)
619	&& pModCtl->v9_64.mod_id > 3)
620	return;
621
622	/*
623	* Read the module and file names first
624	*/
625	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_modname, v9_64.mod_modname);
626	char szModName[64];
627	DBGFADDRESS Addr;
628	int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_modname),
629	szModName, sizeof(szModName));
630	if (RT_FAILURE(rc))
631	return;
632	if (!RTStrEnd(szModName, sizeof(szModName)))
633	szModName[sizeof(szModName) - 1] = '\0';
634
635	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_filename, v9_64.mod_filename);
636	char szFilename[256];
637	rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_filename),
638	szFilename, sizeof(szFilename));
639	if (RT_FAILURE(rc))
640	strcpy(szFilename, szModName);
641	else if (!RTStrEnd(szFilename, sizeof(szFilename)))
642	szFilename[sizeof(szFilename) - 1] = '\0';
643
644	/*
645	* Then read the module struct and validate it.
646	*/
647	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_mp, v9_64.mod_mp);
648	struct SOL64_module Module;
649	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_mp), &Module, sizeof(Module));
650	if (RT_FAILURE(rc))
651	return;
652
653	/* Basic validations of the elf header. */
654	if ( Module.hdr.e_ident[EI_MAG0] != ELFMAG0
655	\|\| Module.hdr.e_ident[EI_MAG1] != ELFMAG1
656	\|\| Module.hdr.e_ident[EI_MAG2] != ELFMAG2
657	\|\| Module.hdr.e_ident[EI_MAG3] != ELFMAG3
658	\|\| Module.hdr.e_ident[EI_CLASS] != ELFCLASS64
659	\|\| Module.hdr.e_ident[EI_DATA] != ELFDATA2LSB
660	\|\| Module.hdr.e_ident[EI_VERSION] != EV_CURRENT
661	\|\| !ASMMemIsZero(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD)
662	)
663	return;
664	if (Module.hdr.e_version != EV_CURRENT)
665	return;
666	if (Module.hdr.e_ehsize != sizeof(Module.hdr))
667	return;
668	if ( Module.hdr.e_type != ET_DYN
669	&& Module.hdr.e_type != ET_REL
670	&& Module.hdr.e_type != ET_EXEC) //??
671	return;
672	if (Module.hdr.e_machine != EM_X86_64)
673	return;
674	if ( Module.hdr.e_phentsize != sizeof(Elf64_Phdr)
675	&& Module.hdr.e_phentsize) //??
676	return;
677	if (Module.hdr.e_shentsize != sizeof(Elf64_Shdr))
678	return;
679
680	/* Basic validations of the rest of the stuff. */
681	if ( !SOL64_VALID_ADDRESS(Module.shdrs)
682	\|\| !SOL64_VALID_ADDRESS(Module.symhdr)
683	\|\| !SOL64_VALID_ADDRESS(Module.strhdr)
684	\|\| (!SOL64_VALID_ADDRESS(Module.symspace) && Module.symspace)
685	\|\| !SOL64_VALID_ADDRESS(Module.text)
686	\|\| !SOL64_VALID_ADDRESS(Module.data)
687	\|\| (!SOL64_VALID_ADDRESS(Module.symtbl) && Module.symtbl)
688	\|\| (!SOL64_VALID_ADDRESS(Module.strings) && Module.strings)
689	\|\| (!SOL64_VALID_ADDRESS(Module.head) && Module.head)
690	\|\| (!SOL64_VALID_ADDRESS(Module.tail) && Module.tail)
691	\|\| !SOL64_VALID_ADDRESS(Module.filename))
692	return;
693	if ( Module.symsize > _4M
694	\|\| Module.hdr.e_shnum > 4096
695	\|\| Module.nsyms > _256K)
696	return;
697
698	/* Ignore modules without symbols. */
699	if (!Module.symtbl \|\| !Module.strings \|\| !Module.symspace \|\| !Module.symsize)
700	return;
701
702	/* Check that the symtbl and strings points inside the symspace. */
703	if (Module.strings - Module.symspace >= Module.symsize)
704	return;
705	if (Module.symtbl - Module.symspace >= Module.symsize)
706	return;
707
708	/*
709	* Read the section headers, symbol table and string tables.
710	*/
711	size_t cb = Module.hdr.e_shnum * sizeof(Elf64_Shdr);
712	Elf64_Shdr paShdrs = (Elf64_Shdr )RTMemTmpAlloc(cb);
713	if (!paShdrs)
714	return;
715	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
716	if (RT_SUCCESS(rc))
717	{
718	void *pvSymSpace = RTMemTmpAlloc(Module.symsize + 1);
719	if (pvSymSpace)
720	{
721	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace),
722	pvSymSpace, Module.symsize);
723	if (RT_SUCCESS(rc))
724	{
725	((uint8_t *)pvSymSpace)[Module.symsize] = 0;
726
727	/*
728	* Hand it over to the common ELF64 module parser.
729	*/
730	char const pbStrings = (char const )pvSymSpace + (Module.strings - Module.symspace);
731	size_t cbMaxStrings = Module.symsize - (Module.strings - Module.symspace);
732
733	Elf64_Sym const paSyms = (Elf64_Sym const )((uintptr_t)pvSymSpace + (uintptr_t)(Module.symtbl - Module.symspace));
734	size_t cMaxSyms = (Module.symsize - (Module.symtbl - Module.symspace)) / sizeof(Elf32_Sym);
735	cMaxSyms = RT_MIN(cMaxSyms, Module.nsyms);
736
737	DBGDiggerCommonParseElf64Mod(pUVM, pVMM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
738	&Module.hdr, paShdrs, paSyms, cMaxSyms, pbStrings, cbMaxStrings,
739	SOL64_MIN_KRNL_ADDR, SOL64_MAX_KRNL_ADDR - 1, DIG_SOL_MOD_TAG);
740	}
741	RTMemTmpFree(pvSymSpace);
742	}
743	}
744
745	RTMemTmpFree(paShdrs);
746	return;
747	}
748
749
750	/**
751	* @copydoc DBGFOSREG::pfnTerm
752	*/
753	static DECLCALLBACK(void) dbgDiggerSolarisTerm(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
754	{
755	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
756	RT_NOREF(pUVM, pVMM);
757	Assert(pThis->fValid);
758
759	pThis->fValid = false;
760	}
761
762
763	/**
764	* @copydoc DBGFOSREG::pfnRefresh
765	*/
766	static DECLCALLBACK(int) dbgDiggerSolarisRefresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
767	{
768	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
769	RT_NOREF(pThis);
770	Assert(pThis->fValid);
771
772	/*
773	* For now we'll flush and reload everything.
774	*/
775	RTDBGAS hDbgAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
776	if (hDbgAs != NIL_RTDBGAS)
777	{
778	uint32_t iMod = RTDbgAsModuleCount(hDbgAs);
779	while (iMod-- > 0)
780	{
781	RTDBGMOD hMod = RTDbgAsModuleByIndex(hDbgAs, iMod);
782	if (hMod != NIL_RTDBGMOD)
783	{
784	if (RTDbgModGetTag(hMod) == DIG_SOL_MOD_TAG)
785	{
786	int rc = RTDbgAsModuleUnlink(hDbgAs, hMod);
787	AssertRC(rc);
788	}
789	RTDbgModRelease(hMod);
790	}
791	}
792	RTDbgAsRelease(hDbgAs);
793	}
794
795	dbgDiggerSolarisTerm(pUVM, pVMM, pvData);
796	return dbgDiggerSolarisInit(pUVM, pVMM, pvData);
797	}
798
799
800	/**
801	* @copydoc DBGFOSREG::pfnInit
802	*/
803	static DECLCALLBACK(int) dbgDiggerSolarisInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
804	{
805	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
806	Assert(!pThis->fValid);
807	int rc;
808	size_t cbModCtl = 0;
809
810	/*
811	* On Solaris the kernel and is the global address space.
812	*/
813	pVMM->pfnDBGFR3AsSetAlias(pUVM, DBGF_AS_KERNEL, DBGF_AS_GLOBAL);
814
815	/** @todo Use debug_info, build 7x / S10U6. */
816
817	/*
818	* Find the 'unix' modctl_t structure (aka modules).
819	* We know it resides in the unix data segment.
820	*/
821	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &pThis->AddrUnixModCtl, 0);
822
823	DBGFADDRESS CurAddr = pThis->AddrUnixData;
824	DBGFADDRESS MaxAddr;
825	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &MaxAddr, CurAddr.FlatPtr + SOL_UNIX_MAX_DATA_SEG_SIZE);
826	const uint8_t pbExpr = (const uint8_t )&pThis->AddrUnixText.FlatPtr;
827	const uint32_t cbExpr = pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t);
828	while ( CurAddr.FlatPtr < MaxAddr.FlatPtr
829	&& CurAddr.FlatPtr >= pThis->AddrUnixData.FlatPtr)
830	{
831	DBGFADDRESS HitAddr;
832	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &CurAddr, MaxAddr.FlatPtr - CurAddr.FlatPtr, 1, pbExpr, cbExpr, &HitAddr);
833	if (RT_FAILURE(rc))
834	break;
835
836	/*
837	* Read out the modctl_t structure.
838	*/
839	DBGFADDRESS ModCtlAddr;
840
841	/* v11 */
842	if (pThis->f64Bit)
843	{
844	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
845	SOL64v11_modctl_t ModCtlv11;
846	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
847	if (RT_SUCCESS(rc))
848	{
849	if ( SOL64_VALID_ADDRESS(ModCtlv11.mod_next)
850	&& SOL64_VALID_ADDRESS(ModCtlv11.mod_prev)
851	&& ModCtlv11.mod_id == 0
852	&& SOL64_VALID_ADDRESS(ModCtlv11.mod_mp)
853	&& SOL64_VALID_ADDRESS(ModCtlv11.mod_filename)
854	&& SOL64_VALID_ADDRESS(ModCtlv11.mod_modname)
855	&& ModCtlv11.mod_prim == 1
856	&& ModCtlv11.mod_loaded == 1
857	&& ModCtlv11.mod_installed == 1
858	&& ModCtlv11.mod_requisites == 0
859	&& ModCtlv11.mod_loadcnt == 1
860	/&& ModCtlv11.mod_text == pThis->AddrUnixText.FlatPtr/
861	&& ModCtlv11.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE
862	&& ModCtlv11.mod_text_size >= _128K)
863	{
864	char szUnix[5];
865	DBGFADDRESS NameAddr;
866	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
867	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
868	if (RT_SUCCESS(rc))
869	{
870	if (!strcmp(szUnix, "unix"))
871	{
872	pThis->AddrUnixModCtl = ModCtlAddr;
873	pThis->iModCtlVer = 11;
874	cbModCtl = sizeof(ModCtlv11);
875	break;
876	}
877	Log(("sol64 mod_name=%.*s v11\n", sizeof(szUnix), szUnix));
878	}
879	}
880	}
881	}
882	else
883	{
884	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
885	SOL32v11_modctl_t ModCtlv11;
886	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
887	if (RT_SUCCESS(rc))
888	{
889	if ( SOL32_VALID_ADDRESS(ModCtlv11.mod_next)
890	&& SOL32_VALID_ADDRESS(ModCtlv11.mod_prev)
891	&& ModCtlv11.mod_id == 0
892	&& SOL32_VALID_ADDRESS(ModCtlv11.mod_mp)
893	&& SOL32_VALID_ADDRESS(ModCtlv11.mod_filename)
894	&& SOL32_VALID_ADDRESS(ModCtlv11.mod_modname)
895	&& ModCtlv11.mod_prim == 1
896	&& ModCtlv11.mod_loaded == 1
897	&& ModCtlv11.mod_installed == 1
898	&& ModCtlv11.mod_requisites == 0
899	&& ModCtlv11.mod_loadcnt == 1
900	/&& ModCtlv11.mod_text == pThis->AddrUnixText.FlatPtr/
901	&& ModCtlv11.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE
902	&& ModCtlv11.mod_text_size >= _128K)
903	{
904	char szUnix[5];
905	DBGFADDRESS NameAddr;
906	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
907	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
908	if (RT_SUCCESS(rc))
909	{
910	if (!strcmp(szUnix, "unix"))
911	{
912	pThis->AddrUnixModCtl = ModCtlAddr;
913	pThis->iModCtlVer = 11;
914	cbModCtl = sizeof(ModCtlv11);
915	break;
916	}
917	Log(("sol32 mod_name=%.*s v11\n", sizeof(szUnix), szUnix));
918	}
919	}
920	}
921	}
922
923	/* v9 */
924	if (pThis->f64Bit)
925	{
926	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL64v9_modctl_t, mod_text));
927	SOL64v9_modctl_t ModCtlv9;
928	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
929	if (RT_SUCCESS(rc))
930	{
931	if ( SOL64_VALID_ADDRESS(ModCtlv9.mod_next)
932	&& SOL64_VALID_ADDRESS(ModCtlv9.mod_prev)
933	&& ModCtlv9.mod_id == 0
934	&& SOL64_VALID_ADDRESS(ModCtlv9.mod_mp)
935	&& SOL64_VALID_ADDRESS(ModCtlv9.mod_filename)
936	&& SOL64_VALID_ADDRESS(ModCtlv9.mod_modname)
937	&& (ModCtlv9.mod_loaded == 1 \|\| ModCtlv9.mod_loaded == 0)
938	&& (ModCtlv9.mod_installed == 1 \|\| ModCtlv9.mod_installed == 0)
939	&& ModCtlv9.mod_requisites == 0
940	&& (ModCtlv9.mod_loadcnt == 1 \|\| ModCtlv9.mod_loadcnt == 0)
941	/&& ModCtlv9.mod_text == pThis->AddrUnixText.FlatPtr/
942	&& ModCtlv9.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE)
943	{
944	char szUnix[5];
945	DBGFADDRESS NameAddr;
946	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
947	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
948	if (RT_SUCCESS(rc))
949	{
950	if (!strcmp(szUnix, "unix"))
951	{
952	pThis->AddrUnixModCtl = ModCtlAddr;
953	pThis->iModCtlVer = 9;
954	cbModCtl = sizeof(ModCtlv9);
955	break;
956	}
957	Log(("sol64 mod_name=%.*s v9\n", sizeof(szUnix), szUnix));
958	}
959	}
960	}
961	}
962	else
963	{
964	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v9_modctl_t, mod_text));
965	SOL32v9_modctl_t ModCtlv9;
966	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
967	if (RT_SUCCESS(rc))
968	{
969	if ( SOL32_VALID_ADDRESS(ModCtlv9.mod_next)
970	&& SOL32_VALID_ADDRESS(ModCtlv9.mod_prev)
971	&& ModCtlv9.mod_id == 0
972	&& SOL32_VALID_ADDRESS(ModCtlv9.mod_mp)
973	&& SOL32_VALID_ADDRESS(ModCtlv9.mod_filename)
974	&& SOL32_VALID_ADDRESS(ModCtlv9.mod_modname)
975	&& (ModCtlv9.mod_loaded == 1 \|\| ModCtlv9.mod_loaded == 0)
976	&& (ModCtlv9.mod_installed == 1 \|\| ModCtlv9.mod_installed == 0)
977	&& ModCtlv9.mod_requisites == 0
978	&& (ModCtlv9.mod_loadcnt == 1 \|\| ModCtlv9.mod_loadcnt == 0)
979	/&& ModCtlv9.mod_text == pThis->AddrUnixText.FlatPtr/
980	&& ModCtlv9.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE )
981	{
982	char szUnix[5];
983	DBGFADDRESS NameAddr;
984	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
985	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
986	if (RT_SUCCESS(rc))
987	{
988	if (!strcmp(szUnix, "unix"))
989	{
990	pThis->AddrUnixModCtl = ModCtlAddr;
991	pThis->iModCtlVer = 9;
992	cbModCtl = sizeof(ModCtlv9);
993	break;
994	}
995	Log(("sol32 mod_name=%.*s v9\n", sizeof(szUnix), szUnix));
996	}
997	}
998	}
999	}
1000
1001	/* next */
1002	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, HitAddr.FlatPtr + cbExpr);
1003	}
1004
1005	/*
1006	* Walk the module chain and add the modules and their symbols.
1007	*/
1008	if (pThis->AddrUnixModCtl.FlatPtr)
1009	{
1010	int iMod = 0;
1011	CurAddr = pThis->AddrUnixModCtl;
1012	do
1013	{
1014	/* read it */
1015	SOL_modctl_t ModCtl;
1016	rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &CurAddr, &ModCtl, cbModCtl);
1017	if (RT_FAILURE(rc))
1018	{
1019	LogRel(("sol: bad modctl_t chain for module %d: %RGv - %Rrc\n", iMod, CurAddr.FlatPtr, rc));
1020	break;
1021	}
1022
1023	/* process it. */
1024	if (pThis->f64Bit)
1025	dbgDiggerSolarisProcessModCtl64(pUVM, pVMM, pThis, &ModCtl);
1026	else
1027	dbgDiggerSolarisProcessModCtl32(pUVM, pVMM, pThis, &ModCtl);
1028
1029	/* next */
1030	if (pThis->f64Bit)
1031	{
1032	AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_next, v9_64.mod_next);
1033	if (!SOL64_VALID_ADDRESS(ModCtl.v9_64.mod_next))
1034	{
1035	LogRel(("sol64: bad modctl_t chain for module %d at %RGv: %RGv\n", iMod, CurAddr.FlatPtr, (RTGCUINTPTR)ModCtl.v9_64.mod_next));
1036	break;
1037	}
1038	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_64.mod_next);
1039	}
1040	else
1041	{
1042	AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_next, v9_32.mod_next);
1043	if (!SOL32_VALID_ADDRESS(ModCtl.v9_32.mod_next))
1044	{
1045	LogRel(("sol32: bad modctl_t chain for module %d at %RGv: %RGv\n", iMod, CurAddr.FlatPtr, (RTGCUINTPTR)ModCtl.v9_32.mod_next));
1046	break;
1047	}
1048	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_32.mod_next);
1049	}
1050	if (++iMod >= 1024)
1051	{
1052	LogRel(("sol32: too many modules (%d)\n", iMod));
1053	break;
1054	}
1055	} while (CurAddr.FlatPtr != pThis->AddrUnixModCtl.FlatPtr);
1056	}
1057
1058	pThis->fValid = true;
1059	return VINF_SUCCESS;
1060	}
1061
1062
1063	/**
1064	* @copydoc DBGFOSREG::pfnProbe
1065	*/
1066	static DECLCALLBACK(bool) dbgDiggerSolarisProbe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1067	{
1068	PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
1069
1070	/*
1071	* Look for "SunOS Release" in the text segment.
1072	*/
1073	DBGFADDRESS Addr;
1074	bool f64Bit = false;
1075
1076	/* 32-bit search range. */
1077	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, 0xfe800000);
1078	RTGCUINTPTR cbRange = 0xfec00000 - 0xfe800000;
1079
1080	DBGFADDRESS HitAddr;
1081	static const uint8_t s_abSunRelease[] = "SunOS Release ";
1082	int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
1083	if (RT_FAILURE(rc))
1084	{
1085	/* 64-bit.... */
1086	pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, UINT64_C(0xfffffffffb800000));
1087	cbRange = UINT64_C(0xfffffffffbd00000) - UINT64_C(0xfffffffffb800000);
1088	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
1089	if (RT_FAILURE(rc))
1090	return false;
1091	f64Bit = true;
1092	}
1093
1094	/*
1095	* Look for the copyright string too, just to be sure.
1096	*/
1097	static const uint8_t s_abSMI[] = "Sun Microsystems, Inc.";
1098	static const uint8_t s_abORCL[] = "Oracle and/or its affiliates.";
1099	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSMI, sizeof(s_abSMI) - 1, &HitAddr);
1100	if (RT_FAILURE(rc))
1101	{
1102	/* Try the alternate copyright string. */
1103	rc = pVMM->pfnDBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abORCL, sizeof(s_abORCL) - 1, &HitAddr);
1104	if (RT_FAILURE(rc))
1105	return false;
1106	}
1107
1108	/*
1109	* Remember the unix text and data addresses and bitness.
1110	*/
1111	pThis->AddrUnixText = Addr;
1112	pVMM->pfnDBGFR3AddrAdd(&Addr, SOL_UNIX_MAX_CODE_SEG_SIZE);
1113	pThis->AddrUnixData = Addr;
1114	pThis->f64Bit = f64Bit;
1115
1116	return true;
1117	}
1118
1119
1120	/**
1121	* @copydoc DBGFOSREG::pfnDestruct
1122	*/
1123	static DECLCALLBACK(void) dbgDiggerSolarisDestruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1124	{
1125	RT_NOREF(pUVM, pVMM, pvData);
1126	}
1127
1128
1129	/**
1130	* @copydoc DBGFOSREG::pfnConstruct
1131	*/
1132	static DECLCALLBACK(int) dbgDiggerSolarisConstruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1133	{
1134	RT_NOREF(pUVM, pVMM, pvData);
1135	return VINF_SUCCESS;
1136	}
1137
1138
1139	const DBGFOSREG g_DBGDiggerSolaris =
1140	{
1141	/* .u32Magic = */ DBGFOSREG_MAGIC,
1142	/* .fFlags = */ 0,
1143	/* .cbData = */ sizeof(DBGDIGGERSOLARIS),
1144	/* .szName = */ "Solaris",
1145	/* .pfnConstruct = */ dbgDiggerSolarisConstruct,
1146	/* .pfnDestruct = */ dbgDiggerSolarisDestruct,
1147	/* .pfnProbe = */ dbgDiggerSolarisProbe,
1148	/* .pfnInit = */ dbgDiggerSolarisInit,
1149	/* .pfnRefresh = */ dbgDiggerSolarisRefresh,
1150	/* .pfnTerm = */ dbgDiggerSolarisTerm,
1151	/* .pfnQueryVersion = */ dbgDiggerSolarisQueryVersion,
1152	/* .pfnQueryInterface = */ dbgDiggerSolarisQueryInterface,
1153	/* .pfnStackUnwindAssist = */ dbgDiggerSolarisStackUnwindAssist,
1154	/* .u32EndMagic = */ DBGFOSREG_MAGIC
1155	};
1156

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

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

Download in other formats: