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