VirtualBox

source: vbox/trunk/src/VBox/Debugger/DBGPlugInOS2.cpp

Last change on this file was 106061, checked in by vboxsync, 3 weeks ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 50.9 KB
Line 
1/* $Id: DBGPlugInOS2.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2/** @file
3 * DBGPlugInOS2 - Debugger and Guest OS Digger Plugin For OS/2.
4 */
5
6/*
7 * Copyright (C) 2009-2024 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#define LOG_GROUP LOG_GROUP_DBGF /// @todo add new log group.
33#include "DBGPlugIns.h"
34#include <VBox/vmm/vmmr3vtable.h>
35#include <VBox/err.h>
36#include <VBox/param.h>
37#include <iprt/string.h>
38#include <iprt/mem.h>
39#include <iprt/stream.h>
40
41
42/*********************************************************************************************************************************
43* Structures and Typedefs *
44*********************************************************************************************************************************/
45
46typedef enum DBGDIGGEROS2VER
47{
48 DBGDIGGEROS2VER_UNKNOWN,
49 DBGDIGGEROS2VER_1_x,
50 DBGDIGGEROS2VER_2_x,
51 DBGDIGGEROS2VER_3_0,
52 DBGDIGGEROS2VER_4_0,
53 DBGDIGGEROS2VER_4_5
54} DBGDIGGEROS2VER;
55
56/**
57 * OS/2 guest OS digger instance data.
58 */
59typedef struct DBGDIGGEROS2
60{
61 /** The user-mode VM handle for use in info handlers. */
62 PUVM pUVM;
63 /** The VMM function table for use in info handlers. */
64 PCVMMR3VTABLE pVMM;
65
66 /** Whether the information is valid or not.
67 * (For fending off illegal interface method calls.) */
68 bool fValid;
69 /** 32-bit (true) or 16-bit (false) */
70 bool f32Bit;
71
72 /** The OS/2 guest version. */
73 DBGDIGGEROS2VER enmVer;
74 uint8_t OS2MajorVersion;
75 uint8_t OS2MinorVersion;
76
77 /** Guest's Global Info Segment selector. */
78 uint16_t selGis;
79 /** The 16:16 address of the LIS. */
80 RTFAR32 Lis;
81
82 /** The kernel virtual address (excluding DOSMVDMINSTDATA & DOSSWAPINSTDATA). */
83 uint32_t uKernelAddr;
84 /** The kernel size. */
85 uint32_t cbKernel;
86
87} DBGDIGGEROS2;
88/** Pointer to the OS/2 guest OS digger instance data. */
89typedef DBGDIGGEROS2 *PDBGDIGGEROS2;
90
91/**
92 * 32-bit OS/2 loader module table entry (V3.0 and later).
93 */
94typedef struct LDRMTE
95{
96 uint16_t mte_flags2;
97 uint16_t mte_handle;
98 uint32_t mte_swapmte; /**< Pointer to LDRSMTE. */
99 uint32_t mte_link; /**< Pointer to next LDRMTE. */
100 uint32_t mte_flags1;
101 uint32_t mte_impmodcnt;
102 uint16_t mte_sfn;
103 uint16_t mte_usecnt;
104 char mte_modname[8];
105 uint32_t mte_RAS; /**< added later */
106 uint32_t mte_modver; /**< added even later. */
107} LDRMTE;
108AssertCompileSize(LDRMTE, 40);
109
110/**
111 * 32-bit OS/2 loader module table entry (V2.11).
112 */
113typedef struct LDRMTE2
114{
115 uint16_t mte_flags2;
116 uint16_t mte_handle;
117 uint32_t mte_swapmte; /**< Pointer to LDRSMTE. */
118 uint32_t mte_modname; /**< Pointer to module name. */
119 uint32_t mte_link; /**< Pointer to next LDRMTE2. */
120 uint32_t mte_flags1;
121 uint32_t mte_impmodcnt;
122 uint16_t mte_sfn;
123 uint16_t mte_usecnt;
124} LDRMTE2;
125AssertCompileSize(LDRMTE2, 28);
126
127/** @name LDRMTE::mte_flag2 values
128 * @{ */
129#define MTEFORMATMASK UINT16_C(0x0003)
130#define MTEFORMATR1 UINT16_C(0x0000)
131#define MTEFORMATNE UINT16_C(0x0001)
132#define MTEFORMATLX UINT16_C(0x0002)
133#define MTEFORMATR2 UINT16_C(0x0003)
134#define MTESYSTEMDLL UINT16_C(0x0004)
135#define MTELOADORATTACH UINT16_C(0x0008)
136#define MTECIRCLEREF UINT16_C(0x0010)
137#define MTEFREEFIXUPS UINT16_C(0x0020) /* had different meaning earlier */
138#define MTEPRELOADED UINT16_C(0x0040)
139#define MTEGETMTEDONE UINT16_C(0x0080)
140#define MTEPACKSEGDONE UINT16_C(0x0100)
141#define MTE20LIELIST UINT16_C(0x0200)
142#define MTESYSPROCESSED UINT16_C(0x0400)
143#define MTEPSDMOD UINT16_C(0x0800)
144#define MTEDLLONEXTLST UINT16_C(0x1000)
145#define MTEPDUMPCIRCREF UINT16_C(0x2000)
146/** @} */
147/** @name LDRMTE::mte_flag1 values
148 * @{ */
149#define MTE1_NOAUTODS UINT32_C(0x00000000)
150#define MTE1_SOLO UINT32_C(0x00000001)
151#define MTE1_INSTANCEDS UINT32_C(0x00000002)
152#define MTE1_INSTLIBINIT UINT32_C(0x00000004)
153#define MTE1_GINISETUP UINT32_C(0x00000008)
154#define MTE1_NOINTERNFIXUPS UINT32_C(0x00000010)
155#define MTE1_NOEXTERNFIXUPS UINT32_C(0x00000020)
156#define MTE1_CLASS_ALL UINT32_C(0x00000000)
157#define MTE1_CLASS_PROGRAM UINT32_C(0x00000040)
158#define MTE1_CLASS_GLOBAL UINT32_C(0x00000080)
159#define MTE1_CLASS_SPECIFIC UINT32_C(0x000000c0)
160#define MTE1_CLASS_MASK UINT32_C(0x000000c0)
161#define MTE1_MTEPROCESSED UINT32_C(0x00000100)
162#define MTE1_USED UINT32_C(0x00000200)
163#define MTE1_DOSLIB UINT32_C(0x00000400)
164#define MTE1_DOSMOD UINT32_C(0x00000800) /**< The OS/2 kernel (DOSCALLS).*/
165#define MTE1_MEDIAFIXED UINT32_C(0x00001000)
166#define MTE1_LDRINVALID UINT32_C(0x00002000)
167#define MTE1_PROGRAMMOD UINT32_C(0x00000000)
168#define MTE1_DEVDRVMOD UINT32_C(0x00004000)
169#define MTE1_LIBRARYMOD UINT32_C(0x00008000)
170#define MTE1_VDDMOD UINT32_C(0x00010000)
171#define MTE1_MVDMMOD UINT32_C(0x00020000)
172#define MTE1_INGRAPH UINT32_C(0x00040000)
173#define MTE1_GINIDONE UINT32_C(0x00080000)
174#define MTE1_ADDRALLOCED UINT32_C(0x00100000)
175#define MTE1_FSDMOD UINT32_C(0x00200000)
176#define MTE1_FSHMOD UINT32_C(0x00400000)
177#define MTE1_LONGNAMES UINT32_C(0x00800000)
178#define MTE1_MEDIACONTIG UINT32_C(0x01000000)
179#define MTE1_MEDIA16M UINT32_C(0x02000000)
180#define MTE1_SWAPONLOAD UINT32_C(0x04000000)
181#define MTE1_PORTHOLE UINT32_C(0x08000000)
182#define MTE1_MODPROT UINT32_C(0x10000000)
183#define MTE1_NEWMOD UINT32_C(0x20000000)
184#define MTE1_DLLTERM UINT32_C(0x40000000)
185#define MTE1_SYMLOADED UINT32_C(0x80000000)
186/** @} */
187
188
189/**
190 * 32-bit OS/2 swappable module table entry.
191 */
192typedef struct LDRSMTE
193{
194 uint32_t smte_mpages; /**< 0x00: module page count. */
195 uint32_t smte_startobj; /**< 0x04: Entrypoint segment number. */
196 uint32_t smte_eip; /**< 0x08: Entrypoint offset value. */
197 uint32_t smte_stackobj; /**< 0x0c: Stack segment number. */
198 uint32_t smte_esp; /**< 0x10: Stack offset value*/
199 uint32_t smte_pageshift; /**< 0x14: Page shift value. */
200 uint32_t smte_fixupsize; /**< 0x18: Size of the fixup section. */
201 uint32_t smte_objtab; /**< 0x1c: Pointer to LDROTE array. */
202 uint32_t smte_objcnt; /**< 0x20: Number of segments. */
203 uint32_t smte_objmap; /**< 0x20: Address of the object page map. */
204 uint32_t smte_itermap; /**< 0x20: File offset of the iterated data map*/
205 uint32_t smte_rsrctab; /**< 0x20: Pointer to resource table? */
206 uint32_t smte_rsrccnt; /**< 0x30: Number of resource table entries. */
207 uint32_t smte_restab; /**< 0x30: Pointer to the resident name table. */
208 uint32_t smte_enttab; /**< 0x30: Possibly entry point table address, if not file offset. */
209 uint32_t smte_fpagetab; /**< 0x30 */
210 uint32_t smte_frectab; /**< 0x40 */
211 uint32_t smte_impmod; /**< 0x44 */
212 uint32_t smte_impproc; /**< 0x48 */
213 uint32_t smte_datapage; /**< 0x4c */
214 uint32_t smte_nrestab; /**< 0x50 */
215 uint32_t smte_cbnrestab; /**< 0x54 */
216 uint32_t smte_autods; /**< 0x58 */
217 uint32_t smte_debuginfo; /**< 0x5c */
218 uint32_t smte_debuglen; /**< 0x60 */
219 uint32_t smte_heapsize; /**< 0x64 */
220 uint32_t smte_path; /**< 0x68 Address of full name string. */
221 uint16_t smte_semcount; /**< 0x6c */
222 uint16_t smte_semowner; /**< 0x6e */
223 uint32_t smte_pfilecache; /**< 0x70: Address of cached data if replace-module is used. */
224 uint32_t smte_stacksize; /**< 0x74: Stack size for .exe thread 1. */
225 uint16_t smte_alignshift; /**< 0x78: */
226 uint16_t smte_NEexpver; /**< 0x7a: */
227 uint16_t smte_pathlen; /**< 0x7c: Length of smte_path */
228 uint16_t smte_NEexetype; /**< 0x7e: */
229 uint16_t smte_csegpack; /**< 0x80: */
230 uint8_t smte_major_os; /**< 0x82: added later to lie about OS version */
231 uint8_t smte_minor_os; /**< 0x83: added later to lie about OS version */
232} LDRSMTE;
233AssertCompileSize(LDRSMTE, 0x84);
234
235typedef struct LDROTE
236{
237 uint32_t ote_size;
238 uint32_t ote_base;
239 uint32_t ote_flags;
240 uint32_t ote_pagemap;
241 uint32_t ote_mapsize;
242 union
243 {
244 uint32_t ote_vddaddr;
245 uint32_t ote_krnaddr;
246 struct
247 {
248 uint16_t ote_selector;
249 uint16_t ote_handle;
250 } s;
251 };
252} LDROTE;
253AssertCompileSize(LDROTE, 24);
254
255
256/**
257 * 32-bit system anchor block segment header.
258 */
259typedef struct SAS
260{
261 uint8_t SAS_signature[4];
262 uint16_t SAS_tables_data; /**< Offset to SASTABLES. */
263 uint16_t SAS_flat_sel; /**< 32-bit kernel DS (flat). */
264 uint16_t SAS_config_data; /**< Offset to SASCONFIG. */
265 uint16_t SAS_dd_data; /**< Offset to SASDD. */
266 uint16_t SAS_vm_data; /**< Offset to SASVM. */
267 uint16_t SAS_task_data; /**< Offset to SASTASK. */
268 uint16_t SAS_RAS_data; /**< Offset to SASRAS. */
269 uint16_t SAS_file_data; /**< Offset to SASFILE. */
270 uint16_t SAS_info_data; /**< Offset to SASINFO. */
271 uint16_t SAS_mp_data; /**< Offset to SASMP. SMP only. */
272} SAS;
273#define SAS_SIGNATURE "SAS "
274
275typedef struct SASTABLES
276{
277 uint16_t SAS_tbl_GDT;
278 uint16_t SAS_tbl_LDT;
279 uint16_t SAS_tbl_IDT;
280 uint16_t SAS_tbl_GDTPOOL;
281} SASTABLES;
282
283typedef struct SASCONFIG
284{
285 uint16_t SAS_config_table;
286} SASCONFIG;
287
288typedef struct SASDD
289{
290 uint16_t SAS_dd_bimodal_chain;
291 uint16_t SAS_dd_real_chain;
292 uint16_t SAS_dd_DPB_segment;
293 uint16_t SAS_dd_CDA_anchor_p;
294 uint16_t SAS_dd_CDA_anchor_r;
295 uint16_t SAS_dd_FSC;
296} SASDD;
297
298typedef struct SASVM
299{
300 uint32_t SAS_vm_arena;
301 uint32_t SAS_vm_object;
302 uint32_t SAS_vm_context;
303 uint32_t SAS_vm_krnl_mte; /**< Flat address of kernel MTE. */
304 uint32_t SAS_vm_glbl_mte; /**< Flat address of global MTE list head pointer variable. */
305 uint32_t SAS_vm_pft;
306 uint32_t SAS_vm_prt;
307 uint32_t SAS_vm_swap;
308 uint32_t SAS_vm_idle_head;
309 uint32_t SAS_vm_free_head;
310 uint32_t SAS_vm_heap_info;
311 uint32_t SAS_vm_all_mte; /**< Flat address of global MTE list head pointer variable. */
312} SASVM;
313
314
315#pragma pack(1)
316typedef struct SASTASK
317{
318 uint16_t SAS_task_PTDA; /**< Current PTDA selector. */
319 uint32_t SAS_task_ptdaptrs; /**< Flat address of process tree root. */
320 uint32_t SAS_task_threadptrs; /**< Flat address array of thread pointer array. */
321 uint32_t SAS_task_tasknumber; /**< Flat address of the TaskNumber variable. */
322 uint32_t SAS_task_threadcount; /**< Flat address of the ThreadCount variable. */
323} SASTASK;
324#pragma pack()
325
326
327#pragma pack(1)
328typedef struct SASRAS
329{
330 uint16_t SAS_RAS_STDA_p;
331 uint16_t SAS_RAS_STDA_r;
332 uint16_t SAS_RAS_event_mask;
333 uint32_t SAS_RAS_Perf_Buff;
334} SASRAS;
335#pragma pack()
336
337typedef struct SASFILE
338{
339 uint32_t SAS_file_MFT; /**< Handle. */
340 uint16_t SAS_file_SFT; /**< Selector. */
341 uint16_t SAS_file_VPB; /**< Selector. */
342 uint16_t SAS_file_CDS; /**< Selector. */
343 uint16_t SAS_file_buffers; /**< Selector. */
344} SASFILE;
345
346#pragma pack(1)
347typedef struct SASINFO
348{
349 uint16_t SAS_info_global; /**< GIS selector. */
350 uint32_t SAS_info_local; /**< 16:16 address of LIS for current task. */
351 uint32_t SAS_info_localRM;
352 uint16_t SAS_info_CDIB; /**< Selector. */
353} SASINFO;
354#pragma pack()
355
356typedef struct SASMP
357{
358 uint32_t SAS_mp_PCBFirst; /**< Flat address of PCB head. */
359 uint32_t SAS_mp_pLockHandles; /**< Flat address of lock handles. */
360 uint32_t SAS_mp_cProcessors; /**< Flat address of CPU count variable. */
361 uint32_t SAS_mp_pIPCInfo; /**< Flat address of IPC info pointer variable. */
362 uint32_t SAS_mp_pIPCHistory; /**< Flat address of IPC history pointer. */
363 uint32_t SAS_mp_IPCHistoryIdx; /**< Flat address of IPC history index variable. */
364 uint32_t SAS_mp_pFirstPSA; /**< Flat address of PSA. Added later. */
365 uint32_t SAS_mp_pPSAPages; /**< Flat address of PSA pages. */
366} SASMP;
367
368
369typedef struct OS2GIS
370{
371 uint32_t time;
372 uint32_t msecs;
373 uint8_t hour;
374 uint8_t minutes;
375 uint8_t seconds;
376 uint8_t hundredths;
377 int16_t timezone;
378 uint16_t cusecTimerInterval;
379 uint8_t day;
380 uint8_t month;
381 uint16_t year;
382 uint8_t weekday;
383 uint8_t uchMajorVersion;
384 uint8_t uchMinorVersion;
385 uint8_t chRevisionLetter;
386 uint8_t sgCurrent;
387 uint8_t sgMax;
388 uint8_t cHugeShift;
389 uint8_t fProtectModeOnly;
390 uint16_t pidForeground;
391 uint8_t fDynamicSched;
392 uint8_t csecMaxWait;
393 uint16_t cmsecMinSlice;
394 uint16_t cmsecMaxSlice;
395 uint16_t bootdrive;
396 uint8_t amecRAS[32];
397 uint8_t csgWindowableVioMax;
398 uint8_t csgPMMax;
399 uint16_t SIS_Syslog;
400 uint16_t SIS_MMIOBase;
401 uint16_t SIS_MMIOAddr;
402 uint8_t SIS_MaxVDMs;
403 uint8_t SIS_Reserved;
404} OS2GIS;
405
406typedef struct OS2LIS
407{
408 uint16_t pidCurrent;
409 uint16_t pidParent;
410 uint16_t prtyCurrent;
411 uint16_t tidCurrent;
412 uint16_t sgCurrent;
413 uint8_t rfProcStatus;
414 uint8_t bReserved1;
415 uint16_t fForeground;
416 uint8_t typeProcess;
417 uint8_t bReserved2;
418 uint16_t selEnvironment;
419 uint16_t offCmdLine;
420 uint16_t cbDataSegment;
421 uint16_t cbStack;
422 uint16_t cbHeap;
423 uint16_t hmod;
424 uint16_t selDS;
425} OS2LIS;
426
427
428/*********************************************************************************************************************************
429* Defined Constants And Macros *
430*********************************************************************************************************************************/
431/** The 'SAS ' signature. */
432#define DIG_OS2_SAS_SIG RT_MAKE_U32_FROM_U8('S','A','S',' ')
433
434/** OS/2Warp on little endian ASCII systems. */
435#define DIG_OS2_MOD_TAG UINT64_C(0x43532f3257617270)
436
437
438/*********************************************************************************************************************************
439* Internal Functions *
440*********************************************************************************************************************************/
441static DECLCALLBACK(int) dbgDiggerOS2Init(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
442
443
444static int dbgDiggerOS2DisplaySelectorAndInfoEx(PDBGDIGGEROS2 pThis, PCDBGFINFOHLP pHlp, uint16_t uSel, uint32_t off,
445 int cchWidth, const char *pszMessage, PDBGFSELINFO pSelInfo)
446{
447 RT_ZERO(*pSelInfo);
448 int rc = pThis->pVMM->pfnDBGFR3SelQueryInfo(pThis->pUVM, 0 /*idCpu*/, uSel, DBGFSELQI_FLAGS_DT_GUEST, pSelInfo);
449 if (RT_SUCCESS(rc))
450 {
451 if (off == UINT32_MAX)
452 pHlp->pfnPrintf(pHlp, "%*s: %#06x (%RGv LB %#RX64 flags=%#x)\n",
453 cchWidth, pszMessage, uSel, pSelInfo->GCPtrBase, pSelInfo->cbLimit, pSelInfo->fFlags);
454 else
455 pHlp->pfnPrintf(pHlp, "%*s: %04x:%04x (%RGv LB %#RX64 flags=%#x)\n",
456 cchWidth, pszMessage, uSel, off, pSelInfo->GCPtrBase + off, pSelInfo->cbLimit - off, pSelInfo->fFlags);
457 }
458 else if (off == UINT32_MAX)
459 pHlp->pfnPrintf(pHlp, "%*s: %#06x (%Rrc)\n", cchWidth, pszMessage, uSel, rc);
460 else
461 pHlp->pfnPrintf(pHlp, "%*s: %04x:%04x (%Rrc)\n", cchWidth, pszMessage, uSel, off, rc);
462 return rc;
463}
464
465DECLINLINE(int) dbgDiggerOS2DisplaySelectorAndInfo(PDBGDIGGEROS2 pThis, PCDBGFINFOHLP pHlp, uint16_t uSel, uint32_t off,
466 int cchWidth, const char *pszMessage)
467{
468 DBGFSELINFO SelInfo;
469 return dbgDiggerOS2DisplaySelectorAndInfoEx(pThis, pHlp, uSel, off, cchWidth, pszMessage, &SelInfo);
470}
471
472
473/**
474 * @callback_method_impl{FNDBGFHANDLEREXT,
475 * Display the OS/2 system anchor segment}
476 */
477static DECLCALLBACK(void) dbgDiggerOS2InfoSas(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs)
478{
479 RT_NOREF(pszArgs);
480 PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser;
481 PUVM const pUVM = pThis->pUVM;
482 PCVMMR3VTABLE const pVMM = pThis->pVMM;
483
484 DBGFSELINFO SelInfo;
485 int rc = pVMM->pfnDBGFR3SelQueryInfo(pUVM, 0 /*idCpu*/, 0x70, DBGFSELQI_FLAGS_DT_GUEST, &SelInfo);
486 if (RT_FAILURE(rc))
487 {
488 pHlp->pfnPrintf(pHlp, "DBGFR3SelQueryInfo failed on selector 0x70: %Rrc\n", rc);
489 return;
490 }
491 pHlp->pfnPrintf(pHlp, "Selector 0x70: %RGv LB %#RX64 (flags %#x)\n",
492 SelInfo.GCPtrBase, (uint64_t)SelInfo.cbLimit, SelInfo.fFlags);
493
494 /*
495 * The SAS header.
496 */
497 union
498 {
499 SAS Sas;
500 uint16_t au16Sas[sizeof(SAS) / sizeof(uint16_t)];
501 };
502 DBGFADDRESS Addr;
503 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase),
504 &Sas, sizeof(Sas));
505 if (RT_FAILURE(rc))
506 {
507 pHlp->pfnPrintf(pHlp, "Failed to read SAS header: %Rrc\n", rc);
508 return;
509 }
510 if (memcmp(&Sas.SAS_signature[0], SAS_SIGNATURE, sizeof(Sas.SAS_signature)) != 0)
511 {
512 pHlp->pfnPrintf(pHlp, "Invalid SAS signature: %#x %#x %#x %#x (expected %#x %#x %#x %#x)\n",
513 Sas.SAS_signature[0], Sas.SAS_signature[1], Sas.SAS_signature[2], Sas.SAS_signature[3],
514 SAS_SIGNATURE[0], SAS_SIGNATURE[1], SAS_SIGNATURE[2], SAS_SIGNATURE[3]);
515 return;
516 }
517 dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, Sas.SAS_flat_sel, UINT32_MAX, 15, "Flat kernel DS");
518 pHlp->pfnPrintf(pHlp, "SAS_tables_data: %#06x (%#RGv)\n", Sas.SAS_tables_data, SelInfo.GCPtrBase + Sas.SAS_tables_data);
519 pHlp->pfnPrintf(pHlp, "SAS_config_data: %#06x (%#RGv)\n", Sas.SAS_config_data, SelInfo.GCPtrBase + Sas.SAS_config_data);
520 pHlp->pfnPrintf(pHlp, " SAS_dd_data: %#06x (%#RGv)\n", Sas.SAS_dd_data, SelInfo.GCPtrBase + Sas.SAS_dd_data);
521 pHlp->pfnPrintf(pHlp, " SAS_vm_data: %#06x (%#RGv)\n", Sas.SAS_vm_data, SelInfo.GCPtrBase + Sas.SAS_vm_data);
522 pHlp->pfnPrintf(pHlp, " SAS_task_data: %#06x (%#RGv)\n", Sas.SAS_task_data, SelInfo.GCPtrBase + Sas.SAS_task_data);
523 pHlp->pfnPrintf(pHlp, " SAS_RAS_data: %#06x (%#RGv)\n", Sas.SAS_RAS_data, SelInfo.GCPtrBase + Sas.SAS_RAS_data);
524 pHlp->pfnPrintf(pHlp, " SAS_file_data: %#06x (%#RGv)\n", Sas.SAS_file_data, SelInfo.GCPtrBase + Sas.SAS_file_data);
525 pHlp->pfnPrintf(pHlp, " SAS_info_data: %#06x (%#RGv)\n", Sas.SAS_info_data, SelInfo.GCPtrBase + Sas.SAS_info_data);
526 bool fIncludeMP = true;
527 if (Sas.SAS_mp_data < sizeof(Sas))
528 fIncludeMP = false;
529 else
530 for (unsigned i = 2; i < RT_ELEMENTS(au16Sas) - 1; i++)
531 if (au16Sas[i] < sizeof(SAS))
532 {
533 fIncludeMP = false;
534 break;
535 }
536 if (fIncludeMP)
537 pHlp->pfnPrintf(pHlp, " SAS_mp_data: %#06x (%#RGv)\n", Sas.SAS_mp_data, SelInfo.GCPtrBase + Sas.SAS_mp_data);
538
539 /* shared databuf */
540 union
541 {
542 SASINFO Info;
543 } u;
544
545 /*
546 * Info data.
547 */
548 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
549 pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase + Sas.SAS_info_data),
550 &u.Info, sizeof(u.Info));
551 if (RT_SUCCESS(rc))
552 {
553 pHlp->pfnPrintf(pHlp, "SASINFO:\n");
554 dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, u.Info.SAS_info_global, UINT32_MAX, 28, "Global info segment");
555 pHlp->pfnPrintf(pHlp, "%28s: %#010x\n", "Local info segment", u.Info.SAS_info_local);
556 pHlp->pfnPrintf(pHlp, "%28s: %#010x\n", "Local info segment (RM)", u.Info.SAS_info_localRM);
557 dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, u.Info.SAS_info_CDIB, UINT32_MAX, 28, "SAS_info_CDIB");
558 }
559 else
560 pHlp->pfnPrintf(pHlp, "Failed to read SAS info data: %Rrc\n", rc);
561
562 /** @todo more */
563}
564
565
566/**
567 * @callback_method_impl{FNDBGFHANDLEREXT,
568 * Display the OS/2 global info segment}
569 */
570static DECLCALLBACK(void) dbgDiggerOS2InfoGis(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs)
571{
572 RT_NOREF(pszArgs);
573 PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser;
574 PUVM const pUVM = pThis->pUVM;
575 PCVMMR3VTABLE const pVMM = pThis->pVMM;
576
577 DBGFSELINFO SelInfo;
578 int rc = dbgDiggerOS2DisplaySelectorAndInfoEx(pThis, pHlp, pThis->selGis, UINT32_MAX, 0, "Global info segment", &SelInfo);
579 if (RT_FAILURE(rc))
580 return;
581
582 /*
583 * Read the GIS.
584 */
585 DBGFADDRESS Addr;
586 OS2GIS Gis;
587 RT_ZERO(Gis);
588 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase), &Gis,
589 RT_MIN(sizeof(Gis), SelInfo.cbLimit + 1));
590 if (RT_FAILURE(rc))
591 {
592 pHlp->pfnPrintf(pHlp, "Failed to read GIS: %Rrc\n", rc);
593 return;
594 }
595 pHlp->pfnPrintf(pHlp, " time: %#010x\n", Gis.time);
596 pHlp->pfnPrintf(pHlp, " msecs: %#010x\n", Gis.msecs);
597 pHlp->pfnPrintf(pHlp, " timestamp: %04u-%02u-%02u %02u:%02u:%02u.%02u\n",
598 Gis.year, Gis.month, Gis.day, Gis.hour, Gis.minutes, Gis.seconds, Gis.hundredths);
599 pHlp->pfnPrintf(pHlp, " timezone: %+2d (min delta)\n", (int)Gis.timezone);
600 pHlp->pfnPrintf(pHlp, " weekday: %u\n", Gis.weekday);
601 pHlp->pfnPrintf(pHlp, " cusecTimerInterval: %u\n", Gis.cusecTimerInterval);
602 pHlp->pfnPrintf(pHlp, " version: %u.%u\n", Gis.uchMajorVersion, Gis.uchMinorVersion);
603 pHlp->pfnPrintf(pHlp, " revision: %#04x (%c)\n", Gis.chRevisionLetter, Gis.chRevisionLetter);
604 pHlp->pfnPrintf(pHlp, " current screen grp: %#04x (%u)\n", Gis.sgCurrent, Gis.sgCurrent);
605 pHlp->pfnPrintf(pHlp, " max screen groups: %#04x (%u)\n", Gis.sgMax, Gis.sgMax);
606 pHlp->pfnPrintf(pHlp, "csgWindowableVioMax: %#x (%u)\n", Gis.csgWindowableVioMax, Gis.csgWindowableVioMax);
607 pHlp->pfnPrintf(pHlp, " csgPMMax: %#x (%u)\n", Gis.csgPMMax, Gis.csgPMMax);
608 pHlp->pfnPrintf(pHlp, " cHugeShift: %#04x\n", Gis.cHugeShift);
609 pHlp->pfnPrintf(pHlp, " fProtectModeOnly: %d\n", Gis.fProtectModeOnly);
610 pHlp->pfnPrintf(pHlp, " pidForeground: %#04x (%u)\n", Gis.pidForeground, Gis.pidForeground);
611 pHlp->pfnPrintf(pHlp, " fDynamicSched: %u\n", Gis.fDynamicSched);
612 pHlp->pfnPrintf(pHlp, " csecMaxWait: %u\n", Gis.csecMaxWait);
613 pHlp->pfnPrintf(pHlp, " cmsecMinSlice: %u\n", Gis.cmsecMinSlice);
614 pHlp->pfnPrintf(pHlp, " cmsecMaxSlice: %u\n", Gis.cmsecMaxSlice);
615 pHlp->pfnPrintf(pHlp, " bootdrive: %#x\n", Gis.bootdrive);
616 pHlp->pfnPrintf(pHlp, " amecRAS: %.32Rhxs\n", &Gis.amecRAS[0]);
617 pHlp->pfnPrintf(pHlp, " SIS_Syslog: %#06x (%u)\n", Gis.SIS_Syslog, Gis.SIS_Syslog);
618 pHlp->pfnPrintf(pHlp, " SIS_MMIOBase: %#06x\n", Gis.SIS_MMIOBase);
619 pHlp->pfnPrintf(pHlp, " SIS_MMIOAddr: %#06x\n", Gis.SIS_MMIOAddr);
620 pHlp->pfnPrintf(pHlp, " SIS_MaxVDMs: %#04x (%u)\n", Gis.SIS_MaxVDMs, Gis.SIS_MaxVDMs);
621 pHlp->pfnPrintf(pHlp, " SIS_Reserved: %#04x\n", Gis.SIS_Reserved);
622}
623
624
625/**
626 * @callback_method_impl{FNDBGFHANDLEREXT,
627 * Display the OS/2 local info segment}
628 */
629static DECLCALLBACK(void) dbgDiggerOS2InfoLis(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs)
630{
631 RT_NOREF(pszArgs);
632 PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser;
633 PUVM const pUVM = pThis->pUVM;
634 PCVMMR3VTABLE const pVMM = pThis->pVMM;
635
636 DBGFSELINFO SelInfo;
637 int rc = dbgDiggerOS2DisplaySelectorAndInfoEx(pThis, pHlp, pThis->Lis.sel, pThis->Lis.off, 19, "Local info segment", &SelInfo);
638 if (RT_FAILURE(rc))
639 return;
640
641 /*
642 * Read the LIS.
643 */
644 DBGFADDRESS Addr;
645 OS2LIS Lis;
646 RT_ZERO(Lis);
647 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase + pThis->Lis.off),
648 &Lis, sizeof(Lis));
649 if (RT_FAILURE(rc))
650 {
651 pHlp->pfnPrintf(pHlp, "Failed to read LIS: %Rrc\n", rc);
652 return;
653 }
654 pHlp->pfnPrintf(pHlp, " pidCurrent: %#06x (%u)\n", Lis.pidCurrent, Lis.pidCurrent);
655 pHlp->pfnPrintf(pHlp, " pidParent: %#06x (%u)\n", Lis.pidParent, Lis.pidParent);
656 pHlp->pfnPrintf(pHlp, " prtyCurrent: %#06x (%u)\n", Lis.prtyCurrent, Lis.prtyCurrent);
657 pHlp->pfnPrintf(pHlp, " tidCurrent: %#06x (%u)\n", Lis.tidCurrent, Lis.tidCurrent);
658 pHlp->pfnPrintf(pHlp, " sgCurrent: %#06x (%u)\n", Lis.sgCurrent, Lis.sgCurrent);
659 pHlp->pfnPrintf(pHlp, " rfProcStatus: %#04x\n", Lis.rfProcStatus);
660 if (Lis.bReserved1)
661 pHlp->pfnPrintf(pHlp, " bReserved1: %#04x\n", Lis.bReserved1);
662 pHlp->pfnPrintf(pHlp, " fForeground: %#04x (%u)\n", Lis.fForeground, Lis.fForeground);
663 pHlp->pfnPrintf(pHlp, " typeProcess: %#04x (%u)\n", Lis.typeProcess, Lis.typeProcess);
664 if (Lis.bReserved2)
665 pHlp->pfnPrintf(pHlp, " bReserved2: %#04x\n", Lis.bReserved2);
666 dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, Lis.selEnvironment, UINT32_MAX, 19, "selEnvironment");
667 pHlp->pfnPrintf(pHlp, " offCmdLine: %#06x (%u)\n", Lis.offCmdLine, Lis.offCmdLine);
668 pHlp->pfnPrintf(pHlp, " cbDataSegment: %#06x (%u)\n", Lis.cbDataSegment, Lis.cbDataSegment);
669 pHlp->pfnPrintf(pHlp, " cbStack: %#06x (%u)\n", Lis.cbStack, Lis.cbStack);
670 pHlp->pfnPrintf(pHlp, " cbHeap: %#06x (%u)\n", Lis.cbHeap, Lis.cbHeap);
671 pHlp->pfnPrintf(pHlp, " hmod: %#06x\n", Lis.hmod); /** @todo look up the name*/
672 dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, Lis.selDS, UINT32_MAX, 19, "selDS");
673}
674
675
676/**
677 * @callback_method_impl{FNDBGFHANDLEREXT,
678 * Display the OS/2 panic message}
679 */
680static DECLCALLBACK(void) dbgDiggerOS2InfoPanic(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs)
681{
682 RT_NOREF(pszArgs);
683 PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser;
684 PUVM const pUVM = pThis->pUVM;
685 PCVMMR3VTABLE const pVMM = pThis->pVMM;
686
687 DBGFADDRESS HitAddr;
688 int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &HitAddr, pThis->uKernelAddr),
689 pThis->cbKernel, 1, RT_STR_TUPLE("Exception in module:"), &HitAddr);
690 if (RT_FAILURE(rc))
691 rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu&*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &HitAddr, pThis->uKernelAddr),
692 pThis->cbKernel, 1, RT_STR_TUPLE("Exception in device driver:"), &HitAddr);
693 /** @todo support pre-2001 kernels w/o the module/drivce name. */
694 if (RT_SUCCESS(rc))
695 {
696 char szMsg[728 + 1];
697 RT_ZERO(szMsg);
698 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &HitAddr, szMsg, sizeof(szMsg) - 1);
699 if (szMsg[0] != '\0')
700 {
701 RTStrPurgeEncoding(szMsg);
702 char *psz = szMsg;
703 while (*psz != '\0')
704 {
705 char *pszEol = strchr(psz, '\r');
706 if (pszEol)
707 *pszEol = '\0';
708 pHlp->pfnPrintf(pHlp, "%s\n", psz);
709 if (!pszEol)
710 break;
711 psz = ++pszEol;
712 if (*psz == '\n')
713 psz++;
714 }
715 }
716 else
717 pHlp->pfnPrintf(pHlp, "DBGFR3MemRead -> %Rrc\n", rc);
718 }
719 else
720 pHlp->pfnPrintf(pHlp, "Unable to locate OS/2 panic message. (%Rrc)\n", rc);
721}
722
723
724
725/**
726 * @copydoc DBGFOSREG::pfnStackUnwindAssist
727 */
728static DECLCALLBACK(int) dbgDiggerOS2StackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
729 PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx,
730 RTDBGAS hAs, uint64_t *puScratch)
731{
732 RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
733 return VINF_SUCCESS;
734}
735
736
737/**
738 * @copydoc DBGFOSREG::pfnQueryInterface
739 */
740static DECLCALLBACK(void *) dbgDiggerOS2QueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf)
741{
742 RT_NOREF(pUVM, pVMM, pvData, enmIf);
743 return NULL;
744}
745
746
747/**
748 * @copydoc DBGFOSREG::pfnQueryVersion
749 */
750static DECLCALLBACK(int) dbgDiggerOS2QueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
751 char *pszVersion, size_t cchVersion)
752{
753 PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
754 RT_NOREF(pUVM, pVMM);
755 Assert(pThis->fValid);
756
757 char *achOS2ProductType[32];
758 char *pszOS2ProductType = (char *)achOS2ProductType;
759
760 if (pThis->OS2MajorVersion == 10)
761 {
762 RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 1.%02d", pThis->OS2MinorVersion);
763 pThis->enmVer = DBGDIGGEROS2VER_1_x;
764 }
765 else if (pThis->OS2MajorVersion == 20)
766 {
767 if (pThis->OS2MinorVersion < 30)
768 {
769 RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 2.%02d", pThis->OS2MinorVersion);
770 pThis->enmVer = DBGDIGGEROS2VER_2_x;
771 }
772 else if (pThis->OS2MinorVersion < 40)
773 {
774 RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 Warp");
775 pThis->enmVer = DBGDIGGEROS2VER_3_0;
776 }
777 else if (pThis->OS2MinorVersion == 40)
778 {
779 RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 Warp 4");
780 pThis->enmVer = DBGDIGGEROS2VER_4_0;
781 }
782 else
783 {
784 RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 Warp %d.%d",
785 pThis->OS2MinorVersion / 10, pThis->OS2MinorVersion % 10);
786 pThis->enmVer = DBGDIGGEROS2VER_4_5;
787 }
788 }
789 RTStrPrintf(pszVersion, cchVersion, "%u.%u (%s)", pThis->OS2MajorVersion, pThis->OS2MinorVersion, pszOS2ProductType);
790 return VINF_SUCCESS;
791}
792
793
794/**
795 * @copydoc DBGFOSREG::pfnTerm
796 */
797static DECLCALLBACK(void) dbgDiggerOS2Term(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
798{
799 PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
800 Assert(pThis->fValid);
801
802 pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "sas");
803 pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "gis");
804 pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "lis");
805 pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "panic");
806
807 pThis->fValid = false;
808}
809
810
811/**
812 * @copydoc DBGFOSREG::pfnRefresh
813 */
814static DECLCALLBACK(int) dbgDiggerOS2Refresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
815{
816 PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
817 NOREF(pThis);
818 Assert(pThis->fValid);
819
820 /*
821 * For now we'll flush and reload everything.
822 */
823 RTDBGAS hDbgAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
824 if (hDbgAs != NIL_RTDBGAS)
825 {
826 uint32_t iMod = RTDbgAsModuleCount(hDbgAs);
827 while (iMod-- > 0)
828 {
829 RTDBGMOD hMod = RTDbgAsModuleByIndex(hDbgAs, iMod);
830 if (hMod != NIL_RTDBGMOD)
831 {
832 if (RTDbgModGetTag(hMod) == DIG_OS2_MOD_TAG)
833 {
834 int rc = RTDbgAsModuleUnlink(hDbgAs, hMod);
835 AssertRC(rc);
836 }
837 RTDbgModRelease(hMod);
838 }
839 }
840 RTDbgAsRelease(hDbgAs);
841 }
842
843 dbgDiggerOS2Term(pUVM, pVMM, pvData);
844 return dbgDiggerOS2Init(pUVM, pVMM, pvData);
845}
846
847
848/** Buffer shared by dbgdiggerOS2ProcessModule and dbgDiggerOS2Init.*/
849typedef union DBGDIGGEROS2BUF
850{
851 uint8_t au8[0x2000];
852 uint16_t au16[0x2000/2];
853 uint32_t au32[0x2000/4];
854 RTUTF16 wsz[0x2000/2];
855 char ach[0x2000];
856 LDROTE aOtes[0x2000 / sizeof(LDROTE)];
857 SAS sas;
858 SASVM sasvm;
859 LDRMTE mte;
860 LDRSMTE smte;
861 LDROTE ote;
862} DBGDIGGEROS2BUF;
863
864/** Arguments dbgdiggerOS2ProcessModule passes to the module open callback. */
865typedef struct
866{
867 const char *pszModPath;
868 const char *pszModName;
869 LDRMTE const *pMte;
870 LDRSMTE const *pSwapMte;
871} DBGDIGGEROS2OPEN;
872
873
874/**
875 * @callback_method_impl{FNRTDBGCFGOPEN, Debug image/image searching callback.}
876 */
877static DECLCALLBACK(int) dbgdiggerOs2OpenModule(RTDBGCFG hDbgCfg, const char *pszFilename, void *pvUser1, void *pvUser2)
878{
879 DBGDIGGEROS2OPEN *pArgs = (DBGDIGGEROS2OPEN *)pvUser1;
880
881 RTDBGMOD hDbgMod = NIL_RTDBGMOD;
882 int rc = RTDbgModCreateFromImage(&hDbgMod, pszFilename, pArgs->pszModName, RTLDRARCH_WHATEVER, hDbgCfg);
883 if (RT_SUCCESS(rc))
884 {
885 /** @todo Do some info matching before using it? */
886
887 *(PRTDBGMOD)pvUser2 = hDbgMod;
888 return VINF_CALLBACK_RETURN;
889 }
890 LogRel(("DbgDiggerOs2: dbgdiggerOs2OpenModule: %Rrc - %s\n", rc, pszFilename));
891 return rc;
892}
893
894
895static void dbgdiggerOS2FixupMTE(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGEROS2 pThis, DBGDIGGEROS2BUF *pBuf)
896{
897 /** @todo OS/2 2.0 used a different format of SAS and likely MTE as well; not supported */
898 if (pThis->OS2MajorVersion == 20 && pThis->OS2MinorVersion < 30)
899 {
900 /*
901 * The MTE was laid out differently in OS/2 2.11, but contained the
902 * same information as in 3.0. After reading the MTE from guest memory,
903 * we can just shuffle things around.
904 * NB: The OS/2 Debugging Handbook doesn't exactly explain that in the
905 * old MTE format, mte_modname is actually a pointer to the ASCII string,
906 * preceded by a length byte.
907 * Must be called before dbgdiggerOS2ProcessModule().
908 */
909 LDRMTE2 OldMte;
910 char achNameBuf[9];
911
912 memcpy(&OldMte, &pBuf->mte, sizeof(OldMte));
913
914 pBuf->mte.mte_flags2 = OldMte.mte_flags2;
915 pBuf->mte.mte_handle = OldMte.mte_handle;
916 pBuf->mte.mte_swapmte = OldMte.mte_swapmte;
917 pBuf->mte.mte_link = OldMte.mte_link;
918 pBuf->mte.mte_flags1 = OldMte.mte_flags1;
919 pBuf->mte.mte_impmodcnt = OldMte.mte_impmodcnt;
920 pBuf->mte.mte_sfn = OldMte.mte_sfn;
921 pBuf->mte.mte_usecnt = OldMte.mte_usecnt;
922
923 /*
924 * Deal with the module name. We assume that in OS/2 V2.x the module name was in
925 * practice restricted to 8 chars, just like it is in V3.0 (pretty safe assumption).
926 */
927 DBGFADDRESS Addr;
928 int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, OldMte.mte_modname),
929 &achNameBuf, sizeof(achNameBuf));
930 if (RT_SUCCESS(rc))
931 {
932 memset(pBuf->mte.mte_modname, 0, 8);
933 if((uint8_t)achNameBuf[0] <= 8)
934 memcpy(pBuf->mte.mte_modname, &achNameBuf[1], achNameBuf[0]);
935 else
936 memcpy(pBuf->mte.mte_modname, "!NameErr", 8);
937 }
938 else
939 {
940 memcpy(pBuf->mte.mte_modname, "!RdErr", 6);
941 }
942 }
943}
944
945
946static void dbgdiggerOS2ProcessModule(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGEROS2 pThis, DBGDIGGEROS2BUF *pBuf,
947 const char *pszCacheSubDir, RTDBGAS hAs, RTDBGCFG hDbgCfg)
948{
949 RT_NOREF(pThis);
950
951 /*
952 * Save the MTE.
953 */
954 static const char * const s_apszMteFmts[4] = { "Reserved1", "NE", "LX", "Reserved2" };
955 LDRMTE const Mte = pBuf->mte;
956 if ((Mte.mte_flags2 & MTEFORMATMASK) != MTEFORMATLX)
957 {
958 LogRel(("DbgDiggerOs2: MTE format not implemented: %s (%d)\n",
959 s_apszMteFmts[(Mte.mte_flags2 & MTEFORMATMASK)], Mte.mte_flags2 & MTEFORMATMASK));
960 return;
961 }
962
963 /*
964 * Don't load program modules into the global address spaces.
965 */
966 if ((Mte.mte_flags1 & MTE1_CLASS_MASK) == MTE1_CLASS_PROGRAM)
967 {
968 LogRel(("DbgDiggerOs2: Program module, skipping.\n"));
969 return;
970 }
971
972 /*
973 * Try read the swappable MTE. Save it too.
974 */
975 DBGFADDRESS Addr;
976 int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Mte.mte_swapmte),
977 &pBuf->smte, sizeof(pBuf->smte));
978 if (RT_FAILURE(rc))
979 {
980 LogRel(("DbgDiggerOs2: Error reading swap mte @ %RX32: %Rrc\n", Mte.mte_swapmte, rc));
981 return;
982 }
983 LDRSMTE const SwapMte = pBuf->smte;
984
985 /* Ignore empty modules or modules with too many segments. */
986 if (SwapMte.smte_objcnt == 0 || SwapMte.smte_objcnt > RT_ELEMENTS(pBuf->aOtes))
987 {
988 LogRel(("DbgDiggerOs2: Skipping: smte_objcnt= %#RX32\n", SwapMte.smte_objcnt));
989 return;
990 }
991
992 /*
993 * Try read the path name, falling back on module name.
994 */
995 char szModPath[260];
996 rc = VERR_READ_ERROR;
997 if (SwapMte.smte_path != 0 && SwapMte.smte_pathlen > 0)
998 {
999 uint32_t cbToRead = RT_MIN(SwapMte.smte_path, sizeof(szModPath) - 1);
1000 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SwapMte.smte_path),
1001 szModPath, cbToRead);
1002 szModPath[cbToRead] = '\0';
1003 }
1004 if (RT_FAILURE(rc))
1005 {
1006 memcpy(szModPath, Mte.mte_modname, sizeof(Mte.mte_modname));
1007 szModPath[sizeof(Mte.mte_modname)] = '\0';
1008 RTStrStripR(szModPath);
1009 }
1010 LogRel(("DbgDiggerOS2: szModPath='%s'\n", szModPath));
1011
1012 /*
1013 * Sanitize the module name.
1014 */
1015 char szModName[16];
1016 memcpy(szModName, Mte.mte_modname, sizeof(Mte.mte_modname));
1017 szModName[sizeof(Mte.mte_modname)] = '\0';
1018 RTStrStripR(szModName);
1019
1020 /*
1021 * Read the object table into the buffer.
1022 */
1023 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SwapMte.smte_objtab),
1024 &pBuf->aOtes[0], sizeof(pBuf->aOtes[0]) * SwapMte.smte_objcnt);
1025 if (RT_FAILURE(rc))
1026 {
1027 LogRel(("DbgDiggerOs2: Error reading object table @ %#RX32 LB %#zx: %Rrc\n",
1028 SwapMte.smte_objtab, sizeof(pBuf->aOtes[0]) * SwapMte.smte_objcnt, rc));
1029 return;
1030 }
1031 for (uint32_t i = 0; i < SwapMte.smte_objcnt; i++)
1032 {
1033 LogRel(("DbgDiggerOs2: seg%u: %RX32 LB %#x\n", i, pBuf->aOtes[i].ote_base, pBuf->aOtes[i].ote_size));
1034 /** @todo validate it. */
1035 }
1036
1037 /*
1038 * If it is the kernel, take down the general address range so we can easily search
1039 * it all in one go when looking for panic messages and such.
1040 */
1041 if (Mte.mte_flags1 & MTE1_DOSMOD)
1042 {
1043 uint32_t uMax = 0;
1044 uint32_t uMin = UINT32_MAX;
1045 for (uint32_t i = 0; i < SwapMte.smte_objcnt; i++)
1046 if (pBuf->aOtes[i].ote_base > _512M)
1047 {
1048 if (pBuf->aOtes[i].ote_base < uMin)
1049 uMin = pBuf->aOtes[i].ote_base;
1050 uint32_t uTmp = pBuf->aOtes[i].ote_base + pBuf->aOtes[i].ote_size;
1051 if (uTmp > uMax)
1052 uMax = uTmp;
1053 }
1054 if (uMax != 0)
1055 {
1056 pThis->uKernelAddr = uMin;
1057 pThis->cbKernel = uMax - uMin;
1058 LogRel(("DbgDiggerOs2: High kernel range: %#RX32 LB %#RX32 (%#RX32)\n", uMin, pThis->cbKernel, uMax));
1059 }
1060 }
1061
1062 /*
1063 * No need to continue without an address space (shouldn't happen).
1064 */
1065 if (hAs == NIL_RTDBGAS)
1066 return;
1067
1068 /*
1069 * Try find a debug file for this module.
1070 */
1071 RTDBGMOD hDbgMod = NIL_RTDBGMOD;
1072 if (hDbgCfg != NIL_RTDBGCFG)
1073 {
1074 DBGDIGGEROS2OPEN Args = { szModPath, szModName, &Mte, &SwapMte };
1075 RTDbgCfgOpenEx(hDbgCfg, szModPath, pszCacheSubDir, NULL,
1076 RT_OPSYS_OS2 | RTDBGCFG_O_CASE_INSENSITIVE | RTDBGCFG_O_EXECUTABLE_IMAGE
1077 | RTDBGCFG_O_RECURSIVE | RTDBGCFG_O_NO_SYSTEM_PATHS,
1078 dbgdiggerOs2OpenModule, &Args, &hDbgMod);
1079 }
1080
1081 /*
1082 * Fallback is a simple module into which we insert sections.
1083 */
1084 uint32_t cSegments = SwapMte.smte_objcnt;
1085 if (hDbgMod == NIL_RTDBGMOD)
1086 {
1087 rc = RTDbgModCreate(&hDbgMod, szModName, 0 /*cbSeg*/, 0 /*fFlags*/);
1088 if (RT_SUCCESS(rc))
1089 {
1090 uint32_t uRva = 0;
1091 for (uint32_t i = 0; i < SwapMte.smte_objcnt; i++)
1092 {
1093 char szSegNm[16];
1094 RTStrPrintf(szSegNm, sizeof(szSegNm), "seg%u", i);
1095 rc = RTDbgModSegmentAdd(hDbgMod, uRva, pBuf->aOtes[i].ote_size, szSegNm, 0 /*fFlags*/, NULL);
1096 if (RT_FAILURE(rc))
1097 {
1098 LogRel(("DbgDiggerOs2: RTDbgModSegmentAdd failed (i=%u, ote_size=%#x): %Rrc\n",
1099 i, pBuf->aOtes[i].ote_size, rc));
1100 cSegments = i;
1101 break;
1102 }
1103 uRva += RT_ALIGN_32(pBuf->aOtes[i].ote_size, _4K);
1104 }
1105 }
1106 else
1107 {
1108 LogRel(("DbgDiggerOs2: RTDbgModCreate failed: %Rrc\n", rc));
1109 return;
1110 }
1111 }
1112
1113 /*
1114 * Tag the module and link its segments.
1115 */
1116 rc = RTDbgModSetTag(hDbgMod, DIG_OS2_MOD_TAG);
1117 if (RT_SUCCESS(rc))
1118 {
1119 for (uint32_t i = 0; i < cSegments; i++)
1120 if (pBuf->aOtes[i].ote_base != 0)
1121 {
1122 rc = RTDbgAsModuleLinkSeg(hAs, hDbgMod, i, pBuf->aOtes[i].ote_base, RTDBGASLINK_FLAGS_REPLACE /*fFlags*/);
1123 if (RT_FAILURE(rc))
1124 LogRel(("DbgDiggerOs2: RTDbgAsModuleLinkSeg failed (i=%u, ote_base=%#x): %Rrc\n",
1125 i, pBuf->aOtes[i].ote_base, rc));
1126 }
1127 }
1128 else
1129 LogRel(("DbgDiggerOs2: RTDbgModSetTag failed: %Rrc\n", rc));
1130 RTDbgModRelease(hDbgMod);
1131}
1132
1133
1134/**
1135 * @copydoc DBGFOSREG::pfnInit
1136 */
1137static DECLCALLBACK(int) dbgDiggerOS2Init(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1138{
1139 PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
1140 Assert(!pThis->fValid);
1141
1142 DBGDIGGEROS2BUF uBuf;
1143 DBGFADDRESS Addr;
1144 int rc;
1145
1146 /*
1147 * Determine the OS/2 version.
1148 */
1149 /* Version info is at GIS:15h (major/minor/revision). */
1150 rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, pThis->selGis, 0x15);
1151 if (RT_FAILURE(rc))
1152 return VERR_NOT_SUPPORTED;
1153 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, uBuf.au32, sizeof(uint32_t));
1154 if (RT_FAILURE(rc))
1155 return VERR_NOT_SUPPORTED;
1156
1157 pThis->OS2MajorVersion = uBuf.au8[0];
1158 pThis->OS2MinorVersion = uBuf.au8[1];
1159
1160 pThis->fValid = true;
1161
1162 /*
1163 * Try use SAS to find the module list.
1164 */
1165 rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, 0x00);
1166 if (RT_SUCCESS(rc))
1167 {
1168 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.sas, sizeof(uBuf.sas));
1169 if (RT_SUCCESS(rc))
1170 {
1171 rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, uBuf.sas.SAS_vm_data);
1172 if (RT_SUCCESS(rc))
1173 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.sasvm, sizeof(uBuf.sasvm));
1174 if (RT_SUCCESS(rc))
1175 {
1176 /*
1177 * Work the module list.
1178 */
1179 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.sasvm.SAS_vm_all_mte),
1180 &uBuf.au32[0], sizeof(uBuf.au32[0]));
1181 if (RT_SUCCESS(rc))
1182 {
1183 uint32_t uOs2Krnl = UINT32_MAX;
1184 RTDBGCFG hDbgCfg = pVMM->pfnDBGFR3AsGetConfig(pUVM); /* (don't release this) */
1185 RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_GLOBAL);
1186
1187 char szCacheSubDir[24];
1188 RTStrPrintf(szCacheSubDir, sizeof(szCacheSubDir), "os2-%u.%u", pThis->OS2MajorVersion, pThis->OS2MinorVersion);
1189
1190 pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.au32[0]);
1191 while (Addr.FlatPtr != 0 && Addr.FlatPtr != UINT32_MAX)
1192 {
1193 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.mte, sizeof(uBuf.mte));
1194 if (RT_FAILURE(rc))
1195 break;
1196 dbgdiggerOS2FixupMTE(pUVM, pVMM, pThis, &uBuf);
1197 LogRel(("DbgDiggerOs2: Module @ %#010RX32: %.8s %#x %#x\n", (uint32_t)Addr.FlatPtr,
1198 uBuf.mte.mte_modname, uBuf.mte.mte_flags1, uBuf.mte.mte_flags2));
1199 if (uBuf.mte.mte_flags1 & MTE1_DOSMOD)
1200 uOs2Krnl = (uint32_t)Addr.FlatPtr;
1201
1202 pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.mte.mte_link);
1203 dbgdiggerOS2ProcessModule(pUVM, pVMM, pThis, &uBuf, szCacheSubDir, hAs, hDbgCfg);
1204 }
1205
1206 /* Load the kernel again. To make sure we didn't drop any segments due
1207 to overlap/conflicts/whatever. */
1208 if (uOs2Krnl != UINT32_MAX)
1209 {
1210 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uOs2Krnl),
1211 &uBuf.mte, sizeof(uBuf.mte));
1212 if (RT_SUCCESS(rc))
1213 {
1214 dbgdiggerOS2FixupMTE(pUVM, pVMM, pThis, &uBuf);
1215 LogRel(("DbgDiggerOs2: Module @ %#010RX32: %.8s %#x %#x [again]\n", (uint32_t)Addr.FlatPtr,
1216 uBuf.mte.mte_modname, uBuf.mte.mte_flags1, uBuf.mte.mte_flags2));
1217 dbgdiggerOS2ProcessModule(pUVM, pVMM, pThis, &uBuf, szCacheSubDir, hAs, hDbgCfg);
1218 }
1219 }
1220
1221 RTDbgAsRelease(hAs);
1222 }
1223 }
1224 }
1225 }
1226
1227 /*
1228 * Register info handlers.
1229 */
1230 pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "sas", "Dumps the OS/2 system anchor block (SAS).", dbgDiggerOS2InfoSas, pThis);
1231 pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "gis", "Dumps the OS/2 global info segment (GIS).", dbgDiggerOS2InfoGis, pThis);
1232 pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "lis", "Dumps the OS/2 local info segment (current process).", dbgDiggerOS2InfoLis, pThis);
1233 pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "panic", "Dumps the OS/2 system panic message.", dbgDiggerOS2InfoPanic, pThis);
1234
1235 return VINF_SUCCESS;
1236}
1237
1238
1239/**
1240 * @copydoc DBGFOSREG::pfnProbe
1241 */
1242static DECLCALLBACK(bool) dbgDiggerOS2Probe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1243{
1244 PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
1245 DBGFADDRESS Addr;
1246 int rc;
1247 uint16_t offInfo;
1248 union
1249 {
1250 uint8_t au8[8192];
1251 uint16_t au16[8192/2];
1252 uint32_t au32[8192/4];
1253 RTUTF16 wsz[8192/2];
1254 } u;
1255
1256 /*
1257 * If the DWORD at 70:0 is 'SAS ' it's quite unlikely that this wouldn't be OS/2.
1258 * Note: The SAS layout is similar between 16-bit and 32-bit OS/2, but not identical.
1259 * 32-bit OS/2 will have the flat kernel data selector at SAS:06. The selector is 168h
1260 * or similar. For 16-bit OS/2 the field contains a table offset into the SAS which will
1261 * be much smaller. Fun fact: The global infoseg selector in the SAS is bimodal in 16-bit
1262 * OS/2 and will work in real mode as well.
1263 */
1264 do {
1265 rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, 0x00);
1266 if (RT_FAILURE(rc))
1267 break;
1268 rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, u.au32, 256);
1269 if (RT_FAILURE(rc))
1270 break;
1271 if (u.au32[0] != DIG_OS2_SAS_SIG)
1272 break;
1273
1274 /* This sure looks like OS/2, but a bit of paranoia won't hurt. */
1275 if (u.au16[2] >= u.au16[4])
1276 break;
1277
1278 /* If 4th word is bigger than 5th, it's the flat kernel mode selector. */
1279 if (u.au16[3] > u.au16[4])
1280 pThis->f32Bit = true;
1281
1282 /* Offset into info table is either at SAS:14h or SAS:16h. */
1283 if (pThis->f32Bit)
1284 offInfo = u.au16[0x14/2];
1285 else
1286 offInfo = u.au16[0x16/2];
1287
1288 /* The global infoseg selector is the first entry in the info table. */
1289 SASINFO const *pInfo = (SASINFO const *)&u.au8[offInfo];
1290 pThis->selGis = pInfo->SAS_info_global;
1291 pThis->Lis.sel = RT_HI_U16(pInfo->SAS_info_local);
1292 pThis->Lis.off = RT_LO_U16(pInfo->SAS_info_local);
1293 return true;
1294 } while (0);
1295
1296 return false;
1297}
1298
1299
1300/**
1301 * @copydoc DBGFOSREG::pfnDestruct
1302 */
1303static DECLCALLBACK(void) dbgDiggerOS2Destruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1304{
1305 RT_NOREF(pUVM, pVMM, pvData);
1306}
1307
1308
1309/**
1310 * @copydoc DBGFOSREG::pfnConstruct
1311 */
1312static DECLCALLBACK(int) dbgDiggerOS2Construct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
1313{
1314 PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData;
1315 pThis->fValid = false;
1316 pThis->f32Bit = false;
1317 pThis->enmVer = DBGDIGGEROS2VER_UNKNOWN;
1318 pThis->pUVM = pUVM;
1319 pThis->pVMM = pVMM;
1320 return VINF_SUCCESS;
1321}
1322
1323
1324const DBGFOSREG g_DBGDiggerOS2 =
1325{
1326 /* .u32Magic = */ DBGFOSREG_MAGIC,
1327 /* .fFlags = */ 0,
1328 /* .cbData = */ sizeof(DBGDIGGEROS2),
1329 /* .szName = */ "OS/2",
1330 /* .pfnConstruct = */ dbgDiggerOS2Construct,
1331 /* .pfnDestruct = */ dbgDiggerOS2Destruct,
1332 /* .pfnProbe = */ dbgDiggerOS2Probe,
1333 /* .pfnInit = */ dbgDiggerOS2Init,
1334 /* .pfnRefresh = */ dbgDiggerOS2Refresh,
1335 /* .pfnTerm = */ dbgDiggerOS2Term,
1336 /* .pfnQueryVersion = */ dbgDiggerOS2QueryVersion,
1337 /* .pfnQueryInterface = */ dbgDiggerOS2QueryInterface,
1338 /* .pfnStackUnwindAssist = */ dbgDiggerOS2StackUnwindAssist,
1339 /* .u32EndMagic = */ DBGFOSREG_MAGIC
1340};
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette