DBGPlugInLinux.cpp@ 84980

Last change on this file since 84980 was 84980, checked in by vboxsync, 4 years ago
Debugger/DBGPlugInLinux: New heuristic to find the kernel log buffer even if we couldn't get at the symbols, used as a last resort if everything fails.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 117.7 KB

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

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

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

Download in other formats: