DBGPlugInSolaris.cpp@ 74888

Last change on this file since 74888 was 73460, checked in by vboxsync, 6 years ago
IPRT,DBGF,Diggers: Moved DBGFRETURNTYPE and the unwind state structure to IPRT (dbg.h) in prep for debug module interface and more. Added stack unwind assist callback for the OS diggers so they can identify special stack frames and supply more info via the sure-register-value array and frame flags. Identify and decode NT/AMD64 trap frames.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 45.2 KB

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

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

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

Download in other formats: