DBGPlugInLinux.cpp@ 78975

Last change on this file since 78975 was 78019, checked in by vboxsync, 6 years ago
Debugger/DBGPlugInLinux.cpp: Fix querying log buffer addresses when disassembling emit_log_char for certain CentO/RHEL 5.x kernels
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 111.7 KB

Line
1	/* $Id: DBGPlugInLinux.cpp 78019 2019-04-04 14:06:32Z vboxsync $ */
2	/** @file
3	* DBGPlugInLinux - Debugger and Guest OS Digger Plugin For Linux.
4	*/
5
6	/*
7	* Copyright (C) 2008-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DBGF /// @todo add new log group.
23	#include "DBGPlugIns.h"
24	#include "DBGPlugInCommonELF.h"
25	#include <VBox/vmm/dbgf.h>
26	#include <VBox/dis.h>
27	#include <iprt/ctype.h>
28	#include <iprt/file.h>
29	#include <iprt/err.h>
30	#include <iprt/mem.h>
31	#include <iprt/stream.h>
32	#include <iprt/string.h>
33	#include <iprt/vfs.h>
34	#include <iprt/zip.h>
35
36
37	/*********************************************************************************************************************************
38	* Structures and Typedefs *
39	*********************************************************************************************************************************/
40
41	/** @name InternalLinux structures
42	* @{ */
43
44
45	/** @} */
46
47
48	/**
49	* Config item type.
50	*/
51	typedef enum DBGDIGGERLINUXCFGITEMTYPE
52	{
53	/** Invalid type. */
54	DBGDIGGERLINUXCFGITEMTYPE_INVALID = 0,
55	/** String. */
56	DBGDIGGERLINUXCFGITEMTYPE_STRING,
57	/** Number. */
58	DBGDIGGERLINUXCFGITEMTYPE_NUMBER,
59	/** Flag whether this feature is included in the
60	* kernel or as a module. */
61	DBGDIGGERLINUXCFGITEMTYPE_FLAG
62	} DBGDIGGERLINUXCFGITEMTYPE;
63
64	/**
65	* Item in the config database.
66	*/
67	typedef struct DBGDIGGERLINUXCFGITEM
68	{
69	/** String space core. */
70	RTSTRSPACECORE Core;
71	/** Config item type. */
72	DBGDIGGERLINUXCFGITEMTYPE enmType;
73	/** Data based on the type. */
74	union
75	{
76	/** Number. */
77	int64_t i64Num;
78	/** Flag. */
79	bool fModule;
80	/** String - variable in size. */
81	char aszString[1];
82	} u;
83	} DBGDIGGERLINUXCFGITEM;
84	/** Pointer to a config database item. */
85	typedef DBGDIGGERLINUXCFGITEM *PDBGDIGGERLINUXCFGITEM;
86	/** Pointer to a const config database item. */
87	typedef const DBGDIGGERLINUXCFGITEM *PCDBGDIGGERLINUXCFGITEM;
88
89	/**
90	* Linux guest OS digger instance data.
91	*/
92	typedef struct DBGDIGGERLINUX
93	{
94	/** Whether the information is valid or not.
95	* (For fending off illegal interface method calls.) */
96	bool fValid;
97	/** Set if 64-bit, clear if 32-bit. */
98	bool f64Bit;
99	/** Set if the kallsyms table uses relative addressing, clear
100	* if absolute addresses are used. */
101	bool fRelKrnlAddr;
102	/** The relative base when kernel symbols use offsets rather than
103	* absolute addresses. */
104	RTGCUINTPTR uKernelRelativeBase;
105
106	/** The address of the linux banner.
107	* This is set during probing. */
108	DBGFADDRESS AddrLinuxBanner;
109	/** Kernel base address.
110	* This is set during probing, refined during kallsyms parsing. */
111	DBGFADDRESS AddrKernelBase;
112	/** The kernel size. */
113	uint32_t cbKernel;
114
115	/** The number of kernel symbols (kallsyms_num_syms).
116	* This is set during init. */
117	uint32_t cKernelSymbols;
118	/** The size of the kernel name table (sizeof(kallsyms_names)). */
119	uint32_t cbKernelNames;
120	/** Number of entries in the kernel_markers table. */
121	uint32_t cKernelNameMarkers;
122	/** The size of the kernel symbol token table. */
123	uint32_t cbKernelTokenTable;
124	/** The address of the encoded kernel symbol names (kallsyms_names). */
125	DBGFADDRESS AddrKernelNames;
126	/** The address of the kernel symbol addresses (kallsyms_addresses). */
127	DBGFADDRESS AddrKernelAddresses;
128	/** The address of the kernel symbol name markers (kallsyms_markers). */
129	DBGFADDRESS AddrKernelNameMarkers;
130	/** The address of the kernel symbol token table (kallsyms_token_table). */
131	DBGFADDRESS AddrKernelTokenTable;
132	/** The address of the kernel symbol token index table (kallsyms_token_index). */
133	DBGFADDRESS AddrKernelTokenIndex;
134
135	/** The kernel message log interface. */
136	DBGFOSIDMESG IDmesg;
137
138	/** The config database root. */
139	RTSTRSPACE hCfgDb;
140	} DBGDIGGERLINUX;
141	/** Pointer to the linux guest OS digger instance data. */
142	typedef DBGDIGGERLINUX *PDBGDIGGERLINUX;
143
144
145	/**
146	* The current printk_log structure.
147	*/
148	typedef struct LNXPRINTKHDR
149	{
150	/** Monotonic timestamp. */
151	uint64_t nsTimestamp;
152	/** The total size of this message record. */
153	uint16_t cbTotal;
154	/** The size of the text part (immediately follows the header). */
155	uint16_t cbText;
156	/** The size of the optional dictionary part (follows the text). */
157	uint16_t cbDict;
158	/** The syslog facility number. */
159	uint8_t bFacility;
160	/** First 5 bits are internal flags, next 3 bits are log level. */
161	uint8_t fFlagsAndLevel;
162	} LNXPRINTKHDR;
163	AssertCompileSize(LNXPRINTKHDR, 2*sizeof(uint64_t));
164	/** Pointer to linux printk_log header. */
165	typedef LNXPRINTKHDR *PLNXPRINTKHDR;
166	/** Pointer to linux const printk_log header. */
167	typedef LNXPRINTKHDR const *PCLNXPRINTKHDR;
168
169
170	/*********************************************************************************************************************************
171	* Defined Constants And Macros *
172	*********************************************************************************************************************************/
173	/** First kernel map address for 32bit Linux hosts (__START_KERNEL_map). */
174	#define LNX32_KERNEL_ADDRESS_START UINT32_C(0xc0000000)
175	/** First kernel map address for 64bit Linux hosts (__START_KERNEL_map). */
176	#define LNX64_KERNEL_ADDRESS_START UINT64_C(0xffffffff80000000)
177	/** Validates a 32-bit linux kernel address */
178	#define LNX32_VALID_ADDRESS(Addr) ((Addr) > UINT32_C(0x80000000) && (Addr) < UINT32_C(0xfffff000))
179	/** Validates a 64-bit linux kernel address */
180	#define LNX64_VALID_ADDRESS(Addr) ((Addr) > UINT64_C(0xffff800000000000) && (Addr) < UINT64_C(0xfffffffffffff000))
181
182	/** The max kernel size. */
183	#define LNX_MAX_KERNEL_SIZE UINT32_C(0x0f000000)
184
185	/** The maximum size we expect for kallsyms_names. */
186	#define LNX_MAX_KALLSYMS_NAMES_SIZE UINT32_C(0x200000)
187	/** The maximum size we expect for kallsyms_token_table. */
188	#define LNX_MAX_KALLSYMS_TOKEN_TABLE_SIZE UINT32_C(0x10000)
189	/** The minimum number of symbols we expect in kallsyms_num_syms. */
190	#define LNX_MIN_KALLSYMS_SYMBOLS UINT32_C(2048)
191	/** The maximum number of symbols we expect in kallsyms_num_syms. */
192	#define LNX_MAX_KALLSYMS_SYMBOLS UINT32_C(1048576)
193	/** The min length an encoded symbol in kallsyms_names is expected to have. */
194	#define LNX_MIN_KALLSYMS_ENC_LENGTH UINT8_C(1)
195	/** The max length an encoded symbol in kallsyms_names is expected to have.
196	* @todo check real life here. */
197	#define LNX_MAX_KALLSYMS_ENC_LENGTH UINT8_C(28)
198	/** The approximate maximum length of a string token. */
199	#define LNX_MAX_KALLSYMS_TOKEN_LEN UINT16_C(32)
200	/** Maximum compressed config size expected. */
201	#define LNX_MAX_COMPRESSED_CFG_SIZE _1M
202
203	/** Module tag for linux ('linuxmod' on little endian ASCII systems). */
204	#define DIG_LNX_MOD_TAG UINT64_C(0x545f5d78758e898c)
205
206
207	/*********************************************************************************************************************************
208	* Internal Functions *
209	*********************************************************************************************************************************/
210	static DECLCALLBACK(int) dbgDiggerLinuxInit(PUVM pUVM, void *pvData);
211
212
213	/*********************************************************************************************************************************
214	* Global Variables *
215	*********************************************************************************************************************************/
216	/** Table of common linux kernel addresses. */
217	static uint64_t g_au64LnxKernelAddresses[] =
218	{
219	UINT64_C(0xc0100000),
220	UINT64_C(0x90100000),
221	UINT64_C(0xffffffff80200000)
222	};
223
224	static const uint8_t g_abLinuxVersion[] = "Linux version ";
225
226	/**
227	* Converts a given offset into an absolute address if relative kernel offsets are used for
228	* kallsyms.
229	*
230	* @returns The absolute kernel address.
231	* @param pThis The Linux digger data.
232	* @param uOffset The offset to convert.
233	*/
234	DECLINLINE(RTGCUINTPTR) dbgDiggerLinuxConvOffsetToAddr(PDBGDIGGERLINUX pThis, int32_t uOffset)
235	{
236	RTGCUINTPTR uAddr;
237
238	/*
239	* How the absolute address is calculated from the offset depends on the
240	* CONFIG_KALLSYMS_ABSOLUTE_PERCPU config which is only set for 64bit
241	* SMP kernels (we assume that all 64bit kernels always have SMP enabled too).
242	*/
243	if (pThis->f64Bit)
244	{
245	if (uOffset >= 0)
246	uAddr = uOffset;
247	else
248	uAddr = pThis->uKernelRelativeBase - 1 - uOffset;
249	}
250	else
251	uAddr = pThis->uKernelRelativeBase + (uint32_t)uOffset;
252
253	return uAddr;
254	}
255
256	/**
257	* Disassembles a simple getter returning the value for it.
258	*
259	* @returns VBox status code.
260	* @param pThis The Linux digger data.
261	* @param pUVM The VM handle.
262	* @param hMod The module to use.
263	* @param pszSymbol The symbol of the getter.
264	* @param pvVal Where to store the value on success.
265	* @param cbVal Size of the value in bytes.
266	*/
267	static int dbgDiggerLinuxDisassembleSimpleGetter(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
268	const char pszSymbol, void pvVal, uint32_t cbVal)
269	{
270	int rc = VINF_SUCCESS;
271
272	RTDBGSYMBOL SymInfo;
273	rc = RTDbgModSymbolByName(hMod, pszSymbol, &SymInfo);
274	if (RT_SUCCESS(rc))
275	{
276	/*
277	* Do the diassembling. Disassemble until a ret instruction is encountered
278	* or a limit is reached (don't want to disassemble for too long as the getter
279	* should be short).
280	* push and pop instructions are skipped as well as any mov instructions not
281	* touching the rax or eax register (depending on the size of the value).
282	*/
283	unsigned cInstrDisassembled = 0;
284	uint32_t offInstr = 0;
285	bool fRet = false;
286	DISSTATE DisState;
287	RT_ZERO(DisState);
288
289	do
290	{
291	DBGFADDRESS Addr;
292	RTGCPTR GCPtrCur = (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr + offInstr;
293	DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrCur);
294
295	/* Prefetch the instruction. */
296	uint8_t abInstr[32];
297	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &Addr, &abInstr[0], sizeof(abInstr));
298	if (RT_SUCCESS(rc))
299	{
300	uint32_t cbInstr = 0;
301
302	rc = DISInstr(&abInstr[0], pThis->f64Bit ? DISCPUMODE_64BIT : DISCPUMODE_32BIT, &DisState, &cbInstr);
303	if (RT_SUCCESS(rc))
304	{
305	switch (DisState.pCurInstr->uOpcode)
306	{
307	case OP_PUSH:
308	case OP_POP:
309	case OP_NOP:
310	case OP_LEA:
311	break;
312	case OP_RETN:
313	/* Getter returned, abort disassembling. */
314	fRet = true;
315	break;
316	case OP_MOV:
317	/*
318	* Check that the destination is either rax or eax depending on the
319	* value size.
320	*
321	* Param1 is the destination and Param2 the source.
322	*/
323	if ( ( ( (DisState.Param1.fUse & (DISUSE_BASE \| DISUSE_REG_GEN32))
324	&& cbVal == sizeof(uint32_t))
325	\|\| ( (DisState.Param1.fUse & (DISUSE_BASE \| DISUSE_REG_GEN64))
326	&& cbVal == sizeof(uint64_t)))
327	&& DisState.Param1.Base.idxGenReg == DISGREG_RAX)
328	{
329	/* Parse the source. */
330	if (DisState.Param2.fUse & (DISUSE_IMMEDIATE32 \| DISUSE_IMMEDIATE64))
331	memcpy(pvVal, &DisState.Param2.uValue, cbVal);
332	else if (DisState.Param2.fUse & (DISUSE_RIPDISPLACEMENT32\|DISUSE_DISPLACEMENT32\|DISUSE_DISPLACEMENT64))
333	{
334	RTGCPTR GCPtrVal = 0;
335
336	if (DisState.Param2.fUse & DISUSE_RIPDISPLACEMENT32)
337	GCPtrVal = GCPtrCur + DisState.Param2.uDisp.i32 + cbInstr;
338	else if (DisState.Param2.fUse & DISUSE_DISPLACEMENT32)
339	GCPtrVal = (RTGCPTR)DisState.Param2.uDisp.u32;
340	else if (DisState.Param2.fUse & DISUSE_DISPLACEMENT64)
341	GCPtrVal = (RTGCPTR)DisState.Param2.uDisp.u64;
342	else
343	AssertMsgFailedBreakStmt(("Invalid displacement\n"), rc = VERR_INVALID_STATE);
344
345	DBGFADDRESS AddrVal;
346	rc = DBGFR3MemRead(pUVM, 0 /idCpu/,
347	DBGFR3AddrFromFlat(pUVM, &AddrVal, GCPtrVal),
348	pvVal, cbVal);
349	}
350	}
351	break;
352	default:
353	/* All other instructions will cause an error for now (playing safe here). */
354	rc = VERR_INVALID_PARAMETER;
355	break;
356	}
357	cInstrDisassembled++;
358	offInstr += cbInstr;
359	}
360	}
361	} while ( RT_SUCCESS(rc)
362	&& cInstrDisassembled < 20
363	&& !fRet);
364	}
365
366	return rc;
367	}
368
369	/**
370	* Try to get at the log buffer starting address and size by disassembling emit_log_char.
371	*
372	* @returns VBox status code.
373	* @param pThis The Linux digger data.
374	* @param pUVM The VM handle.
375	* @param hMod The module to use.
376	* @param pGCPtrLogBuf Where to store the log buffer pointer on success.
377	* @param pcbLogBuf Where to store the size of the log buffer on success.
378	*/
379	static int dbgDiggerLinuxQueryAsciiLogBufferPtrs(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
380	RTGCPTR pGCPtrLogBuf, uint32_t pcbLogBuf)
381	{
382	int rc = VINF_SUCCESS;
383
384	/**
385	* We disassemble emit_log_char to get at the log buffer address and size.
386	* This is used in case the symbols are not exported in kallsyms.
387	*
388	* This is what it typically looks like:
389	* vmlinux!emit_log_char:
390	* %00000000c01204a1 56 push esi
391	* %00000000c01204a2 8b 35 d0 1c 34 c0 mov esi, dword [0c0341cd0h]
392	* %00000000c01204a8 53 push ebx
393	* %00000000c01204a9 8b 1d 74 3b 3e c0 mov ebx, dword [0c03e3b74h]
394	* %00000000c01204af 8b 0d d8 1c 34 c0 mov ecx, dword [0c0341cd8h]
395	* %00000000c01204b5 8d 56 ff lea edx, [esi-001h]
396	* %00000000c01204b8 21 da and edx, ebx
397	* %00000000c01204ba 88 04 11 mov byte [ecx+edx], al
398	* %00000000c01204bd 8d 53 01 lea edx, [ebx+001h]
399	* %00000000c01204c0 89 d0 mov eax, edx
400	* [...]
401	*/
402	RTDBGSYMBOL SymInfo;
403	rc = RTDbgModSymbolByName(hMod, "emit_log_char", &SymInfo);
404	if (RT_SUCCESS(rc))
405	{
406	/*
407	* Do the diassembling. Disassemble until a ret instruction is encountered
408	* or a limit is reached (don't want to disassemble for too long as the getter
409	* should be short). Certain instructions found are ignored (push, nop, etc.).
410	*/
411	unsigned cInstrDisassembled = 0;
412	uint32_t offInstr = 0;
413	bool fRet = false;
414	DISSTATE DisState;
415	unsigned cAddressesUsed = 0;
416	struct { size_t cb; RTGCPTR GCPtrOrigSrc; } aAddresses[5];
417	RT_ZERO(DisState);
418	RT_ZERO(aAddresses);
419
420	do
421	{
422	DBGFADDRESS Addr;
423	RTGCPTR GCPtrCur = (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr + offInstr;
424	DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrCur);
425
426	/* Prefetch the instruction. */
427	uint8_t abInstr[32];
428	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &Addr, &abInstr[0], sizeof(abInstr));
429	if (RT_SUCCESS(rc))
430	{
431	uint32_t cbInstr = 0;
432
433	rc = DISInstr(&abInstr[0], pThis->f64Bit ? DISCPUMODE_64BIT : DISCPUMODE_32BIT, &DisState, &cbInstr);
434	if (RT_SUCCESS(rc))
435	{
436	switch (DisState.pCurInstr->uOpcode)
437	{
438	case OP_PUSH:
439	case OP_POP:
440	case OP_NOP:
441	case OP_LEA:
442	case OP_AND:
443	case OP_CBW:
444	case OP_DEC:
445	break;
446	case OP_RETN:
447	/* emit_log_char returned, abort disassembling. */
448	rc = VERR_NOT_FOUND;
449	fRet = true;
450	break;
451	case OP_MOV:
452	case OP_MOVSXD:
453	/*
454	* If a mov is encountered writing to memory with al (or dil for amd64) being the source the
455	* character is stored and we can infer the base address and size of the log buffer from
456	* the source addresses.
457	*/
458	if ( (DisState.Param2.fUse & DISUSE_REG_GEN8)
459	&& ( (DisState.Param2.Base.idxGenReg == DISGREG_AL && !pThis->f64Bit)
460	\|\| (DisState.Param2.Base.idxGenReg == DISGREG_DIL && pThis->f64Bit))
461	&& DISUSE_IS_EFFECTIVE_ADDR(DisState.Param1.fUse))
462	{
463	RTGCPTR GCPtrLogBuf = 0;
464	uint32_t cbLogBuf = 0;
465
466	/*
467	* We can stop disassembling now and inspect all registers, look for a valid kernel address first.
468	* Only one of the accessed registers should hold a valid kernel address.
469	* For the log size look for the biggest non kernel address.
470	*/
471	for (unsigned i = 0; i < cAddressesUsed; i++)
472	{
473	DBGFADDRESS AddrVal;
474	union { uint8_t abVal[8]; uint32_t u32Val; uint64_t u64Val; } Val;
475
476	rc = DBGFR3MemRead(pUVM, 0 /idCpu/,
477	DBGFR3AddrFromFlat(pUVM, &AddrVal, aAddresses[i].GCPtrOrigSrc),
478	&Val.abVal[0], aAddresses[i].cb);
479	if (RT_SUCCESS(rc))
480	{
481	if (pThis->f64Bit && aAddresses[i].cb == sizeof(uint64_t))
482	{
483	if (LNX64_VALID_ADDRESS(Val.u64Val))
484	{
485	if (GCPtrLogBuf == 0)
486	GCPtrLogBuf = Val.u64Val;
487	else
488	{
489	rc = VERR_NOT_FOUND;
490	break;
491	}
492	}
493	}
494	else
495	{
496	AssertMsgBreakStmt(aAddresses[i].cb == sizeof(uint32_t),
497	("Invalid value size\n"), rc = VERR_INVALID_STATE);
498
499	/* Might be a kernel address or a size indicator. */
500	if (!pThis->f64Bit && LNX32_VALID_ADDRESS(Val.u32Val))
501	{
502	if (GCPtrLogBuf == 0)
503	GCPtrLogBuf = Val.u32Val;
504	else
505	{
506	rc = VERR_NOT_FOUND;
507	break;
508	}
509	}
510	else
511	{
512	/*
513	* The highest value will be the log buffer because the other
514	* accessed variables are indexes into the buffer and hence
515	* always smaller than the size.
516	*/
517	if (cbLogBuf < Val.u32Val)
518	cbLogBuf = Val.u32Val;
519	}
520	}
521	}
522	}
523
524	if ( RT_SUCCESS(rc)
525	&& GCPtrLogBuf != 0
526	&& cbLogBuf != 0)
527	{
528	*pGCPtrLogBuf = GCPtrLogBuf;
529	*pcbLogBuf = cbLogBuf;
530	}
531	else if (RT_SUCCESS(rc))
532	rc = VERR_NOT_FOUND;
533
534	fRet = true;
535	break;
536	}
537	else
538	{
539	/*
540	* In case of a memory to register move store the destination register index and the
541	* source address in the relation table for later processing.
542	*/
543	if ( (DisState.Param1.fUse & (DISUSE_BASE \| DISUSE_REG_GEN32 \| DISUSE_REG_GEN64))
544	&& (DisState.Param2.cb == sizeof(uint32_t) \|\| DisState.Param2.cb == sizeof(uint64_t))
545	&& (DisState.Param2.fUse & (DISUSE_RIPDISPLACEMENT32\|DISUSE_DISPLACEMENT32\|DISUSE_DISPLACEMENT64)))
546	{
547	RTGCPTR GCPtrVal = 0;
548
549	if (DisState.Param2.fUse & DISUSE_RIPDISPLACEMENT32)
550	GCPtrVal = GCPtrCur + DisState.Param2.uDisp.i32 + cbInstr;
551	else if (DisState.Param2.fUse & DISUSE_DISPLACEMENT32)
552	GCPtrVal = (RTGCPTR)DisState.Param2.uDisp.u32;
553	else if (DisState.Param2.fUse & DISUSE_DISPLACEMENT64)
554	GCPtrVal = (RTGCPTR)DisState.Param2.uDisp.u64;
555	else
556	AssertMsgFailedBreakStmt(("Invalid displacement\n"), rc = VERR_INVALID_STATE);
557
558	if (cAddressesUsed < RT_ELEMENTS(aAddresses))
559	{
560	/* movsxd reads always 32bits. */
561	if (DisState.pCurInstr->uOpcode == OP_MOVSXD)
562	aAddresses[cAddressesUsed].cb = sizeof(uint32_t);
563	else
564	aAddresses[cAddressesUsed].cb = DisState.Param2.cb;
565	aAddresses[cAddressesUsed].GCPtrOrigSrc = GCPtrVal;
566	cAddressesUsed++;
567	}
568	else
569	{
570	rc = VERR_INVALID_PARAMETER;
571	break;
572	}
573	}
574	}
575	break;
576	default:
577	/* All other instructions will cause an error for now (playing safe here). */
578	rc = VERR_INVALID_PARAMETER;
579	break;
580	}
581	cInstrDisassembled++;
582	offInstr += cbInstr;
583	}
584	}
585	} while ( RT_SUCCESS(rc)
586	&& cInstrDisassembled < 20
587	&& !fRet);
588	}
589
590	return rc;
591	}
592
593	/**
594	* Try to get at the log buffer starting address and size by disassembling some exposed helpers.
595	*
596	* @returns VBox status code.
597	* @param pThis The Linux digger data.
598	* @param pUVM The VM handle.
599	* @param hMod The module to use.
600	* @param pGCPtrLogBuf Where to store the log buffer pointer on success.
601	* @param pcbLogBuf Where to store the size of the log buffer on success.
602	*/
603	static int dbgDiggerLinuxQueryLogBufferPtrs(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
604	RTGCPTR pGCPtrLogBuf, uint32_t pcbLogBuf)
605	{
606	int rc = VINF_SUCCESS;
607
608	struct { void pvVar; uint32_t cbHost, cbGuest; const char pszSymbol; } aSymbols[] =
609	{
610	{ pGCPtrLogBuf, (uint32_t)sizeof(RTGCPTR), (uint32_t)(pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t)), "log_buf_addr_get" },
611	{ pcbLogBuf, (uint32_t)sizeof(uint32_t), (uint32_t)sizeof(uint32_t), "log_buf_len_get" }
612	};
613	for (uint32_t i = 0; i < RT_ELEMENTS(aSymbols) && RT_SUCCESS(rc); i++)
614	{
615	RT_BZERO(aSymbols[i].pvVar, aSymbols[i].cbHost);
616	Assert(aSymbols[i].cbHost >= aSymbols[i].cbGuest);
617	rc = dbgDiggerLinuxDisassembleSimpleGetter(pThis, pUVM, hMod, aSymbols[i].pszSymbol,
618	aSymbols[i].pvVar, aSymbols[i].cbGuest);
619	}
620
621	return rc;
622	}
623
624	/**
625	* Returns whether the log buffer is a simple ascii buffer or a record based implementation
626	* based on the kernel version found.
627	*
628	* @returns Flag whether the log buffer is the simple ascii buffer.
629	* @param pThis The Linux digger data.
630	* @param pUVM The user mode VM handle.
631	*/
632	static bool dbgDiggerLinuxLogBufferIsAsciiBuffer(PDBGDIGGERLINUX pThis, PUVM pUVM)
633	{
634	char szTmp[128];
635	char const *pszVer = &szTmp[sizeof(g_abLinuxVersion) - 1];
636
637	RT_ZERO(szTmp);
638	int rc = DBGFR3MemReadString(pUVM, 0, &pThis->AddrLinuxBanner, szTmp, sizeof(szTmp) - 1);
639	if ( RT_SUCCESS(rc)
640	&& RTStrVersionCompare(pszVer, "3.4") == -1)
641	return true;
642
643	return false;
644	}
645
646	/**
647	* Worker to get at the kernel log for pre 3.4 kernels where the log buffer was just a char buffer.
648	*
649	* @returns VBox status code.
650	* @param pThis The Linux digger data.
651	* @param pUVM The VM user mdoe handle.
652	* @param hMod The debug module handle.
653	* @param fFlags Flags reserved for future use, MBZ.
654	* @param cMessages The number of messages to retrieve, counting from the
655	* end of the log (i.e. like tail), use UINT32_MAX for all.
656	* @param pszBuf The output buffer.
657	* @param cbBuf The buffer size.
658	* @param pcbActual Where to store the number of bytes actually returned,
659	* including zero terminator. On VERR_BUFFER_OVERFLOW this
660	* holds the necessary buffer size. Optional.
661	*/
662	static int dbgDiggerLinuxLogBufferQueryAscii(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
663	uint32_t fFlags, uint32_t cMessages,
664	char pszBuf, size_t cbBuf, size_t pcbActual)
665	{
666	RT_NOREF2(fFlags, cMessages);
667	int rc = VINF_SUCCESS;
668	RTGCPTR GCPtrLogBuf;
669	uint32_t cbLogBuf;
670
671	struct { void pvVar; size_t cbHost, cbGuest; const char pszSymbol; } aSymbols[] =
672	{
673	{ &GCPtrLogBuf, sizeof(GCPtrLogBuf), pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t), "log_buf" },
674	{ &cbLogBuf, sizeof(cbLogBuf), sizeof(cbLogBuf), "log_buf_len" },
675	};
676	for (uint32_t i = 0; i < RT_ELEMENTS(aSymbols); i++)
677	{
678	RTDBGSYMBOL SymInfo;
679	rc = RTDbgModSymbolByName(hMod, aSymbols[i].pszSymbol, &SymInfo);
680	if (RT_SUCCESS(rc))
681	{
682	RT_BZERO(aSymbols[i].pvVar, aSymbols[i].cbHost);
683	Assert(aSymbols[i].cbHost >= aSymbols[i].cbGuest);
684	DBGFADDRESS Addr;
685	rc = DBGFR3MemRead(pUVM, 0 /idCpu/,
686	DBGFR3AddrFromFlat(pUVM, &Addr, (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr),
687	aSymbols[i].pvVar, aSymbols[i].cbGuest);
688	if (RT_SUCCESS(rc))
689	continue;
690	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Reading '%s' at %RGv: %Rrc\n", aSymbols[i].pszSymbol, Addr.FlatPtr, rc));
691	}
692	else
693	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Error looking up '%s': %Rrc\n", aSymbols[i].pszSymbol, rc));
694	rc = VERR_NOT_FOUND;
695	break;
696	}
697
698	/*
699	* Some kernels don't expose the variables in kallsyms so we have to try disassemble
700	* some public helpers to get at the addresses.
701	*
702	* @todo: Maybe cache those values so we don't have to do the heavy work every time?
703	*/
704	if (rc == VERR_NOT_FOUND)
705	{
706	rc = dbgDiggerLinuxQueryAsciiLogBufferPtrs(pThis, pUVM, hMod, &GCPtrLogBuf, &cbLogBuf);
707	if (RT_FAILURE(rc))
708	return rc;
709	}
710
711	/*
712	* Check if the values make sense.
713	*/
714	if (pThis->f64Bit ? !LNX64_VALID_ADDRESS(GCPtrLogBuf) : !LNX32_VALID_ADDRESS(GCPtrLogBuf))
715	{
716	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_buf' value %RGv is not valid.\n", GCPtrLogBuf));
717	return VERR_NOT_FOUND;
718	}
719	if ( cbLogBuf < 4096
720	\|\| !RT_IS_POWER_OF_TWO(cbLogBuf)
721	\|\| cbLogBuf > 16*_1M)
722	{
723	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_buf_len' value %#x is not valid.\n", cbLogBuf));
724	return VERR_NOT_FOUND;
725	}
726
727	/*
728	* Read the whole log buffer.
729	*/
730	uint8_t pbLogBuf = (uint8_t )RTMemAlloc(cbLogBuf);
731	if (!pbLogBuf)
732	{
733	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Failed to allocate %#x bytes for log buffer\n", cbLogBuf));
734	return VERR_NO_MEMORY;
735	}
736	DBGFADDRESS Addr;
737	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrLogBuf), pbLogBuf, cbLogBuf);
738	if (RT_FAILURE(rc))
739	{
740	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Error reading %#x bytes of log buffer at %RGv: %Rrc\n",
741	cbLogBuf, Addr.FlatPtr, rc));
742	RTMemFree(pbLogBuf);
743	return VERR_NOT_FOUND;
744	}
745
746	/** @todo Try to parse where the single messages start to make use of cMessages. */
747	size_t cchLength = RTStrNLen((const char *)pbLogBuf, cbLogBuf);
748	memcpy(&pszBuf[0], pbLogBuf, RT_MIN(cbBuf, cchLength));
749
750	/* Done with the buffer. */
751	RTMemFree(pbLogBuf);
752
753	/* Set return size value. */
754	if (pcbActual)
755	*pcbActual = RT_MIN(cbBuf, cchLength);
756
757	return cbBuf <= cchLength ? VERR_BUFFER_OVERFLOW : VINF_SUCCESS;
758	}
759
760	/**
761	* Worker to get at the kernel log for post 3.4 kernels where the log buffer contains records.
762	*
763	* @returns VBox status code.
764	* @param pThis The Linux digger data.
765	* @param pUVM The VM user mdoe handle.
766	* @param hMod The debug module handle.
767	* @param fFlags Flags reserved for future use, MBZ.
768	* @param cMessages The number of messages to retrieve, counting from the
769	* end of the log (i.e. like tail), use UINT32_MAX for all.
770	* @param pszBuf The output buffer.
771	* @param cbBuf The buffer size.
772	* @param pcbActual Where to store the number of bytes actually returned,
773	* including zero terminator. On VERR_BUFFER_OVERFLOW this
774	* holds the necessary buffer size. Optional.
775	*/
776	static int dbgDiggerLinuxLogBufferQueryRecords(PDBGDIGGERLINUX pThis, PUVM pUVM, RTDBGMOD hMod,
777	uint32_t fFlags, uint32_t cMessages,
778	char pszBuf, size_t cbBuf, size_t pcbActual)
779	{
780	RT_NOREF1(fFlags);
781	int rc = VINF_SUCCESS;
782	RTGCPTR GCPtrLogBuf;
783	uint32_t cbLogBuf;
784	uint32_t idxFirst;
785	uint32_t idxNext;
786
787	struct { void pvVar; size_t cbHost, cbGuest; const char pszSymbol; } aSymbols[] =
788	{
789	{ &GCPtrLogBuf, sizeof(GCPtrLogBuf), pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t), "log_buf" },
790	{ &cbLogBuf, sizeof(cbLogBuf), sizeof(cbLogBuf), "log_buf_len" },
791	{ &idxFirst, sizeof(idxFirst), sizeof(idxFirst), "log_first_idx" },
792	{ &idxNext, sizeof(idxNext), sizeof(idxNext), "log_next_idx" },
793	};
794	for (uint32_t i = 0; i < RT_ELEMENTS(aSymbols); i++)
795	{
796	RTDBGSYMBOL SymInfo;
797	rc = RTDbgModSymbolByName(hMod, aSymbols[i].pszSymbol, &SymInfo);
798	if (RT_SUCCESS(rc))
799	{
800	RT_BZERO(aSymbols[i].pvVar, aSymbols[i].cbHost);
801	Assert(aSymbols[i].cbHost >= aSymbols[i].cbGuest);
802	DBGFADDRESS Addr;
803	rc = DBGFR3MemRead(pUVM, 0 /idCpu/,
804	DBGFR3AddrFromFlat(pUVM, &Addr, (RTGCPTR)SymInfo.Value + pThis->AddrKernelBase.FlatPtr),
805	aSymbols[i].pvVar, aSymbols[i].cbGuest);
806	if (RT_SUCCESS(rc))
807	continue;
808	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Reading '%s' at %RGv: %Rrc\n", aSymbols[i].pszSymbol, Addr.FlatPtr, rc));
809	}
810	else
811	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Error looking up '%s': %Rrc\n", aSymbols[i].pszSymbol, rc));
812	rc = VERR_NOT_FOUND;
813	break;
814	}
815
816	/*
817	* Some kernels don't expose the variables in kallsyms so we have to try disassemble
818	* some public helpers to get at the addresses.
819	*
820	* @todo: Maybe cache those values so we don't have to do the heavy work every time?
821	*/
822	if (rc == VERR_NOT_FOUND)
823	{
824	idxFirst = 0;
825	idxNext = 0;
826	rc = dbgDiggerLinuxQueryLogBufferPtrs(pThis, pUVM, hMod, &GCPtrLogBuf, &cbLogBuf);
827	if (RT_FAILURE(rc))
828	return rc;
829	}
830
831	/*
832	* Check if the values make sense.
833	*/
834	if (pThis->f64Bit ? !LNX64_VALID_ADDRESS(GCPtrLogBuf) : !LNX32_VALID_ADDRESS(GCPtrLogBuf))
835	{
836	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_buf' value %RGv is not valid.\n", GCPtrLogBuf));
837	return VERR_NOT_FOUND;
838	}
839	if ( cbLogBuf < 4096
840	\|\| !RT_IS_POWER_OF_TWO(cbLogBuf)
841	\|\| cbLogBuf > 16*_1M)
842	{
843	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_buf_len' value %#x is not valid.\n", cbLogBuf));
844	return VERR_NOT_FOUND;
845	}
846	uint32_t const cbLogAlign = 4;
847	if ( idxFirst > cbLogBuf - sizeof(LNXPRINTKHDR)
848	\|\| (idxFirst & (cbLogAlign - 1)) != 0)
849	{
850	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_first_idx' value %#x is not valid.\n", idxFirst));
851	return VERR_NOT_FOUND;
852	}
853	if ( idxNext > cbLogBuf - sizeof(LNXPRINTKHDR)
854	\|\| (idxNext & (cbLogAlign - 1)) != 0)
855	{
856	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_next_idx' value %#x is not valid.\n", idxNext));
857	return VERR_NOT_FOUND;
858	}
859
860	/*
861	* Read the whole log buffer.
862	*/
863	uint8_t pbLogBuf = (uint8_t )RTMemAlloc(cbLogBuf);
864	if (!pbLogBuf)
865	{
866	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Failed to allocate %#x bytes for log buffer\n", cbLogBuf));
867	return VERR_NO_MEMORY;
868	}
869	DBGFADDRESS Addr;
870	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrLogBuf), pbLogBuf, cbLogBuf);
871	if (RT_FAILURE(rc))
872	{
873	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Error reading %#x bytes of log buffer at %RGv: %Rrc\n",
874	cbLogBuf, Addr.FlatPtr, rc));
875	RTMemFree(pbLogBuf);
876	return VERR_NOT_FOUND;
877	}
878
879	/*
880	* Count the messages in the buffer while doing some basic validation.
881	*/
882	uint32_t const cbUsed = idxFirst == idxNext ? cbLogBuf /* could be empty... */
883	: idxFirst < idxNext ? idxNext - idxFirst : cbLogBuf - idxFirst + idxNext;
884	uint32_t cbLeft = cbUsed;
885	uint32_t offCur = idxFirst;
886	uint32_t cLogMsgs = 0;
887
888	while (cbLeft > 0)
889	{
890	PCLNXPRINTKHDR pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
891	if (!pHdr->cbTotal)
892	{
893	/* Wrap around packet, most likely... */
894	if (cbLogBuf - offCur >= cbLeft)
895	break;
896	offCur = 0;
897	pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
898	}
899	if (RT_UNLIKELY( pHdr->cbTotal > cbLogBuf - sizeof(*pHdr) - offCur
900	\|\| pHdr->cbTotal > cbLeft
901	\|\| (pHdr->cbTotal & (cbLogAlign - 1)) != 0
902	\|\| pHdr->cbTotal < (uint32_t)pHdr->cbText + (uint32_t)pHdr->cbDict + sizeof(*pHdr) ))
903	{
904	LogRel(("dbgDiggerLinuxIDmsg_QueryKernelLog: Invalid printk_log record at %#x: cbTotal=%#x cbText=%#x cbDict=%#x cbLogBuf=%#x cbLeft=%#x\n",
905	offCur, pHdr->cbTotal, pHdr->cbText, pHdr->cbDict, cbLogBuf, cbLeft));
906	rc = VERR_INVALID_STATE;
907	break;
908	}
909
910	if (pHdr->cbText > 0)
911	cLogMsgs++;
912
913	/* next */
914	offCur += pHdr->cbTotal;
915	cbLeft -= pHdr->cbTotal;
916	}
917	if (RT_FAILURE(rc))
918	{
919	RTMemFree(pbLogBuf);
920	return rc;
921	}
922
923	/*
924	* Copy the messages into the output buffer.
925	*/
926	offCur = idxFirst;
927	cbLeft = cbUsed;
928
929	/* Skip messages that the caller doesn't want. */
930	if (cMessages < cLogMsgs)
931	{
932	uint32_t cToSkip = cLogMsgs - cMessages;
933	while (cToSkip > 0)
934	{
935	PCLNXPRINTKHDR pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
936	if (!pHdr->cbTotal)
937	{
938	offCur = 0;
939	pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
940	}
941	if (pHdr->cbText > 0)
942	cToSkip--;
943
944	/* next */
945	offCur += pHdr->cbTotal;
946	cbLeft -= pHdr->cbTotal;
947	}
948	}
949
950	/* Now copy the messages. */
951	size_t offDst = 0;
952	while (cbLeft > 0)
953	{
954	PCLNXPRINTKHDR pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
955	if (!pHdr->cbTotal)
956	{
957	if (cbLogBuf - offCur >= cbLeft)
958	break;
959	offCur = 0;
960	pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
961	}
962
963	if (pHdr->cbText > 0)
964	{
965	char pchText = (char )(pHdr + 1);
966	size_t cchText = RTStrNLen(pchText, pHdr->cbText);
967	if (offDst + cchText < cbBuf)
968	{
969	memcpy(&pszBuf[offDst], pHdr + 1, cchText);
970	pszBuf[offDst + cchText] = '\n';
971	}
972	else if (offDst < cbBuf)
973	memcpy(&pszBuf[offDst], pHdr + 1, cbBuf - offDst);
974	offDst += cchText + 1;
975	}
976
977	/* next */
978	offCur += pHdr->cbTotal;
979	cbLeft -= pHdr->cbTotal;
980	}
981
982	/* Done with the buffer. */
983	RTMemFree(pbLogBuf);
984
985	/* Make sure we've reserved a char for the terminator. */
986	if (!offDst)
987	offDst = 1;
988
989	/* Set return size value. */
990	if (pcbActual)
991	*pcbActual = offDst;
992
993	if (offDst <= cbBuf)
994	return VINF_SUCCESS;
995	return VERR_BUFFER_OVERFLOW;
996	}
997
998	/**
999	* @interface_method_impl{DBGFOSIDMESG,pfnQueryKernelLog}
1000	*/
1001	static DECLCALLBACK(int) dbgDiggerLinuxIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, uint32_t fFlags, uint32_t cMessages,
1002	char pszBuf, size_t cbBuf, size_t pcbActual)
1003	{
1004	PDBGDIGGERLINUX pData = RT_FROM_MEMBER(pThis, DBGDIGGERLINUX, IDmesg);
1005
1006	if (cMessages < 1)
1007	return VERR_INVALID_PARAMETER;
1008
1009	/*
1010	* Resolve the symbols we need and read their values.
1011	*/
1012	RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
1013	RTDBGMOD hMod;
1014	int rc = RTDbgAsModuleByName(hAs, "vmlinux", 0, &hMod);
1015	RTDbgAsRelease(hAs);
1016	if (RT_FAILURE(rc))
1017	return VERR_NOT_FOUND;
1018
1019	/*
1020	* Check whether the kernel log buffer is a simple char buffer or the newer
1021	* record based implementation.
1022	* The record based implementation was presumably introduced with kernel 3.4,
1023	* see: http://thread.gmane.org/gmane.linux.kernel/1284184
1024	*/
1025	size_t cbActual;
1026	if (dbgDiggerLinuxLogBufferIsAsciiBuffer(pData, pUVM))
1027	rc = dbgDiggerLinuxLogBufferQueryAscii(pData, pUVM, hMod, fFlags, cMessages, pszBuf, cbBuf, &cbActual);
1028	else
1029	rc = dbgDiggerLinuxLogBufferQueryRecords(pData, pUVM, hMod, fFlags, cMessages, pszBuf, cbBuf, &cbActual);
1030
1031	/* Release the module in any case. */
1032	RTDbgModRelease(hMod);
1033
1034	if (RT_FAILURE(rc) && rc != VERR_BUFFER_OVERFLOW)
1035	return rc;
1036
1037	if (pcbActual)
1038	*pcbActual = cbActual;
1039
1040	/*
1041	* All VBox strings are UTF-8 and bad things may in theory happen if we
1042	* pass bad UTF-8 to code which assumes it's all valid. So, we enforce
1043	* UTF-8 upon the guest kernel messages here even if they (probably) have
1044	* no defined code set in reality.
1045	*/
1046	if ( RT_SUCCESS(rc)
1047	&& cbActual <= cbBuf)
1048	{
1049	pszBuf[cbActual - 1] = '\0';
1050	RTStrPurgeEncoding(pszBuf);
1051	return VINF_SUCCESS;
1052	}
1053
1054	if (cbBuf)
1055	{
1056	pszBuf[cbBuf - 1] = '\0';
1057	RTStrPurgeEncoding(pszBuf);
1058	}
1059	return VERR_BUFFER_OVERFLOW;
1060	}
1061
1062
1063	/**
1064	* Worker destroying the config database.
1065	*/
1066	static DECLCALLBACK(int) dbgDiggerLinuxCfgDbDestroyWorker(PRTSTRSPACECORE pStr, void *pvUser)
1067	{
1068	PDBGDIGGERLINUXCFGITEM pCfgItem = (PDBGDIGGERLINUXCFGITEM)pStr;
1069	RTStrFree((char *)pCfgItem->Core.pszString);
1070	RTMemFree(pCfgItem);
1071	NOREF(pvUser);
1072	return 0;
1073	}
1074
1075
1076	/**
1077	* Destroy the config database.
1078	*
1079	* @returns nothing.
1080	* @param pThis The Linux digger data.
1081	*/
1082	static void dbgDiggerLinuxCfgDbDestroy(PDBGDIGGERLINUX pThis)
1083	{
1084	RTStrSpaceDestroy(&pThis->hCfgDb, dbgDiggerLinuxCfgDbDestroyWorker, NULL);
1085	}
1086
1087
1088	/**
1089	* @copydoc DBGFOSREG::pfnStackUnwindAssist
1090	*/
1091	static DECLCALLBACK(int) dbgDiggerLinuxStackUnwindAssist(PUVM pUVM, void *pvData, VMCPUID idCpu, PDBGFSTACKFRAME pFrame,
1092	PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, RTDBGAS hAs,
1093	uint64_t *puScratch)
1094	{
1095	RT_NOREF(pUVM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
1096	return VINF_SUCCESS;
1097	}
1098
1099
1100	/**
1101	* @copydoc DBGFOSREG::pfnQueryInterface
1102	*/
1103	static DECLCALLBACK(void ) dbgDiggerLinuxQueryInterface(PUVM pUVM, void pvData, DBGFOSINTERFACE enmIf)
1104	{
1105	RT_NOREF1(pUVM);
1106	PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
1107	switch (enmIf)
1108	{
1109	case DBGFOSINTERFACE_DMESG:
1110	return &pThis->IDmesg;
1111
1112	default:
1113	return NULL;
1114	}
1115	}
1116
1117
1118	/**
1119	* @copydoc DBGFOSREG::pfnQueryVersion
1120	*/
1121	static DECLCALLBACK(int) dbgDiggerLinuxQueryVersion(PUVM pUVM, void pvData, char pszVersion, size_t cchVersion)
1122	{
1123	PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
1124	Assert(pThis->fValid);
1125
1126	/*
1127	* It's all in the linux banner.
1128	*/
1129	int rc = DBGFR3MemReadString(pUVM, 0, &pThis->AddrLinuxBanner, pszVersion, cchVersion);
1130	if (RT_SUCCESS(rc))
1131	{
1132	char *pszEnd = RTStrEnd(pszVersion, cchVersion);
1133	AssertReturn(pszEnd, VERR_BUFFER_OVERFLOW);
1134	while ( pszEnd > pszVersion
1135	&& RT_C_IS_SPACE(pszEnd[-1]))
1136	pszEnd--;
1137	*pszEnd = '\0';
1138	}
1139	else
1140	RTStrPrintf(pszVersion, cchVersion, "DBGFR3MemRead -> %Rrc", rc);
1141
1142	return rc;
1143	}
1144
1145
1146	/**
1147	* @copydoc DBGFOSREG::pfnTerm
1148	*/
1149	static DECLCALLBACK(void) dbgDiggerLinuxTerm(PUVM pUVM, void *pvData)
1150	{
1151	PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
1152	Assert(pThis->fValid);
1153
1154	/*
1155	* Destroy configuration database.
1156	*/
1157	dbgDiggerLinuxCfgDbDestroy(pThis);
1158
1159	/*
1160	* Unlink and release our modules.
1161	*/
1162	RTDBGAS hDbgAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
1163	if (hDbgAs != NIL_RTDBGAS)
1164	{
1165	uint32_t iMod = RTDbgAsModuleCount(hDbgAs);
1166	while (iMod-- > 0)
1167	{
1168	RTDBGMOD hMod = RTDbgAsModuleByIndex(hDbgAs, iMod);
1169	if (hMod != NIL_RTDBGMOD)
1170	{
1171	if (RTDbgModGetTag(hMod) == DIG_LNX_MOD_TAG)
1172	{
1173	int rc = RTDbgAsModuleUnlink(hDbgAs, hMod);
1174	AssertRC(rc);
1175	}
1176	RTDbgModRelease(hMod);
1177	}
1178	}
1179	RTDbgAsRelease(hDbgAs);
1180	}
1181
1182	pThis->fValid = false;
1183	}
1184
1185
1186	/**
1187	* @copydoc DBGFOSREG::pfnRefresh
1188	*/
1189	static DECLCALLBACK(int) dbgDiggerLinuxRefresh(PUVM pUVM, void *pvData)
1190	{
1191	PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
1192	NOREF(pThis);
1193	Assert(pThis->fValid);
1194
1195	/*
1196	* For now we'll flush and reload everything.
1197	*/
1198	dbgDiggerLinuxTerm(pUVM, pvData);
1199	return dbgDiggerLinuxInit(pUVM, pvData);
1200	}
1201
1202
1203	/**
1204	* Worker for dbgDiggerLinuxFindStartOfNamesAndSymbolCount that update the
1205	* digger data.
1206	*
1207	* @returns VINF_SUCCESS.
1208	* @param pThis The Linux digger data to update.
1209	* @param pAddrKernelNames The kallsyms_names address.
1210	* @param cKernelSymbols The number of kernel symbol.
1211	* @param cbAddress The guest address size.
1212	*/
1213	static int dbgDiggerLinuxFoundStartOfNames(PDBGDIGGERLINUX pThis, PCDBGFADDRESS pAddrKernelNames,
1214	uint32_t cKernelSymbols, uint32_t cbAddress)
1215	{
1216	pThis->cKernelSymbols = cKernelSymbols;
1217	pThis->AddrKernelNames = *pAddrKernelNames;
1218	pThis->AddrKernelAddresses = *pAddrKernelNames;
1219	uint32_t cbSymbolsSkip = (pThis->fRelKrnlAddr ? 2 : 1) * cbAddress; /* Relative addressing introduces kallsyms_relative_base. */
1220	uint32_t cbOffsets = pThis->fRelKrnlAddr ? sizeof(int32_t) : cbAddress; /* Offsets are always 32bits wide for relative addressing. */
1221	uint32_t cbAlign = 0;
1222
1223	/*
1224	* If the number of symbols is odd there is padding to align the following guest pointer
1225	* sized data properly on 64bit systems with relative addressing.
1226	*/
1227	if ( pThis->fRelKrnlAddr
1228	&& pThis->f64Bit
1229	&& (pThis->cKernelSymbols & 1))
1230	cbAlign = sizeof(int32_t);
1231	DBGFR3AddrSub(&pThis->AddrKernelAddresses, cKernelSymbols * cbOffsets + cbSymbolsSkip + cbAlign);
1232
1233	Log(("dbgDiggerLinuxFoundStartOfNames: AddrKernelAddresses=%RGv\n"
1234	"dbgDiggerLinuxFoundStartOfNames: cKernelSymbols=%#x (at %RGv)\n"
1235	"dbgDiggerLinuxFoundStartOfNames: AddrKernelName=%RGv\n",
1236	pThis->AddrKernelAddresses.FlatPtr,
1237	pThis->cKernelSymbols, pThis->AddrKernelNames.FlatPtr - cbAddress,
1238	pThis->AddrKernelNames.FlatPtr));
1239	return VINF_SUCCESS;
1240	}
1241
1242
1243	/**
1244	* Tries to find the address of the kallsyms_names, kallsyms_num_syms and
1245	* kallsyms_addresses symbols.
1246	*
1247	* The kallsyms_num_syms is read and stored in pThis->cKernelSymbols, while the
1248	* addresses of the other two are stored as pThis->AddrKernelNames and
1249	* pThis->AddrKernelAddresses.
1250	*
1251	* @returns VBox status code, success indicating that all three variables have
1252	* been found and taken down.
1253	* @param pUVM The user mode VM handle.
1254	* @param pThis The Linux digger data.
1255	* @param pHitAddr An address we think is inside kallsyms_names.
1256	*/
1257	static int dbgDiggerLinuxFindStartOfNamesAndSymbolCount(PUVM pUVM, PDBGDIGGERLINUX pThis, PCDBGFADDRESS pHitAddr)
1258	{
1259	/*
1260	* Search backwards in chunks.
1261	*/
1262	union
1263	{
1264	uint8_t ab[0x1000];
1265	uint32_t au32[0x1000 / sizeof(uint32_t)];
1266	uint64_t au64[0x1000 / sizeof(uint64_t)];
1267	} uBuf;
1268	uint32_t cbLeft = LNX_MAX_KALLSYMS_NAMES_SIZE;
1269	uint32_t cbBuf = pHitAddr->FlatPtr & (sizeof(uBuf) - 1);
1270	DBGFADDRESS CurAddr = *pHitAddr;
1271	DBGFR3AddrSub(&CurAddr, cbBuf);
1272	cbBuf += sizeof(uint64_t) - 1; /* In case our kobj hit is in the first 4/8 bytes. */
1273	for (;;)
1274	{
1275	int rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &CurAddr, &uBuf, sizeof(uBuf));
1276	if (RT_FAILURE(rc))
1277	return rc;
1278
1279	/*
1280	* Since Linux 4.6 there are two different methods to store the kallsyms addresses
1281	* in the image.
1282	*
1283	* The first and longer existing method is to store the absolute addresses in an
1284	* array starting at kallsyms_addresses followed by a field which stores the number
1285	* of kernel symbols called kallsyms_num_syms.
1286	* The newer method is to use offsets stored in kallsyms_offsets and have a base pointer
1287	* to relate the offsets to called kallsyms_relative_base. One entry in kallsyms_offsets is
1288	* always 32bit wide regardless of the guest pointer size (this halves the table on 64bit
1289	* systems) but means more work for us for the 64bit case.
1290	*
1291	* When absolute addresses are used the following assumptions hold:
1292	*
1293	* We assume that the three symbols are aligned on guest pointer boundary.
1294	*
1295	* The boundary between the two tables should be noticable as the number
1296	* is unlikely to be more than 16 millions, there will be at least one zero
1297	* byte where it is, 64-bit will have 5 zero bytes. Zero bytes aren't all
1298	* that common in the kallsyms_names table.
1299	*
1300	* Also the kallsyms_names table starts with a length byte, which means
1301	* we're likely to see a byte in the range 1..31.
1302	*
1303	* The kallsyms_addresses are mostly sorted (except for the start where the
1304	* absolute symbols are), so we'll spot a bunch of kernel addresses
1305	* immediately preceeding the kallsyms_num_syms field.
1306	*
1307	* Lazy bird: If kallsyms_num_syms is on a buffer boundrary, we skip
1308	* the check for kernel addresses preceeding it.
1309	*
1310	* For relative offsets most of the assumptions from above are true too
1311	* except that we have to distinguish between the relative base address and the offsets.
1312	* Every observed kernel has a valid kernel address fo the relative base and kallsyms_relative_base
1313	* always comes before kallsyms_num_syms and is aligned on a guest pointer boundary.
1314	* Offsets are stored before kallsyms_relative_base and don't contain valid kernel addresses.
1315	*
1316	* To distinguish between absolute and relative offsetting we check the data before a candidate
1317	* for kallsyms_num_syms. If all entries before the kallsyms_num_syms candidate are valid kernel
1318	* addresses absolute addresses are assumed. If this is not the case but the first entry before
1319	* kallsyms_num_syms is a valid kernel address we check whether the data before and the possible
1320	* relative base form a valid kernel address and assume relative offsets.
1321	*/
1322	if (pThis->f64Bit)
1323	{
1324	uint32_t i = cbBuf / sizeof(uint64_t);
1325	while (i-- > 0)
1326	if ( uBuf.au64[i] <= LNX_MAX_KALLSYMS_SYMBOLS
1327	&& uBuf.au64[i] >= LNX_MIN_KALLSYMS_SYMBOLS)
1328	{
1329	uint8_t pb = (uint8_t )&uBuf.au64[i + 1];
1330	if ( pb[0] <= LNX_MAX_KALLSYMS_ENC_LENGTH
1331	&& pb[0] >= LNX_MIN_KALLSYMS_ENC_LENGTH)
1332	{
1333	/*
1334	* Check whether we have a valid kernel address and try to distinguish
1335	* whether the kernel uses relative offsetting or absolute addresses.
1336	*/
1337	if ( (i >= 1 && LNX64_VALID_ADDRESS(uBuf.au64[i - 1]))
1338	&& (i >= 2 && !LNX64_VALID_ADDRESS(uBuf.au64[i - 2]))
1339	&& (i >= 3 && !LNX64_VALID_ADDRESS(uBuf.au64[i - 3])))
1340	{
1341	RTGCUINTPTR uKrnlRelBase = uBuf.au64[i - 1];
1342	DBGFADDRESS RelAddr = CurAddr;
1343	int32_t aiRelOff[3];
1344	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, DBGFR3AddrAdd(&RelAddr, (i - 1) * sizeof(uint64_t) - sizeof(aiRelOff)),
1345	&aiRelOff[0], sizeof(aiRelOff));
1346	if ( RT_SUCCESS(rc)
1347	&& LNX64_VALID_ADDRESS(uKrnlRelBase + aiRelOff[0])
1348	&& LNX64_VALID_ADDRESS(uKrnlRelBase + aiRelOff[1])
1349	&& LNX64_VALID_ADDRESS(uKrnlRelBase + aiRelOff[2]))
1350	{
1351	Log(("dbgDiggerLinuxFindStartOfNamesAndSymbolCount: relative base %RGv (at %RGv)\n",
1352	uKrnlRelBase, CurAddr.FlatPtr + (i - 1) * sizeof(uint64_t)));
1353	pThis->fRelKrnlAddr = true;
1354	pThis->uKernelRelativeBase = uKrnlRelBase;
1355	return dbgDiggerLinuxFoundStartOfNames(pThis,
1356	DBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint64_t)),
1357	(uint32_t)uBuf.au64[i], sizeof(uint64_t));
1358	}
1359	}
1360
1361	if ( (i <= 0 \|\| LNX64_VALID_ADDRESS(uBuf.au64[i - 1]))
1362	&& (i <= 1 \|\| LNX64_VALID_ADDRESS(uBuf.au64[i - 2]))
1363	&& (i <= 2 \|\| LNX64_VALID_ADDRESS(uBuf.au64[i - 3])))
1364	return dbgDiggerLinuxFoundStartOfNames(pThis,
1365	DBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint64_t)),
1366	(uint32_t)uBuf.au64[i], sizeof(uint64_t));
1367	}
1368	}
1369	}
1370	else
1371	{
1372	uint32_t i = cbBuf / sizeof(uint32_t);
1373	while (i-- > 0)
1374	if ( uBuf.au32[i] <= LNX_MAX_KALLSYMS_SYMBOLS
1375	&& uBuf.au32[i] >= LNX_MIN_KALLSYMS_SYMBOLS)
1376	{
1377	uint8_t pb = (uint8_t )&uBuf.au32[i + 1];
1378	if ( pb[0] <= LNX_MAX_KALLSYMS_ENC_LENGTH
1379	&& pb[0] >= LNX_MIN_KALLSYMS_ENC_LENGTH)
1380	{
1381	/* Check for relative base addressing. */
1382	if (i >= 1 && LNX32_VALID_ADDRESS(uBuf.au32[i - 1]))
1383	{
1384	RTGCUINTPTR uKrnlRelBase = uBuf.au32[i - 1];
1385	if ( (i <= 1 \|\| LNX32_VALID_ADDRESS(uKrnlRelBase + uBuf.au32[i - 2]))
1386	&& (i <= 2 \|\| LNX32_VALID_ADDRESS(uKrnlRelBase + uBuf.au32[i - 3])))
1387	{
1388	Log(("dbgDiggerLinuxFindStartOfNamesAndSymbolCount: relative base %RGv (at %RGv)\n",
1389	uKrnlRelBase, CurAddr.FlatPtr + (i - 1) * sizeof(uint32_t)));
1390	pThis->fRelKrnlAddr = true;
1391	pThis->uKernelRelativeBase = uKrnlRelBase;
1392	return dbgDiggerLinuxFoundStartOfNames(pThis,
1393	DBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint32_t)),
1394	uBuf.au32[i], sizeof(uint32_t));
1395	}
1396	}
1397
1398	if ( (i <= 0 \|\| LNX32_VALID_ADDRESS(uBuf.au32[i - 1]))
1399	&& (i <= 1 \|\| LNX32_VALID_ADDRESS(uBuf.au32[i - 2]))
1400	&& (i <= 2 \|\| LNX32_VALID_ADDRESS(uBuf.au32[i - 3])))
1401	return dbgDiggerLinuxFoundStartOfNames(pThis,
1402	DBGFR3AddrAdd(&CurAddr, (i + 1) * sizeof(uint32_t)),
1403	uBuf.au32[i], sizeof(uint32_t));
1404	}
1405	}
1406	}
1407
1408	/*
1409	* Advance
1410	*/
1411	if (RT_UNLIKELY(cbLeft <= sizeof(uBuf)))
1412	{
1413	Log(("dbgDiggerLinuxFindStartOfNamesAndSymbolCount: failed (pHitAddr=%RGv)\n", pHitAddr->FlatPtr));
1414	return VERR_NOT_FOUND;
1415	}
1416	cbLeft -= sizeof(uBuf);
1417	DBGFR3AddrSub(&CurAddr, sizeof(uBuf));
1418	cbBuf = sizeof(uBuf);
1419	}
1420	}
1421
1422
1423	/**
1424	* Worker for dbgDiggerLinuxFindEndNames that records the findings.
1425	*
1426	* @returns VINF_SUCCESS
1427	* @param pThis The linux digger data to update.
1428	* @param pAddrMarkers The address of the marker (kallsyms_markers).
1429	* @param cbMarkerEntry The size of a marker entry (32-bit or 64-bit).
1430	*/
1431	static int dbgDiggerLinuxFoundMarkers(PDBGDIGGERLINUX pThis, PCDBGFADDRESS pAddrMarkers, uint32_t cbMarkerEntry)
1432	{
1433	pThis->cbKernelNames = pAddrMarkers->FlatPtr - pThis->AddrKernelNames.FlatPtr;
1434	pThis->AddrKernelNameMarkers = *pAddrMarkers;
1435	pThis->cKernelNameMarkers = RT_ALIGN_32(pThis->cKernelSymbols, 256) / 256;
1436	pThis->AddrKernelTokenTable = *pAddrMarkers;
1437	DBGFR3AddrAdd(&pThis->AddrKernelTokenTable, pThis->cKernelNameMarkers * cbMarkerEntry);
1438
1439	Log(("dbgDiggerLinuxFoundMarkers: AddrKernelNames=%RGv cbKernelNames=%#x\n"
1440	"dbgDiggerLinuxFoundMarkers: AddrKernelNameMarkers=%RGv cKernelNameMarkers=%#x\n"
1441	"dbgDiggerLinuxFoundMarkers: AddrKernelTokenTable=%RGv\n",
1442	pThis->AddrKernelNames.FlatPtr, pThis->cbKernelNames,
1443	pThis->AddrKernelNameMarkers.FlatPtr, pThis->cKernelNameMarkers,
1444	pThis->AddrKernelTokenTable.FlatPtr));
1445	return VINF_SUCCESS;
1446	}
1447
1448
1449	/**
1450	* Tries to find the end of kallsyms_names and thereby the start of
1451	* kallsyms_markers and kallsyms_token_table.
1452	*
1453	* The kallsyms_names size is stored in pThis->cbKernelNames, the addresses of
1454	* the two other symbols in pThis->AddrKernelNameMarkers and
1455	* pThis->AddrKernelTokenTable. The number of marker entries is stored in
1456	* pThis->cKernelNameMarkers.
1457	*
1458	* @returns VBox status code, success indicating that all three variables have
1459	* been found and taken down.
1460	* @param pUVM The user mode VM handle.
1461	* @param pThis The Linux digger data.
1462	* @param pHitAddr An address we think is inside kallsyms_names.
1463	*/
1464	static int dbgDiggerLinuxFindEndOfNamesAndMore(PUVM pUVM, PDBGDIGGERLINUX pThis, PCDBGFADDRESS pHitAddr)
1465	{
1466	/*
1467	* Search forward in chunks.
1468	*/
1469	union
1470	{
1471	uint8_t ab[0x1000];
1472	uint32_t au32[0x1000 / sizeof(uint32_t)];
1473	uint64_t au64[0x1000 / sizeof(uint64_t)];
1474	} uBuf;
1475	bool fPendingZeroHit = false;
1476	uint32_t cbLeft = LNX_MAX_KALLSYMS_NAMES_SIZE + sizeof(uBuf);
1477	uint32_t offBuf = pHitAddr->FlatPtr & (sizeof(uBuf) - 1);
1478	DBGFADDRESS CurAddr = *pHitAddr;
1479	DBGFR3AddrSub(&CurAddr, offBuf);
1480	for (;;)
1481	{
1482	int rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &CurAddr, &uBuf, sizeof(uBuf));
1483	if (RT_FAILURE(rc))
1484	return rc;
1485
1486	/*
1487	* The kallsyms_names table is followed by kallsyms_markers we assume,
1488	* using sizeof(unsigned long) alignment like the preceeding symbols.
1489	*
1490	* The kallsyms_markers table has entried sizeof(unsigned long) and
1491	* contains offsets into kallsyms_names. The kallsyms_markers used to
1492	* index kallsyms_names and reduce seek time when looking up the name
1493	* of an address/symbol. Each entry in kallsyms_markers covers 256
1494	* symbol names.
1495	*
1496	* Because of this, the first entry is always zero and all the entries
1497	* are ascending. It also follows that the size of the table can be
1498	* calculated from kallsyms_num_syms.
1499	*
1500	* Note! We could also have walked kallsyms_names by skipping
1501	* kallsyms_num_syms names, but this is faster and we will
1502	* validate the encoded names later.
1503	*/
1504	if (pThis->f64Bit)
1505	{
1506	if ( RT_UNLIKELY(fPendingZeroHit)
1507	&& uBuf.au64[0] >= (LNX_MIN_KALLSYMS_ENC_LENGTH + 1) * 256
1508	&& uBuf.au64[0] <= (LNX_MAX_KALLSYMS_ENC_LENGTH + 1) * 256)
1509	return dbgDiggerLinuxFoundMarkers(pThis, DBGFR3AddrSub(&CurAddr, sizeof(uint64_t)), sizeof(uint64_t));
1510
1511	uint32_t const cEntries = sizeof(uBuf) / sizeof(uint64_t);
1512	for (uint32_t i = offBuf / sizeof(uint64_t); i < cEntries; i++)
1513	if (uBuf.au64[i] == 0)
1514	{
1515	if (RT_UNLIKELY(i + 1 >= cEntries))
1516	{
1517	fPendingZeroHit = true;
1518	break;
1519	}
1520	if ( uBuf.au64[i + 1] >= (LNX_MIN_KALLSYMS_ENC_LENGTH + 1) * 256
1521	&& uBuf.au64[i + 1] <= (LNX_MAX_KALLSYMS_ENC_LENGTH + 1) * 256)
1522	return dbgDiggerLinuxFoundMarkers(pThis, DBGFR3AddrAdd(&CurAddr, i * sizeof(uint64_t)), sizeof(uint64_t));
1523	}
1524	}
1525	else
1526	{
1527	if ( RT_UNLIKELY(fPendingZeroHit)
1528	&& uBuf.au32[0] >= (LNX_MIN_KALLSYMS_ENC_LENGTH + 1) * 256
1529	&& uBuf.au32[0] <= (LNX_MAX_KALLSYMS_ENC_LENGTH + 1) * 256)
1530	return dbgDiggerLinuxFoundMarkers(pThis, DBGFR3AddrSub(&CurAddr, sizeof(uint32_t)), sizeof(uint32_t));
1531
1532	uint32_t const cEntries = sizeof(uBuf) / sizeof(uint32_t);
1533	for (uint32_t i = offBuf / sizeof(uint32_t); i < cEntries; i++)
1534	if (uBuf.au32[i] == 0)
1535	{
1536	if (RT_UNLIKELY(i + 1 >= cEntries))
1537	{
1538	fPendingZeroHit = true;
1539	break;
1540	}
1541	if ( uBuf.au32[i + 1] >= (LNX_MIN_KALLSYMS_ENC_LENGTH + 1) * 256
1542	&& uBuf.au32[i + 1] <= (LNX_MAX_KALLSYMS_ENC_LENGTH + 1) * 256)
1543	return dbgDiggerLinuxFoundMarkers(pThis, DBGFR3AddrAdd(&CurAddr, i * sizeof(uint32_t)), sizeof(uint32_t));
1544	}
1545	}
1546
1547	/*
1548	* Advance
1549	*/
1550	if (RT_UNLIKELY(cbLeft <= sizeof(uBuf)))
1551	{
1552	Log(("dbgDiggerLinuxFindEndOfNamesAndMore: failed (pHitAddr=%RGv)\n", pHitAddr->FlatPtr));
1553	return VERR_NOT_FOUND;
1554	}
1555	cbLeft -= sizeof(uBuf);
1556	DBGFR3AddrAdd(&CurAddr, sizeof(uBuf));
1557	offBuf = 0;
1558	}
1559	}
1560
1561
1562	/**
1563	* Locates the kallsyms_token_index table.
1564	*
1565	* Storing the address in pThis->AddrKernelTokenIndex and the size of the token
1566	* table in pThis->cbKernelTokenTable.
1567	*
1568	* @returns VBox status code.
1569	* @param pUVM The user mode VM handle.
1570	* @param pThis The Linux digger data.
1571	*/
1572	static int dbgDiggerLinuxFindTokenIndex(PUVM pUVM, PDBGDIGGERLINUX pThis)
1573	{
1574	/*
1575	* The kallsyms_token_table is very much like a string table. Due to the
1576	* nature of the compression algorithm it is reasonably short (one example
1577	* here is 853 bytes), so we'll not be reading it in chunks but in full.
1578	* To be on the safe side, we read 8KB, ASSUMING we won't run into unmapped
1579	* memory or any other nasty stuff...
1580	*/
1581	union
1582	{
1583	uint8_t ab[0x2000];
1584	uint16_t au16[0x2000 / sizeof(uint16_t)];
1585	} uBuf;
1586	DBGFADDRESS CurAddr = pThis->AddrKernelTokenTable;
1587	int rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &CurAddr, &uBuf, sizeof(uBuf));
1588	if (RT_FAILURE(rc))
1589	return rc;
1590
1591	/*
1592	* We've got two choices here, either walk the string table or look for
1593	* the next structure, kallsyms_token_index.
1594	*
1595	* The token index is a table of 256 uint16_t entries (index by bytes
1596	* from kallsyms_names) that gives offsets in kallsyms_token_table. It
1597	* starts with a zero entry and the following entries are sorted in
1598	* ascending order. The range of the entries are reasonably small since
1599	* kallsyms_token_table is small.
1600	*
1601	* The alignment seems to be sizeof(unsigned long), just like
1602	* kallsyms_token_table.
1603	*
1604	* So, we start by looking for a zero 16-bit entry.
1605	*/
1606	uint32_t cIncr = (pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t)) / sizeof(uint16_t);
1607
1608	for (uint32_t i = 0; i < sizeof(uBuf) / sizeof(uint16_t) - 16; i += cIncr)
1609	if ( uBuf.au16[i] == 0
1610	&& uBuf.au16[i + 1] > 0
1611	&& uBuf.au16[i + 1] <= LNX_MAX_KALLSYMS_TOKEN_LEN
1612	&& (uint16_t)(uBuf.au16[i + 2] - uBuf.au16[i + 1] - 1U) <= (uint16_t)LNX_MAX_KALLSYMS_TOKEN_LEN
1613	&& (uint16_t)(uBuf.au16[i + 3] - uBuf.au16[i + 2] - 1U) <= (uint16_t)LNX_MAX_KALLSYMS_TOKEN_LEN
1614	&& (uint16_t)(uBuf.au16[i + 4] - uBuf.au16[i + 3] - 1U) <= (uint16_t)LNX_MAX_KALLSYMS_TOKEN_LEN
1615	&& (uint16_t)(uBuf.au16[i + 5] - uBuf.au16[i + 4] - 1U) <= (uint16_t)LNX_MAX_KALLSYMS_TOKEN_LEN
1616	&& (uint16_t)(uBuf.au16[i + 6] - uBuf.au16[i + 5] - 1U) <= (uint16_t)LNX_MAX_KALLSYMS_TOKEN_LEN
1617	)
1618	{
1619	pThis->AddrKernelTokenIndex = CurAddr;
1620	DBGFR3AddrAdd(&pThis->AddrKernelTokenIndex, i * sizeof(uint16_t));
1621	pThis->cbKernelTokenTable = i * sizeof(uint16_t);
1622	return VINF_SUCCESS;
1623	}
1624
1625	Log(("dbgDiggerLinuxFindTokenIndex: Failed (%RGv..%RGv)\n", CurAddr.FlatPtr, CurAddr.FlatPtr + (RTGCUINTPTR)sizeof(uBuf)));
1626	return VERR_NOT_FOUND;
1627	}
1628
1629
1630	/**
1631	* Loads the kernel symbols from the given kallsyms offset table decoding the symbol names
1632	* (worker common for dbgDiggerLinuxLoadKernelSymbolsAbsolute() and dbgDiggerLinuxLoadKernelSymbolsRelative()).
1633	*
1634	* @returns VBox status code.
1635	* @param pUVM The user mode VM handle.
1636	* @param pThis The Linux digger data.
1637	* @param uKernelStart Flat kernel start address.
1638	* @param cbKernel Size of the kernel in bytes.
1639	* @param pauSymOff Pointer to the array of symbol offsets in the kallsyms table
1640	* relative to the start of the kernel.
1641	*/
1642	static int dbgDiggerLinuxLoadKernelSymbolsWorker(PUVM pUVM, PDBGDIGGERLINUX pThis, RTGCUINTPTR uKernelStart,
1643	RTGCUINTPTR cbKernel, RTGCUINTPTR *pauSymOff)
1644	{
1645	uint8_t pbNames = (uint8_t )RTMemAllocZ(pThis->cbKernelNames);
1646	int rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &pThis->AddrKernelNames, pbNames, pThis->cbKernelNames);
1647	if (RT_SUCCESS(rc))
1648	{
1649	char pszzTokens = (char )RTMemAllocZ(pThis->cbKernelTokenTable);
1650	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &pThis->AddrKernelTokenTable, pszzTokens, pThis->cbKernelTokenTable);
1651	if (RT_SUCCESS(rc))
1652	{
1653	uint16_t paoffTokens = (uint16_t )RTMemAllocZ(256 * sizeof(uint16_t));
1654	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &pThis->AddrKernelTokenIndex, paoffTokens, 256 * sizeof(uint16_t));
1655	if (RT_SUCCESS(rc))
1656	{
1657	/*
1658	* Create a module for the kernel.
1659	*/
1660	RTDBGMOD hMod;
1661	rc = RTDbgModCreate(&hMod, "vmlinux", cbKernel, 0 /fFlags/);
1662	if (RT_SUCCESS(rc))
1663	{
1664	rc = RTDbgModSetTag(hMod, DIG_LNX_MOD_TAG); AssertRC(rc);
1665	rc = VINF_SUCCESS;
1666
1667	/*
1668	* Enumerate the symbols.
1669	*/
1670	uint32_t offName = 0;
1671	uint32_t cLeft = pThis->cKernelSymbols;
1672	while (cLeft-- > 0 && RT_SUCCESS(rc))
1673	{
1674	/* Decode the symbol name first. */
1675	if (RT_LIKELY(offName < pThis->cbKernelNames))
1676	{
1677	uint8_t cbName = pbNames[offName++];
1678	if (RT_LIKELY(offName + cbName <= pThis->cbKernelNames))
1679	{
1680	char szSymbol[4096];
1681	uint32_t offSymbol = 0;
1682	while (cbName-- > 0)
1683	{
1684	uint8_t bEnc = pbNames[offName++];
1685	uint16_t offToken = paoffTokens[bEnc];
1686	if (RT_LIKELY(offToken < pThis->cbKernelTokenTable))
1687	{
1688	const char *pszToken = &pszzTokens[offToken];
1689	char ch;
1690	while ((ch = *pszToken++) != '\0')
1691	if (offSymbol < sizeof(szSymbol) - 1)
1692	szSymbol[offSymbol++] = ch;
1693	}
1694	else
1695	{
1696	rc = VERR_INVALID_UTF8_ENCODING;
1697	break;
1698	}
1699	}
1700	szSymbol[offSymbol < sizeof(szSymbol) ? offSymbol : sizeof(szSymbol) - 1] = '\0';
1701
1702	/* The offset. */
1703	RTGCUINTPTR uSymOff = *pauSymOff;
1704	pauSymOff++;
1705
1706	/* Add it without the type char. */
1707	if (uSymOff <= cbKernel)
1708	{
1709	rc = RTDbgModSymbolAdd(hMod, &szSymbol[1], RTDBGSEGIDX_RVA, uSymOff,
1710	0 /cb/, 0 /fFlags/, NULL);
1711	if (RT_FAILURE(rc))
1712	{
1713	if ( rc == VERR_DBG_SYMBOL_NAME_OUT_OF_RANGE
1714	\|\| rc == VERR_DBG_INVALID_RVA
1715	\|\| rc == VERR_DBG_ADDRESS_CONFLICT
1716	\|\| rc == VERR_DBG_DUPLICATE_SYMBOL)
1717	{
1718	Log2(("dbgDiggerLinuxLoadKernelSymbols: RTDbgModSymbolAdd(,%s,) failed %Rrc (ignored)\n", szSymbol, rc));
1719	rc = VINF_SUCCESS;
1720	}
1721	else
1722	Log(("dbgDiggerLinuxLoadKernelSymbols: RTDbgModSymbolAdd(,%s,) failed %Rrc\n", szSymbol, rc));
1723	}
1724	}
1725	}
1726	else
1727	{
1728	rc = VERR_END_OF_STRING;
1729	Log(("dbgDiggerLinuxLoadKernelSymbols: offName=%#x cLeft=%#x cbName=%#x cbKernelNames=%#x\n",
1730	offName, cLeft, cbName, pThis->cbKernelNames));
1731	}
1732	}
1733	else
1734	{
1735	rc = VERR_END_OF_STRING;
1736	Log(("dbgDiggerLinuxLoadKernelSymbols: offName=%#x cLeft=%#x cbKernelNames=%#x\n",
1737	offName, cLeft, pThis->cbKernelNames));
1738	}
1739	}
1740
1741	/*
1742	* Link the module into the address space.
1743	*/
1744	if (RT_SUCCESS(rc))
1745	{
1746	RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
1747	if (hAs != NIL_RTDBGAS)
1748	rc = RTDbgAsModuleLink(hAs, hMod, uKernelStart, RTDBGASLINK_FLAGS_REPLACE);
1749	else
1750	rc = VERR_INTERNAL_ERROR;
1751	RTDbgAsRelease(hAs);
1752	}
1753	else
1754	Log(("dbgDiggerLinuxLoadKernelSymbols: Failed: %Rrc\n", rc));
1755	RTDbgModRelease(hMod);
1756	}
1757	else
1758	Log(("dbgDiggerLinuxLoadKernelSymbols: RTDbgModCreate failed: %Rrc\n", rc));
1759	}
1760	else
1761	Log(("dbgDiggerLinuxLoadKernelSymbols: Reading token index at %RGv failed: %Rrc\n",
1762	pThis->AddrKernelTokenIndex.FlatPtr, rc));
1763	RTMemFree(paoffTokens);
1764	}
1765	else
1766	Log(("dbgDiggerLinuxLoadKernelSymbols: Reading token table at %RGv failed: %Rrc\n",
1767	pThis->AddrKernelTokenTable.FlatPtr, rc));
1768	RTMemFree(pszzTokens);
1769	}
1770	else
1771	Log(("dbgDiggerLinuxLoadKernelSymbols: Reading encoded names at %RGv failed: %Rrc\n",
1772	pThis->AddrKernelNames.FlatPtr, rc));
1773	RTMemFree(pbNames);
1774
1775	return rc;
1776	}
1777
1778	/**
1779	* Loads the kernel symbols from the kallsyms table if it contains absolute addresses
1780	*
1781	* @returns VBox status code.
1782	* @param pUVM The user mode VM handle.
1783	* @param pThis The Linux digger data.
1784	*/
1785	static int dbgDiggerLinuxLoadKernelSymbolsAbsolute(PUVM pUVM, PDBGDIGGERLINUX pThis)
1786	{
1787	/*
1788	* Allocate memory for temporary table copies, reading the tables as we go.
1789	*/
1790	uint32_t const cbGuestAddr = pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t);
1791	void pvAddresses = RTMemAllocZ(pThis->cKernelSymbols cbGuestAddr);
1792	int rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &pThis->AddrKernelAddresses, pvAddresses, pThis->cKernelSymbols * cbGuestAddr);
1793	if (RT_SUCCESS(rc))
1794	{
1795	/*
1796	* Figure out the kernel start and end and convert the absolute addresses to relative offsets.
1797	*/
1798	RTGCUINTPTR uKernelStart = pThis->AddrKernelAddresses.FlatPtr;
1799	RTGCUINTPTR uKernelEnd = pThis->AddrKernelTokenIndex.FlatPtr + 256 * sizeof(uint16_t);
1800	RTGCUINTPTR pauSymOff = (RTGCUINTPTR )RTMemTmpAllocZ(pThis->cKernelSymbols * sizeof(RTGCUINTPTR));
1801	uint32_t i;
1802	if (cbGuestAddr == sizeof(uint64_t))
1803	{
1804	uint64_t pauAddrs = (uint64_t )pvAddresses;
1805	for (i = 0; i < pThis->cKernelSymbols; i++)
1806	if ( pauAddrs[i] < uKernelStart
1807	&& LNX64_VALID_ADDRESS(pauAddrs[i])
1808	&& uKernelStart - pauAddrs[i] < LNX_MAX_KERNEL_SIZE)
1809	uKernelStart = pauAddrs[i];
1810
1811	for (i = pThis->cKernelSymbols - 1; i > 0; i--)
1812	if ( pauAddrs[i] > uKernelEnd
1813	&& LNX64_VALID_ADDRESS(pauAddrs[i])
1814	&& pauAddrs[i] - uKernelEnd < LNX_MAX_KERNEL_SIZE)
1815	uKernelEnd = pauAddrs[i];
1816
1817	for (i = 0; i < pThis->cKernelSymbols; i++)
1818	pauSymOff[i] = pauAddrs[i] - uKernelStart;
1819	}
1820	else
1821	{
1822	uint32_t pauAddrs = (uint32_t )pvAddresses;
1823	for (i = 0; i < pThis->cKernelSymbols; i++)
1824	if ( pauAddrs[i] < uKernelStart
1825	&& LNX32_VALID_ADDRESS(pauAddrs[i])
1826	&& uKernelStart - pauAddrs[i] < LNX_MAX_KERNEL_SIZE)
1827	uKernelStart = pauAddrs[i];
1828
1829	for (i = pThis->cKernelSymbols - 1; i > 0; i--)
1830	if ( pauAddrs[i] > uKernelEnd
1831	&& LNX32_VALID_ADDRESS(pauAddrs[i])
1832	&& pauAddrs[i] - uKernelEnd < LNX_MAX_KERNEL_SIZE)
1833	uKernelEnd = pauAddrs[i];
1834
1835	for (i = 0; i < pThis->cKernelSymbols; i++)
1836	pauSymOff[i] = pauAddrs[i] - uKernelStart;
1837	}
1838
1839	RTGCUINTPTR cbKernel = uKernelEnd - uKernelStart;
1840	pThis->cbKernel = (uint32_t)cbKernel;
1841	DBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelBase, uKernelStart);
1842	Log(("dbgDiggerLinuxLoadKernelSymbolsAbsolute: uKernelStart=%RGv cbKernel=%#x\n", uKernelStart, cbKernel));
1843
1844	rc = dbgDiggerLinuxLoadKernelSymbolsWorker(pUVM, pThis, uKernelStart, cbKernel, pauSymOff);
1845	if (RT_FAILURE(rc))
1846	Log(("dbgDiggerLinuxLoadKernelSymbolsAbsolute: Loading symbols from given offset table failed: %Rrc\n", rc));
1847	RTMemTmpFree(pauSymOff);
1848	}
1849	else
1850	Log(("dbgDiggerLinuxLoadKernelSymbolsAbsolute: Reading symbol addresses at %RGv failed: %Rrc\n",
1851	pThis->AddrKernelAddresses.FlatPtr, rc));
1852	RTMemFree(pvAddresses);
1853
1854	return rc;
1855	}
1856
1857
1858	/**
1859	* Loads the kernel symbols from the kallsyms table if it contains absolute addresses
1860	*
1861	* @returns VBox status code.
1862	* @param pUVM The user mode VM handle.
1863	* @param pThis The Linux digger data.
1864	*/
1865	static int dbgDiggerLinuxLoadKernelSymbolsRelative(PUVM pUVM, PDBGDIGGERLINUX pThis)
1866	{
1867	/*
1868	* Allocate memory for temporary table copies, reading the tables as we go.
1869	*/
1870	int32_t pai32Offsets = (int32_t )RTMemAllocZ(pThis->cKernelSymbols * sizeof(int32_t));
1871	int rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &pThis->AddrKernelAddresses, pai32Offsets, pThis->cKernelSymbols * sizeof(int32_t));
1872	if (RT_SUCCESS(rc))
1873	{
1874	/*
1875	* Figure out the kernel start and end and convert the absolute addresses to relative offsets.
1876	*/
1877	RTGCUINTPTR uKernelStart = pThis->AddrKernelAddresses.FlatPtr;
1878	RTGCUINTPTR uKernelEnd = pThis->AddrKernelTokenIndex.FlatPtr + 256 * sizeof(uint16_t);
1879	RTGCUINTPTR pauSymOff = (RTGCUINTPTR )RTMemTmpAllocZ(pThis->cKernelSymbols * sizeof(RTGCUINTPTR));
1880	uint32_t i;
1881
1882	for (i = 0; i < pThis->cKernelSymbols; i++)
1883	{
1884	RTGCUINTPTR uSymAddr = dbgDiggerLinuxConvOffsetToAddr(pThis, pai32Offsets[i]);
1885
1886	if ( uSymAddr < uKernelStart
1887	&& (pThis->f64Bit ? LNX64_VALID_ADDRESS(uSymAddr) : LNX32_VALID_ADDRESS(uSymAddr))
1888	&& uKernelStart - uSymAddr < LNX_MAX_KERNEL_SIZE)
1889	uKernelStart = uSymAddr;
1890	}
1891
1892	for (i = pThis->cKernelSymbols - 1; i > 0; i--)
1893	{
1894	RTGCUINTPTR uSymAddr = dbgDiggerLinuxConvOffsetToAddr(pThis, pai32Offsets[i]);
1895
1896	if ( uSymAddr > uKernelEnd
1897	&& (pThis->f64Bit ? LNX64_VALID_ADDRESS(uSymAddr) : LNX32_VALID_ADDRESS(uSymAddr))
1898	&& uSymAddr - uKernelEnd < LNX_MAX_KERNEL_SIZE)
1899	uKernelEnd = uSymAddr;
1900
1901	/* Store the offset from the derived kernel start address. */
1902	pauSymOff[i] = uSymAddr - uKernelStart;
1903	}
1904
1905	RTGCUINTPTR cbKernel = uKernelEnd - uKernelStart;
1906	pThis->cbKernel = (uint32_t)cbKernel;
1907	DBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelBase, uKernelStart);
1908	Log(("dbgDiggerLinuxLoadKernelSymbolsRelative: uKernelStart=%RGv cbKernel=%#x\n", uKernelStart, cbKernel));
1909
1910	rc = dbgDiggerLinuxLoadKernelSymbolsWorker(pUVM, pThis, uKernelStart, cbKernel, pauSymOff);
1911	if (RT_FAILURE(rc))
1912	Log(("dbgDiggerLinuxLoadKernelSymbolsRelative: Loading symbols from given offset table failed: %Rrc\n", rc));
1913	RTMemTmpFree(pauSymOff);
1914	}
1915	else
1916	Log(("dbgDiggerLinuxLoadKernelSymbolsRelative: Reading symbol addresses at %RGv failed: %Rrc\n",
1917	pThis->AddrKernelAddresses.FlatPtr, rc));
1918	RTMemFree(pai32Offsets);
1919
1920	return rc;
1921	}
1922
1923
1924	/**
1925	* Loads the kernel symbols.
1926	*
1927	* @returns VBox status code.
1928	* @param pUVM The user mode VM handle.
1929	* @param pThis The Linux digger data.
1930	*/
1931	static int dbgDiggerLinuxLoadKernelSymbols(PUVM pUVM, PDBGDIGGERLINUX pThis)
1932	{
1933	/*
1934	* First the kernel itself.
1935	*/
1936	if (pThis->fRelKrnlAddr)
1937	return dbgDiggerLinuxLoadKernelSymbolsRelative(pUVM, pThis);
1938	return dbgDiggerLinuxLoadKernelSymbolsAbsolute(pUVM, pThis);
1939	}
1940
1941
1942	/*
1943	* The module structure changed it was easier to produce different code for
1944	* each version of the structure. The C preprocessor rules!
1945	*/
1946	#define LNX_TEMPLATE_HEADER "DBGPlugInLinuxModuleCodeTmpl.cpp.h"
1947
1948	#define LNX_BIT_SUFFIX _amd64
1949	#define LNX_PTR_T uint64_t
1950	#define LNX_64BIT 1
1951	#include "DBGPlugInLinuxModuleVerTmpl.cpp.h"
1952
1953	#define LNX_BIT_SUFFIX _x86
1954	#define LNX_PTR_T uint32_t
1955	#define LNX_64BIT 0
1956	#include "DBGPlugInLinuxModuleVerTmpl.cpp.h"
1957
1958	#undef LNX_TEMPLATE_HEADER
1959
1960	static const struct
1961	{
1962	uint32_t uVersion;
1963	bool f64Bit;
1964	uint64_t (*pfnProcessModule)(PDBGDIGGERLINUX pThis, PUVM pUVM, PDBGFADDRESS pAddrModule);
1965	} g_aModVersions[] =
1966	{
1967	#define LNX_TEMPLATE_HEADER "DBGPlugInLinuxModuleTableEntryTmpl.cpp.h"
1968
1969	#define LNX_BIT_SUFFIX _amd64
1970	#define LNX_64BIT 1
1971	#include "DBGPlugInLinuxModuleVerTmpl.cpp.h"
1972
1973	#define LNX_BIT_SUFFIX _x86
1974	#define LNX_64BIT 0
1975	#include "DBGPlugInLinuxModuleVerTmpl.cpp.h"
1976
1977	#undef LNX_TEMPLATE_HEADER
1978	};
1979
1980
1981	/**
1982	* Tries to find and process the module list.
1983	*
1984	* @returns VBox status code.
1985	* @param pThis The Linux digger data.
1986	* @param pUVM The user mode VM handle.
1987	*/
1988	static int dbgDiggerLinuxLoadModules(PDBGDIGGERLINUX pThis, PUVM pUVM)
1989	{
1990	/*
1991	* Locate the list head.
1992	*/
1993	RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
1994	RTDBGSYMBOL SymInfo;
1995	int rc = RTDbgAsSymbolByName(hAs, "vmlinux!modules", &SymInfo, NULL);
1996	RTDbgAsRelease(hAs);
1997	if (RT_FAILURE(rc))
1998	return VERR_NOT_FOUND;
1999
2000	if (RT_FAILURE(rc))
2001	{
2002	LogRel(("dbgDiggerLinuxLoadModules: Failed to locate the module list (%Rrc).\n", rc));
2003	return VERR_NOT_FOUND;
2004	}
2005
2006	/*
2007	* Read the list anchor.
2008	*/
2009	union
2010	{
2011	uint32_t volatile u32Pair[2];
2012	uint64_t u64Pair[2];
2013	} uListAnchor;
2014	DBGFADDRESS Addr;
2015	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, DBGFR3AddrFromFlat(pUVM, &Addr, SymInfo.Value),
2016	&uListAnchor, pThis->f64Bit ? sizeof(uListAnchor.u64Pair) : sizeof(uListAnchor.u32Pair));
2017	if (RT_FAILURE(rc))
2018	{
2019	LogRel(("dbgDiggerLinuxLoadModules: Error reading list anchor at %RX64: %Rrc\n", SymInfo.Value, rc));
2020	return VERR_NOT_FOUND;
2021	}
2022	if (!pThis->f64Bit)
2023	{
2024	uListAnchor.u64Pair[1] = uListAnchor.u32Pair[1];
2025	ASMCompilerBarrier();
2026	uListAnchor.u64Pair[0] = uListAnchor.u32Pair[0];
2027	}
2028
2029	/*
2030	* Get a numerical version number.
2031	*/
2032	char szVersion[256] = "Linux version 4.19.0";
2033	bool fValid = pThis->fValid;
2034	pThis->fValid = true;
2035	dbgDiggerLinuxQueryVersion(pUVM, pThis, szVersion, sizeof(szVersion));
2036	pThis->fValid = fValid;
2037
2038	const char *pszVersion = szVersion;
2039	while (pszVersion && !RT_C_IS_DIGIT(pszVersion))
2040	pszVersion++;
2041
2042	size_t offVersion = 0;
2043	uint32_t uMajor = 0;
2044	while (pszVersion[offVersion] && RT_C_IS_DIGIT(pszVersion[offVersion]))
2045	uMajor = uMajor * 10 + pszVersion[offVersion++] - '0';
2046
2047	if (pszVersion[offVersion] == '.')
2048	offVersion++;
2049
2050	uint32_t uMinor = 0;
2051	while (pszVersion[offVersion] && RT_C_IS_DIGIT(pszVersion[offVersion]))
2052	uMinor = uMinor * 10 + pszVersion[offVersion++] - '0';
2053
2054	if (pszVersion[offVersion] == '.')
2055	offVersion++;
2056
2057	uint32_t uBuild = 0;
2058	while (pszVersion[offVersion] && RT_C_IS_DIGIT(pszVersion[offVersion]))
2059	uBuild = uBuild * 10 + pszVersion[offVersion++] - '0';
2060
2061	uint32_t const uGuestVer = LNX_MK_VER(uMajor, uMinor, uBuild);
2062	if (uGuestVer == 0)
2063	{
2064	LogRel(("dbgDiggerLinuxLoadModules: Failed to parse version string: %s\n", pszVersion));
2065	return VERR_NOT_FOUND;
2066	}
2067
2068	/*
2069	* Find the g_aModVersion entry that fits the best.
2070	* ASSUMES strict descending order by bitcount and version.
2071	*/
2072	Assert(g_aModVersions[0].f64Bit == true);
2073	unsigned i = 0;
2074	if (!pThis->f64Bit)
2075	while (i < RT_ELEMENTS(g_aModVersions) && g_aModVersions[i].f64Bit)
2076	i++;
2077	while ( i < RT_ELEMENTS(g_aModVersions)
2078	&& g_aModVersions[i].f64Bit == pThis->f64Bit
2079	&& uGuestVer < g_aModVersions[i].uVersion)
2080	i++;
2081	if (i >= RT_ELEMENTS(g_aModVersions))
2082	{
2083	LogRel(("dbgDiggerLinuxLoadModules: Failed to find anything matching version: %u.%u.%u (%s)\n",
2084	uMajor, uMinor, uBuild, pszVersion));
2085	return VERR_NOT_FOUND;
2086	}
2087
2088	/*
2089	* Walk the list.
2090	*/
2091	uint64_t uModAddr = uListAnchor.u64Pair[0];
2092	for (size_t iModule = 0; iModule < 4096 && uModAddr != SymInfo.Value && uModAddr != 0; iModule++)
2093	uModAddr = g_aModVersions[i].pfnProcessModule(pThis, pUVM, DBGFR3AddrFromFlat(pUVM, &Addr, uModAddr));
2094
2095	return VINF_SUCCESS;
2096	}
2097
2098
2099	/**
2100	* Checks if there is a likely kallsyms_names fragment at pHitAddr.
2101	*
2102	* @returns true if it's a likely fragment, false if not.
2103	* @param pUVM The user mode VM handle.
2104	* @param pHitAddr The address where paNeedle was found.
2105	* @param pabNeedle The fragment we've been searching for.
2106	* @param cbNeedle The length of the fragment.
2107	*/
2108	static bool dbgDiggerLinuxIsLikelyNameFragment(PUVM pUVM, PCDBGFADDRESS pHitAddr, uint8_t const *pabNeedle, uint8_t cbNeedle)
2109	{
2110	/*
2111	* Examples of lead and tail bytes of our choosen needle in a randomly
2112	* picked kernel:
2113	* k o b j
2114	* 22 6b 6f 62 6a aa
2115	* fc 6b 6f 62 6a aa
2116	* 82 6b 6f 62 6a 5f - ascii trail byte (_).
2117	* ee 6b 6f 62 6a aa
2118	* fc 6b 6f 62 6a 5f - ascii trail byte (_).
2119	* 0a 74 6b 6f 62 6a 5f ea - ascii lead (t) and trail (_) bytes.
2120	* 0b 54 6b 6f 62 6a aa - ascii lead byte (T).
2121	* ... omitting 29 samples similar to the last two ...
2122	* d8 6b 6f 62 6a aa
2123	* d8 6b 6f 62 6a aa
2124	* d8 6b 6f 62 6a aa
2125	* d8 6b 6f 62 6a aa
2126	* f9 5f 6b 6f 62 6a 5f 94 - ascii lead and trail bytes (_)
2127	* f9 5f 6b 6f 62 6a 0c - ascii lead byte (_).
2128	* fd 6b 6f 62 6a 0f
2129	* ... enough.
2130	*/
2131	uint8_t abBuf[32];
2132	DBGFADDRESS ReadAddr = *pHitAddr;
2133	DBGFR3AddrSub(&ReadAddr, 2);
2134	int rc = DBGFR3MemRead(pUVM, 0 /idCpu/, &ReadAddr, abBuf, 2 + cbNeedle + 2);
2135	if (RT_SUCCESS(rc))
2136	{
2137	if (memcmp(&abBuf[2], pabNeedle, cbNeedle) == 0) /* paranoia */
2138	{
2139	uint8_t const bLead = abBuf[1] == '_' \|\| abBuf[1] == 'T' \|\| abBuf[1] == 't' ? abBuf[0] : abBuf[1];
2140	uint8_t const offTail = 2 + cbNeedle;
2141	uint8_t const bTail = abBuf[offTail] == '_' ? abBuf[offTail] : abBuf[offTail + 1];
2142	if ( bLead >= 1 && (bLead < 0x20 \|\| bLead >= 0x80)
2143	&& bTail >= 1 && (bTail < 0x20 \|\| bTail >= 0x80))
2144	return true;
2145	Log(("dbgDiggerLinuxIsLikelyNameFragment: failed at %RGv: bLead=%#x bTail=%#x (offTail=%#x)\n",
2146	pHitAddr->FlatPtr, bLead, bTail, offTail));
2147	}
2148	else
2149	Log(("dbgDiggerLinuxIsLikelyNameFragment: failed at %RGv: Needle changed!\n", pHitAddr->FlatPtr));
2150	}
2151	else
2152	Log(("dbgDiggerLinuxIsLikelyNameFragment: failed at %RGv: %Rrc\n", pHitAddr->FlatPtr, rc));
2153
2154	return false;
2155	}
2156
2157	/**
2158	* Tries to find and load the kernel symbol table with the given needle.
2159	*
2160	* @returns VBox status code.
2161	* @param pThis The Linux digger data.
2162	* @param pUVM The user mode VM handle.
2163	* @param pabNeedle The needle to use for searching.
2164	* @param cbNeedle Size of the needle in bytes.
2165	*/
2166	static int dbgDiggerLinuxFindSymbolTableFromNeedle(PDBGDIGGERLINUX pThis, PUVM pUVM, uint8_t const *pabNeedle, uint8_t cbNeedle)
2167	{
2168	int rc = VINF_SUCCESS;
2169
2170	/*
2171	* Go looking for the kallsyms table. If it's there, it will be somewhere
2172	* after the linux_banner symbol, so use it for starting the search.
2173	*/
2174	DBGFADDRESS CurAddr = pThis->AddrLinuxBanner;
2175	uint32_t cbLeft = LNX_MAX_KERNEL_SIZE;
2176	while (cbLeft > 4096)
2177	{
2178	DBGFADDRESS HitAddr;
2179	rc = DBGFR3MemScan(pUVM, 0 /idCpu/, &CurAddr, cbLeft, 1 /uAlign/,
2180	pabNeedle, cbNeedle, &HitAddr);
2181	if (RT_FAILURE(rc))
2182	break;
2183	if (dbgDiggerLinuxIsLikelyNameFragment(pUVM, &HitAddr, pabNeedle, cbNeedle))
2184	{
2185	/* There will be another hit near by. */
2186	DBGFR3AddrAdd(&HitAddr, 1);
2187	rc = DBGFR3MemScan(pUVM, 0 /idCpu/, &HitAddr, LNX_MAX_KALLSYMS_NAMES_SIZE, 1 /uAlign/,
2188	pabNeedle, cbNeedle, &HitAddr);
2189	if ( RT_SUCCESS(rc)
2190	&& dbgDiggerLinuxIsLikelyNameFragment(pUVM, &HitAddr, pabNeedle, cbNeedle))
2191	{
2192	/*
2193	* We've got a very likely candidate for a location inside kallsyms_names.
2194	* Try find the start of it, that is to say, try find kallsyms_num_syms.
2195	* kallsyms_num_syms is aligned on sizeof(unsigned long) boundrary
2196	*/
2197	rc = dbgDiggerLinuxFindStartOfNamesAndSymbolCount(pUVM, pThis, &HitAddr);
2198	if (RT_SUCCESS(rc))
2199	rc = dbgDiggerLinuxFindEndOfNamesAndMore(pUVM, pThis, &HitAddr);
2200	if (RT_SUCCESS(rc))
2201	rc = dbgDiggerLinuxFindTokenIndex(pUVM, pThis);
2202	if (RT_SUCCESS(rc))
2203	rc = dbgDiggerLinuxLoadKernelSymbols(pUVM, pThis);
2204	if (RT_SUCCESS(rc))
2205	{
2206	rc = dbgDiggerLinuxLoadModules(pThis, pUVM);
2207	break;
2208	}
2209	}
2210	}
2211
2212	/*
2213	* Advance.
2214	*/
2215	RTGCUINTPTR cbDistance = HitAddr.FlatPtr - CurAddr.FlatPtr + cbNeedle;
2216	if (RT_UNLIKELY(cbDistance >= cbLeft))
2217	{
2218	Log(("dbgDiggerLinuxInit: Failed to find kallsyms\n"));
2219	break;
2220	}
2221	cbLeft -= cbDistance;
2222	DBGFR3AddrAdd(&CurAddr, cbDistance);
2223
2224	}
2225
2226	return rc;
2227	}
2228
2229	/**
2230	* Skips whitespace and comments in the given config returning the pointer
2231	* to the first non whitespace character.
2232	*
2233	* @returns Pointer to the first non whitespace character or NULL if the end
2234	* of the string was reached.
2235	* @param pszCfg The config string.
2236	*/
2237	static const char dbgDiggerLinuxCfgSkipWhitespace(const char pszCfg)
2238	{
2239	do
2240	{
2241	while ( *pszCfg != '\0'
2242	&& ( RT_C_IS_SPACE(*pszCfg)
2243	\|\| *pszCfg == '\n'))
2244	pszCfg++;
2245
2246	/* Do we have a comment? Skip it. */
2247	if (*pszCfg == '#')
2248	{
2249	while ( *pszCfg != '\n'
2250	&& *pszCfg != '\0')
2251	pszCfg++;
2252	}
2253	} while ( *pszCfg != '\0'
2254	&& ( RT_C_IS_SPACE(*pszCfg)
2255	\|\| *pszCfg == '\n'
2256	\|\| *pszCfg == '#'));
2257
2258	return pszCfg;
2259	}
2260
2261	/**
2262	* Parses an identifier at the given position.
2263	*
2264	* @returns VBox status code.
2265	* @param pszCfg The config data.
2266	* @param ppszCfgNext Where to store the pointer to the data following the identifier.
2267	* @param ppszIde Where to store the pointer to the identifier on success.
2268	* Free with RTStrFree().
2269	*/
2270	static int dbgDiggerLinuxCfgParseIde(const char pszCfg, const char ppszCfgNext, char *ppszIde)
2271	{
2272	int rc = VINF_SUCCESS;
2273	size_t cchIde = 0;
2274
2275	while ( *pszCfg != '\0'
2276	&& ( RT_C_IS_ALNUM(*pszCfg)
2277	\|\| *pszCfg == '_'))
2278	{
2279	cchIde++;
2280	pszCfg++;
2281	}
2282
2283	if (cchIde)
2284	{
2285	*ppszIde = RTStrDupN(pszCfg - cchIde, cchIde);
2286	if (!*ppszIde)
2287	rc = VERR_NO_STR_MEMORY;
2288	}
2289
2290	*ppszCfgNext = pszCfg;
2291	return rc;
2292	}
2293
2294	/**
2295	* Parses a value for a config item.
2296	*
2297	* @returns VBox status code.
2298	* @param pszCfg The config data.
2299	* @param ppszCfgNext Where to store the pointer to the data following the identifier.
2300	* @param ppCfgItem Where to store the created config item on success.
2301	*/
2302	static int dbgDiggerLinuxCfgParseVal(const char pszCfg, const char *ppszCfgNext,
2303	PDBGDIGGERLINUXCFGITEM *ppCfgItem)
2304	{
2305	int rc = VINF_SUCCESS;
2306	PDBGDIGGERLINUXCFGITEM pCfgItem = NULL;
2307
2308	if (RT_C_IS_DIGIT(pszCfg) \|\| pszCfg == '-')
2309	{
2310	/* Parse the number. */
2311	int64_t i64Num;
2312	rc = RTStrToInt64Ex(pszCfg, (char **)ppszCfgNext, 0, &i64Num);
2313	if ( RT_SUCCESS(rc)
2314	\|\| rc == VWRN_TRAILING_CHARS
2315	\|\| rc == VWRN_TRAILING_SPACES)
2316	{
2317	pCfgItem = (PDBGDIGGERLINUXCFGITEM)RTMemAllocZ(sizeof(DBGDIGGERLINUXCFGITEM));
2318	if (pCfgItem)
2319	{
2320	pCfgItem->enmType = DBGDIGGERLINUXCFGITEMTYPE_NUMBER;
2321	pCfgItem->u.i64Num = i64Num;
2322	}
2323	else
2324	rc = VERR_NO_MEMORY;
2325	}
2326	}
2327	else if (*pszCfg == '\"')
2328	{
2329	/* Parse a string. */
2330	const char *pszCfgCur = pszCfg + 1;
2331	while ( *pszCfgCur != '\0'
2332	&& *pszCfgCur != '\"')
2333	pszCfgCur++;
2334
2335	if (*pszCfgCur == '\"')
2336	{
2337	pCfgItem = (PDBGDIGGERLINUXCFGITEM)RTMemAllocZ(RT_UOFFSETOF_DYN(DBGDIGGERLINUXCFGITEM,
2338	u.aszString[pszCfgCur - pszCfg + 1]));
2339	if (pCfgItem)
2340	{
2341	pCfgItem->enmType = DBGDIGGERLINUXCFGITEMTYPE_STRING;
2342	RTStrCopyEx(&pCfgItem->u.aszString[0], pszCfgCur - pszCfg + 1, pszCfg, pszCfgCur - pszCfg);
2343	*ppszCfgNext = pszCfgCur + 1;
2344	}
2345	else
2346	rc = VERR_NO_MEMORY;
2347	}
2348	else
2349	rc = VERR_INVALID_STATE;
2350	}
2351	else if ( *pszCfg == 'y'
2352	\|\| *pszCfg == 'm')
2353	{
2354	/* Included or module. */
2355	pCfgItem = (PDBGDIGGERLINUXCFGITEM)RTMemAllocZ(sizeof(DBGDIGGERLINUXCFGITEM));
2356	if (pCfgItem)
2357	{
2358	pCfgItem->enmType = DBGDIGGERLINUXCFGITEMTYPE_FLAG;
2359	pCfgItem->u.fModule = *pszCfg == 'm';
2360	}
2361	else
2362	rc = VERR_NO_MEMORY;
2363	pszCfg++;
2364	*ppszCfgNext = pszCfg;
2365	}
2366	else
2367	rc = VERR_INVALID_STATE;
2368
2369	if (RT_SUCCESS(rc))
2370	*ppCfgItem = pCfgItem;
2371	else if (pCfgItem)
2372	RTMemFree(pCfgItem);
2373
2374	return rc;
2375	}
2376
2377	/**
2378	* Parses the given kernel config and creates the config database.
2379	*
2380	* @returns VBox status code
2381	* @param pThis The Linux digger data.
2382	* @param pszCfg The config string.
2383	*/
2384	static int dbgDiggerLinuxCfgParse(PDBGDIGGERLINUX pThis, const char *pszCfg)
2385	{
2386	int rc = VINF_SUCCESS;
2387
2388	/*
2389	* The config is a text file with the following elements:
2390	* # starts a comment which goes till the end of the line
2391	* <Ide>=<val> where <Ide> is an identifier consisting of
2392	* alphanumerical characters (including _)
2393	* <val> denotes the value for the identifier and can have the following
2394	* formats:
2395	* (-)[0-9]* for numbers
2396	* "..." for a string value
2397	* m when a feature is enabled as a module
2398	* y when a feature is enabled
2399	* Newlines are used as a separator between values and mark the end
2400	* of a comment
2401	*/
2402	const char *pszCfgCur = pszCfg;
2403	while ( RT_SUCCESS(rc)
2404	&& *pszCfgCur != '\0')
2405	{
2406	/* Start skipping the whitespace. */
2407	pszCfgCur = dbgDiggerLinuxCfgSkipWhitespace(pszCfgCur);
2408	if ( pszCfgCur
2409	&& *pszCfgCur != '\0')
2410	{
2411	char *pszIde = NULL;
2412	/* Must be an identifier, parse it. */
2413	rc = dbgDiggerLinuxCfgParseIde(pszCfgCur, &pszCfgCur, &pszIde);
2414	if (RT_SUCCESS(rc))
2415	{
2416	/*
2417	* Skip whitespace again (shouldn't be required because = follows immediately
2418	* in the observed configs).
2419	*/
2420	pszCfgCur = dbgDiggerLinuxCfgSkipWhitespace(pszCfgCur);
2421	if ( pszCfgCur
2422	&& *pszCfgCur == '=')
2423	{
2424	pszCfgCur++;
2425	pszCfgCur = dbgDiggerLinuxCfgSkipWhitespace(pszCfgCur);
2426	if ( pszCfgCur
2427	&& *pszCfgCur != '\0')
2428	{
2429	/* Get the value. */
2430	PDBGDIGGERLINUXCFGITEM pCfgItem = NULL;
2431	rc = dbgDiggerLinuxCfgParseVal(pszCfgCur, &pszCfgCur, &pCfgItem);
2432	if (RT_SUCCESS(rc))
2433	{
2434	pCfgItem->Core.pszString = pszIde;
2435	bool fRc = RTStrSpaceInsert(&pThis->hCfgDb, &pCfgItem->Core);
2436	if (!fRc)
2437	{
2438	RTStrFree(pszIde);
2439	RTMemFree(pCfgItem);
2440	rc = VERR_INVALID_STATE;
2441	}
2442	}
2443	}
2444	else
2445	rc = VERR_EOF;
2446	}
2447	else
2448	rc = VERR_INVALID_STATE;
2449	}
2450
2451	if (RT_FAILURE(rc))
2452	RTStrFree(pszIde);
2453	}
2454	else
2455	break; /* Reached the end of the config. */
2456	}
2457
2458	if (RT_FAILURE(rc))
2459	dbgDiggerLinuxCfgDbDestroy(pThis);
2460
2461	return rc;
2462	}
2463
2464	/**
2465	* Decompresses the given config and validates the UTF-8 encoding.
2466	*
2467	* @returns VBox status code.
2468	* @param pbCfgComp The compressed config.
2469	* @param cbCfgComp Size of the compressed config.
2470	* @param ppszCfg Where to store the pointer to the decompressed config
2471	* on success.
2472	*/
2473	static int dbgDiggerLinuxCfgDecompress(const uint8_t pbCfgComp, size_t cbCfgComp, char *ppszCfg)
2474	{
2475	int rc = VINF_SUCCESS;
2476	RTVFSIOSTREAM hVfsIos = NIL_RTVFSIOSTREAM;
2477
2478	rc = RTVfsIoStrmFromBuffer(RTFILE_O_READ, pbCfgComp, cbCfgComp, &hVfsIos);
2479	if (RT_SUCCESS(rc))
2480	{
2481	RTVFSIOSTREAM hVfsIosDecomp = NIL_RTVFSIOSTREAM;
2482	rc = RTZipGzipDecompressIoStream(hVfsIos, RTZIPGZIPDECOMP_F_ALLOW_ZLIB_HDR, &hVfsIosDecomp);
2483	if (RT_SUCCESS(rc))
2484	{
2485	char *pszCfg = NULL;
2486	size_t cchCfg = 0;
2487	size_t cbRead = 0;
2488
2489	do
2490	{
2491	uint8_t abBuf[_64K];
2492	rc = RTVfsIoStrmRead(hVfsIosDecomp, abBuf, sizeof(abBuf), true /fBlocking/, &cbRead);
2493	if (rc == VINF_EOF && cbRead == 0)
2494	rc = VINF_SUCCESS;
2495	if ( RT_SUCCESS(rc)
2496	&& cbRead > 0)
2497	{
2498	/* Append data. */
2499	char *pszCfgNew = pszCfg;
2500	rc = RTStrRealloc(&pszCfgNew, cchCfg + cbRead + 1);
2501	if (RT_SUCCESS(rc))
2502	{
2503	pszCfg = pszCfgNew;
2504	memcpy(pszCfg + cchCfg, &abBuf[0], cbRead);
2505	cchCfg += cbRead;
2506	pszCfg[cchCfg] = '\0'; /* Enforce string termination. */
2507	}
2508	}
2509	} while (RT_SUCCESS(rc) && cbRead > 0);
2510
2511	if (RT_SUCCESS(rc))
2512	*ppszCfg = pszCfg;
2513	else if (RT_FAILURE(rc) && pszCfg)
2514	RTStrFree(pszCfg);
2515
2516	RTVfsIoStrmRelease(hVfsIosDecomp);
2517	}
2518	RTVfsIoStrmRelease(hVfsIos);
2519	}
2520
2521	return rc;
2522	}
2523
2524	/**
2525	* Reads and decodes the compressed kernel config.
2526	*
2527	* @returns VBox status code.
2528	* @param pThis The Linux digger data.
2529	* @param pUVM The user mode VM handle.
2530	* @param pAddrStart The start address of the compressed config.
2531	* @param cbCfgComp The size of the compressed config.
2532	*/
2533	static int dbgDiggerLinuxCfgDecode(PDBGDIGGERLINUX pThis, PUVM pUVM,
2534	PCDBGFADDRESS pAddrStart, size_t cbCfgComp)
2535	{
2536	int rc = VINF_SUCCESS;
2537	uint8_t pbCfgComp = (uint8_t )RTMemTmpAlloc(cbCfgComp);
2538	if (!pbCfgComp)
2539	return VERR_NO_MEMORY;
2540
2541	rc = DBGFR3MemRead(pUVM, 0 /idCpu/, pAddrStart, pbCfgComp, cbCfgComp);
2542	if (RT_SUCCESS(rc))
2543	{
2544	char *pszCfg = NULL;
2545	rc = dbgDiggerLinuxCfgDecompress(pbCfgComp, cbCfgComp, &pszCfg);
2546	if (RT_SUCCESS(rc))
2547	{
2548	if (RTStrIsValidEncoding(pszCfg))
2549	rc = dbgDiggerLinuxCfgParse(pThis, pszCfg);
2550	else
2551	rc = VERR_INVALID_UTF8_ENCODING;
2552	RTStrFree(pszCfg);
2553	}
2554	}
2555
2556	RTMemFree(pbCfgComp);
2557	return rc;
2558	}
2559
2560	/**
2561	* Tries to find the compressed kernel config in the kernel address space
2562	* and sets up the config database.
2563	*
2564	* @returns VBox status code.
2565	* @param pThis The Linux digger data.
2566	* @param pUVM The user mode VM handle.
2567	*/
2568	static int dbgDiggerLinuxCfgFind(PDBGDIGGERLINUX pThis, PUVM pUVM)
2569	{
2570	int rc = VINF_SUCCESS;
2571
2572	/*
2573	* Go looking for the IKCFG_ST string which indicates the start
2574	* of the compressed config file.
2575	*/
2576	static const uint8_t s_abCfgNeedleStart[] = "IKCFG_ST";
2577	static const uint8_t s_abCfgNeedleEnd[] = "IKCFG_ED";
2578	DBGFADDRESS CurAddr = pThis->AddrLinuxBanner;
2579	uint32_t cbLeft = LNX_MAX_KERNEL_SIZE;
2580	while (cbLeft > 4096)
2581	{
2582	DBGFADDRESS HitAddrStart;
2583	rc = DBGFR3MemScan(pUVM, 0 /idCpu/, &CurAddr, cbLeft, 1 /uAlign/,
2584	s_abCfgNeedleStart, sizeof(s_abCfgNeedleStart) - 1, &HitAddrStart);
2585	if (RT_FAILURE(rc))
2586	break;
2587
2588	/* Check for the end marker which shouldn't be that far away. */
2589	DBGFR3AddrAdd(&HitAddrStart, sizeof(s_abCfgNeedleStart) - 1);
2590	DBGFADDRESS HitAddrEnd;
2591	rc = DBGFR3MemScan(pUVM, 0 /* idCpu */, &HitAddrStart, LNX_MAX_COMPRESSED_CFG_SIZE,
2592	1 /* uAlign */, s_abCfgNeedleEnd, sizeof(s_abCfgNeedleEnd) - 1, &HitAddrEnd);
2593	if (RT_SUCCESS(rc))
2594	{
2595	/* Allocate a buffer to hold the compressed data between the markers and fetch it. */
2596	RTGCUINTPTR cbCfg = HitAddrEnd.FlatPtr - HitAddrStart.FlatPtr;
2597	Assert(cbCfg == (size_t)cbCfg);
2598	rc = dbgDiggerLinuxCfgDecode(pThis, pUVM, &HitAddrStart, cbCfg);
2599	if (RT_SUCCESS(rc))
2600	break;
2601	}
2602
2603	/*
2604	* Advance.
2605	*/
2606	RTGCUINTPTR cbDistance = HitAddrStart.FlatPtr - CurAddr.FlatPtr + sizeof(s_abCfgNeedleStart) - 1;
2607	if (RT_UNLIKELY(cbDistance >= cbLeft))
2608	{
2609	LogFunc(("Failed to find compressed kernel config\n"));
2610	break;
2611	}
2612	cbLeft -= cbDistance;
2613	DBGFR3AddrAdd(&CurAddr, cbDistance);
2614
2615	}
2616
2617	return rc;
2618	}
2619
2620	/**
2621	* Probes for a Linux kernel starting at the given address.
2622	*
2623	* @returns Flag whether something which looks like a valid Linux kernel was found.
2624	* @param pThis The Linux digger data.
2625	* @param pUVM The user mode VM handle.
2626	* @param uAddrStart The address to start scanning at.
2627	* @param cbScan How much to scan.
2628	*/
2629	static bool dbgDiggerLinuxProbeWithAddr(PDBGDIGGERLINUX pThis, PUVM pUVM, RTGCUINTPTR uAddrStart, size_t cbScan)
2630	{
2631	/*
2632	* Look for "Linux version " at the start of the rodata segment.
2633	* Hope that this comes before any message buffer or other similar string.
2634	*/
2635	DBGFADDRESS KernelAddr;
2636	DBGFR3AddrFromFlat(pUVM, &KernelAddr, uAddrStart);
2637	DBGFADDRESS HitAddr;
2638	int rc = DBGFR3MemScan(pUVM, 0, &KernelAddr, cbScan, 1,
2639	g_abLinuxVersion, sizeof(g_abLinuxVersion) - 1, &HitAddr);
2640	if (RT_SUCCESS(rc))
2641	{
2642	char szTmp[128];
2643	char const *pszX = &szTmp[sizeof(g_abLinuxVersion) - 1];
2644	rc = DBGFR3MemReadString(pUVM, 0, &HitAddr, szTmp, sizeof(szTmp));
2645	if ( RT_SUCCESS(rc)
2646	&& ( ( pszX[0] == '2' /* 2.x.y with x in {0..6} */
2647	&& pszX[1] == '.'
2648	&& pszX[2] >= '0'
2649	&& pszX[2] <= '6')
2650	\|\| ( pszX[0] >= '3' /* 3.x, 4.x, ... 9.x */
2651	&& pszX[0] <= '9'
2652	&& pszX[1] == '.'
2653	&& pszX[2] >= '0'
2654	&& pszX[2] <= '9')
2655	)
2656	)
2657	{
2658	pThis->AddrKernelBase = KernelAddr;
2659	pThis->AddrLinuxBanner = HitAddr;
2660	return true;
2661	}
2662	}
2663
2664	return false;
2665	}
2666
2667	/**
2668	* Probes for a Linux kernel which has KASLR enabled.
2669	*
2670	* @returns Flag whether a possible candidate location was found.
2671	* @param pThis The Linux digger data.
2672	* @param pUVM The user mode VM handle.
2673	* @param uAddrKernelStart The first address the kernel is expected at.
2674	*/
2675	static bool dbgDiggerLinuxProbeKaslr(PDBGDIGGERLINUX pThis, PUVM pUVM, RTGCUINTPTR uAddrKernelStart)
2676	{
2677	/**
2678	* With KASLR the kernel is loaded at a different address at each boot making detection
2679	* more difficult for us.
2680	*
2681	* The randomization is done in arch/x86/boot/compressed/kaslr.c:choose_random_location() (as of Nov 2017).
2682	* At the end of the method a random offset is chosen using find_random_virt_addr() which is added to the
2683	* kernel map start in the caller (the start of the kernel depends on the bit size, see LNX32_KERNEL_ADDRESS_START
2684	* and LNX64_KERNEL_ADDRESS_START for 32bit and 64bit kernels respectively).
2685	* The lowest offset possible is LOAD_PHYSICAL_ADDR which is defined in arch/x86/include/asm/boot.h
2686	* using CONFIG_PHYSICAL_START aligned to CONFIG_PHYSICAL_ALIGN.
2687	* The default CONFIG_PHYSICAL_START and CONFIG_PHYSICAL_ALIGN are both 0x1000000 no matter whether a 32bit
2688	* or a 64bit kernel is used. So the lowest offset to the kernel start address is 0x1000000.
2689	* The find_random_virt_addr() the number of possible slots where the kernel can be placed based on the image size
2690	* is calculated using the following formula:
2691	* cSlots = ((KERNEL_IMAGE_SIZE - 0x1000000 (minimum) - image_size) / 0x1000000 (CONFIG_PHYSICAL_ALIGN)) + 1
2692	*
2693	* KERNEL_IMAGE_SIZE is 1GB for 64bit kernels and 512MB for 32bit kernels, so the maximum number of slots (resulting
2694	* in the largest possible offset) can be achieved when image_size (which contains the real size of the kernel image
2695	* which is unknown for us) goes to 0 and a 1GB KERNEL_IMAGE_SIZE is assumed. With that the biggest cSlots which can be
2696	* achieved is 64. The chosen random offset is taken from a random long integer using kaslr_get_random_long() modulo the
2697	* number of slots which selects a slot between 0 and 63. The final offset is calculated using:
2698	* offAddr = random_addr * 0x1000000 (CONFIG_PHYSICAL_ALIGN) + 0x1000000 (minimum)
2699	*
2700	* So the highest offset the kernel can start is 0x40000000 which is 1GB (plus the maximum kernel size we defined).
2701	*/
2702	if (dbgDiggerLinuxProbeWithAddr(pThis, pUVM, uAddrKernelStart, _1G + LNX_MAX_KERNEL_SIZE))
2703	return true;
2704
2705	return false;
2706	}
2707
2708	/**
2709	* @copydoc DBGFOSREG::pfnInit
2710	*/
2711	static DECLCALLBACK(int) dbgDiggerLinuxInit(PUVM pUVM, void *pvData)
2712	{
2713	PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
2714	Assert(!pThis->fValid);
2715
2716	/*
2717	* Assume 64-bit kernels all live way beyond 32-bit address space.
2718	*/
2719	pThis->f64Bit = pThis->AddrLinuxBanner.FlatPtr > UINT32_MAX;
2720	pThis->fRelKrnlAddr = false;
2721
2722	pThis->hCfgDb = NULL;
2723
2724	/*
2725	* Try to find the compressed kernel config and parse it before we try
2726	* to get the symbol table, the config database is required to select
2727	* the method to use.
2728	*/
2729	int rc = dbgDiggerLinuxCfgFind(pThis, pUVM);
2730	if (RT_FAILURE(rc))
2731	LogFlowFunc(("Failed to find kernel config (%Rrc), no config database available\n", rc));
2732
2733	static const uint8_t s_abNeedle[] = "kobj";
2734	rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, s_abNeedle, sizeof(s_abNeedle) - 1);
2735	if (RT_FAILURE(rc))
2736	{
2737	/* Try alternate needle (seen on older x86 Linux kernels). */
2738	static const uint8_t s_abNeedleAlt[] = "kobjec";
2739	rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, s_abNeedleAlt, sizeof(s_abNeedleAlt) - 1);
2740	if (RT_FAILURE(rc))
2741	{
2742	static const uint8_t s_abNeedleOSuseX86[] = "nmi"; /* OpenSuSe 10.2 x86 */
2743	rc = dbgDiggerLinuxFindSymbolTableFromNeedle(pThis, pUVM, s_abNeedleOSuseX86, sizeof(s_abNeedleOSuseX86) - 1);
2744	}
2745	}
2746
2747	pThis->fValid = true;
2748	return VINF_SUCCESS;
2749	}
2750
2751
2752	/**
2753	* @copydoc DBGFOSREG::pfnProbe
2754	*/
2755	static DECLCALLBACK(bool) dbgDiggerLinuxProbe(PUVM pUVM, void *pvData)
2756	{
2757	PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
2758
2759	for (unsigned i = 0; i < RT_ELEMENTS(g_au64LnxKernelAddresses); i++)
2760	{
2761	if (dbgDiggerLinuxProbeWithAddr(pThis, pUVM, g_au64LnxKernelAddresses[i], LNX_MAX_KERNEL_SIZE))
2762	return true;
2763	}
2764
2765	/* Maybe the kernel uses KASLR. */
2766	if (dbgDiggerLinuxProbeKaslr(pThis, pUVM, LNX32_KERNEL_ADDRESS_START))
2767	return true;
2768
2769	if (dbgDiggerLinuxProbeKaslr(pThis, pUVM, LNX64_KERNEL_ADDRESS_START))
2770	return true;
2771
2772	return false;
2773	}
2774
2775
2776	/**
2777	* @copydoc DBGFOSREG::pfnDestruct
2778	*/
2779	static DECLCALLBACK(void) dbgDiggerLinuxDestruct(PUVM pUVM, void *pvData)
2780	{
2781	RT_NOREF2(pUVM, pvData);
2782	}
2783
2784
2785	/**
2786	* @copydoc DBGFOSREG::pfnConstruct
2787	*/
2788	static DECLCALLBACK(int) dbgDiggerLinuxConstruct(PUVM pUVM, void *pvData)
2789	{
2790	RT_NOREF1(pUVM);
2791	PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
2792	pThis->IDmesg.u32Magic = DBGFOSIDMESG_MAGIC;
2793	pThis->IDmesg.pfnQueryKernelLog = dbgDiggerLinuxIDmsg_QueryKernelLog;
2794	pThis->IDmesg.u32EndMagic = DBGFOSIDMESG_MAGIC;
2795
2796	return VINF_SUCCESS;
2797	}
2798
2799
2800	const DBGFOSREG g_DBGDiggerLinux =
2801	{
2802	/* .u32Magic = */ DBGFOSREG_MAGIC,
2803	/* .fFlags = */ 0,
2804	/* .cbData = */ sizeof(DBGDIGGERLINUX),
2805	/* .szName = */ "Linux",
2806	/* .pfnConstruct = */ dbgDiggerLinuxConstruct,
2807	/* .pfnDestruct = */ dbgDiggerLinuxDestruct,
2808	/* .pfnProbe = */ dbgDiggerLinuxProbe,
2809	/* .pfnInit = */ dbgDiggerLinuxInit,
2810	/* .pfnRefresh = */ dbgDiggerLinuxRefresh,
2811	/* .pfnTerm = */ dbgDiggerLinuxTerm,
2812	/* .pfnQueryVersion = */ dbgDiggerLinuxQueryVersion,
2813	/* .pfnQueryInterface = */ dbgDiggerLinuxQueryInterface,
2814	/* .pfnStackUnwindAssist = */ dbgDiggerLinuxStackUnwindAssist,
2815	/* .u32EndMagic = */ DBGFOSREG_MAGIC
2816	};
2817

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

source: vbox/trunk/src/VBox/Debugger/DBGPlugInLinux.cpp@ 78975

Download in other formats: