diff options
Diffstat (limited to 'src/VBox/Debugger/DBGPlugInOS2.cpp')
| -rw-r--r-- | src/VBox/Debugger/DBGPlugInOS2.cpp | 1268 |
1 files changed, 1268 insertions, 0 deletions
diff --git a/src/VBox/Debugger/DBGPlugInOS2.cpp b/src/VBox/Debugger/DBGPlugInOS2.cpp new file mode 100644 index 00000000..576a6fca --- /dev/null +++ b/src/VBox/Debugger/DBGPlugInOS2.cpp @@ -0,0 +1,1268 @@ +/* $Id: DBGPlugInOS2.cpp $ */ +/** @file + * DBGPlugInOS2 - Debugger and Guest OS Digger Plugin For OS/2. + */ + +/* + * Copyright (C) 2009-2022 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_DBGF /// @todo add new log group. +#include "DBGPlugIns.h" +#include <VBox/vmm/vmmr3vtable.h> +#include <VBox/err.h> +#include <VBox/param.h> +#include <iprt/string.h> +#include <iprt/mem.h> +#include <iprt/stream.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ + +typedef enum DBGDIGGEROS2VER +{ + DBGDIGGEROS2VER_UNKNOWN, + DBGDIGGEROS2VER_1_x, + DBGDIGGEROS2VER_2_x, + DBGDIGGEROS2VER_3_0, + DBGDIGGEROS2VER_4_0, + DBGDIGGEROS2VER_4_5 +} DBGDIGGEROS2VER; + +/** + * OS/2 guest OS digger instance data. + */ +typedef struct DBGDIGGEROS2 +{ + /** The user-mode VM handle for use in info handlers. */ + PUVM pUVM; + /** The VMM function table for use in info handlers. */ + PCVMMR3VTABLE pVMM; + + /** Whether the information is valid or not. + * (For fending off illegal interface method calls.) */ + bool fValid; + /** 32-bit (true) or 16-bit (false) */ + bool f32Bit; + + /** The OS/2 guest version. */ + DBGDIGGEROS2VER enmVer; + uint8_t OS2MajorVersion; + uint8_t OS2MinorVersion; + + /** Guest's Global Info Segment selector. */ + uint16_t selGis; + /** The 16:16 address of the LIS. */ + RTFAR32 Lis; + + /** The kernel virtual address (excluding DOSMVDMINSTDATA & DOSSWAPINSTDATA). */ + uint32_t uKernelAddr; + /** The kernel size. */ + uint32_t cbKernel; + +} DBGDIGGEROS2; +/** Pointer to the OS/2 guest OS digger instance data. */ +typedef DBGDIGGEROS2 *PDBGDIGGEROS2; + +/** + * 32-bit OS/2 loader module table entry. + */ +typedef struct LDRMTE +{ + uint16_t mte_flags2; + uint16_t mte_handle; + uint32_t mte_swapmte; /**< Pointer to LDRSMTE. */ + uint32_t mte_link; /**< Pointer to next LDRMTE. */ + uint32_t mte_flags1; + uint32_t mte_impmodcnt; + uint16_t mte_sfn; + uint16_t mte_usecnt; + char mte_modname[8]; + uint32_t mte_RAS; /**< added later */ + uint32_t mte_modver; /**< added even later. */ +} LDRMTE; +/** @name LDRMTE::mte_flag2 values + * @{ */ +#define MTEFORMATMASK UINT16_C(0x0003) +#define MTEFORMATR1 UINT16_C(0x0000) +#define MTEFORMATNE UINT16_C(0x0001) +#define MTEFORMATLX UINT16_C(0x0002) +#define MTEFORMATR2 UINT16_C(0x0003) +#define MTESYSTEMDLL UINT16_C(0x0004) +#define MTELOADORATTACH UINT16_C(0x0008) +#define MTECIRCLEREF UINT16_C(0x0010) +#define MTEFREEFIXUPS UINT16_C(0x0020) /* had different meaning earlier */ +#define MTEPRELOADED UINT16_C(0x0040) +#define MTEGETMTEDONE UINT16_C(0x0080) +#define MTEPACKSEGDONE UINT16_C(0x0100) +#define MTE20LIELIST UINT16_C(0x0200) +#define MTESYSPROCESSED UINT16_C(0x0400) +#define MTEPSDMOD UINT16_C(0x0800) +#define MTEDLLONEXTLST UINT16_C(0x1000) +#define MTEPDUMPCIRCREF UINT16_C(0x2000) +/** @} */ +/** @name LDRMTE::mte_flag1 values + * @{ */ +#define MTE1_NOAUTODS UINT32_C(0x00000000) +#define MTE1_SOLO UINT32_C(0x00000001) +#define MTE1_INSTANCEDS UINT32_C(0x00000002) +#define MTE1_INSTLIBINIT UINT32_C(0x00000004) +#define MTE1_GINISETUP UINT32_C(0x00000008) +#define MTE1_NOINTERNFIXUPS UINT32_C(0x00000010) +#define MTE1_NOEXTERNFIXUPS UINT32_C(0x00000020) +#define MTE1_CLASS_ALL UINT32_C(0x00000000) +#define MTE1_CLASS_PROGRAM UINT32_C(0x00000040) +#define MTE1_CLASS_GLOBAL UINT32_C(0x00000080) +#define MTE1_CLASS_SPECIFIC UINT32_C(0x000000c0) +#define MTE1_CLASS_MASK UINT32_C(0x000000c0) +#define MTE1_MTEPROCESSED UINT32_C(0x00000100) +#define MTE1_USED UINT32_C(0x00000200) +#define MTE1_DOSLIB UINT32_C(0x00000400) +#define MTE1_DOSMOD UINT32_C(0x00000800) /**< The OS/2 kernel (DOSCALLS).*/ +#define MTE1_MEDIAFIXED UINT32_C(0x00001000) +#define MTE1_LDRINVALID UINT32_C(0x00002000) +#define MTE1_PROGRAMMOD UINT32_C(0x00000000) +#define MTE1_DEVDRVMOD UINT32_C(0x00004000) +#define MTE1_LIBRARYMOD UINT32_C(0x00008000) +#define MTE1_VDDMOD UINT32_C(0x00010000) +#define MTE1_MVDMMOD UINT32_C(0x00020000) +#define MTE1_INGRAPH UINT32_C(0x00040000) +#define MTE1_GINIDONE UINT32_C(0x00080000) +#define MTE1_ADDRALLOCED UINT32_C(0x00100000) +#define MTE1_FSDMOD UINT32_C(0x00200000) +#define MTE1_FSHMOD UINT32_C(0x00400000) +#define MTE1_LONGNAMES UINT32_C(0x00800000) +#define MTE1_MEDIACONTIG UINT32_C(0x01000000) +#define MTE1_MEDIA16M UINT32_C(0x02000000) +#define MTE1_SWAPONLOAD UINT32_C(0x04000000) +#define MTE1_PORTHOLE UINT32_C(0x08000000) +#define MTE1_MODPROT UINT32_C(0x10000000) +#define MTE1_NEWMOD UINT32_C(0x20000000) +#define MTE1_DLLTERM UINT32_C(0x40000000) +#define MTE1_SYMLOADED UINT32_C(0x80000000) +/** @} */ + + +/** + * 32-bit OS/2 swappable module table entry. + */ +typedef struct LDRSMTE +{ + uint32_t smte_mpages; /**< 0x00: module page count. */ + uint32_t smte_startobj; /**< 0x04: Entrypoint segment number. */ + uint32_t smte_eip; /**< 0x08: Entrypoint offset value. */ + uint32_t smte_stackobj; /**< 0x0c: Stack segment number. */ + uint32_t smte_esp; /**< 0x10: Stack offset value*/ + uint32_t smte_pageshift; /**< 0x14: Page shift value. */ + uint32_t smte_fixupsize; /**< 0x18: Size of the fixup section. */ + uint32_t smte_objtab; /**< 0x1c: Pointer to LDROTE array. */ + uint32_t smte_objcnt; /**< 0x20: Number of segments. */ + uint32_t smte_objmap; /**< 0x20: Address of the object page map. */ + uint32_t smte_itermap; /**< 0x20: File offset of the iterated data map*/ + uint32_t smte_rsrctab; /**< 0x20: Pointer to resource table? */ + uint32_t smte_rsrccnt; /**< 0x30: Number of resource table entries. */ + uint32_t smte_restab; /**< 0x30: Pointer to the resident name table. */ + uint32_t smte_enttab; /**< 0x30: Possibly entry point table address, if not file offset. */ + uint32_t smte_fpagetab; /**< 0x30 */ + uint32_t smte_frectab; /**< 0x40 */ + uint32_t smte_impmod; /**< 0x44 */ + uint32_t smte_impproc; /**< 0x48 */ + uint32_t smte_datapage; /**< 0x4c */ + uint32_t smte_nrestab; /**< 0x50 */ + uint32_t smte_cbnrestab; /**< 0x54 */ + uint32_t smte_autods; /**< 0x58 */ + uint32_t smte_debuginfo; /**< 0x5c */ + uint32_t smte_debuglen; /**< 0x60 */ + uint32_t smte_heapsize; /**< 0x64 */ + uint32_t smte_path; /**< 0x68 Address of full name string. */ + uint16_t smte_semcount; /**< 0x6c */ + uint16_t smte_semowner; /**< 0x6e */ + uint32_t smte_pfilecache; /**< 0x70: Address of cached data if replace-module is used. */ + uint32_t smte_stacksize; /**< 0x74: Stack size for .exe thread 1. */ + uint16_t smte_alignshift; /**< 0x78: */ + uint16_t smte_NEexpver; /**< 0x7a: */ + uint16_t smte_pathlen; /**< 0x7c: Length of smte_path */ + uint16_t smte_NEexetype; /**< 0x7e: */ + uint16_t smte_csegpack; /**< 0x80: */ + uint8_t smte_major_os; /**< 0x82: added later to lie about OS version */ + uint8_t smte_minor_os; /**< 0x83: added later to lie about OS version */ +} LDRSMTE; +AssertCompileSize(LDRSMTE, 0x84); + +typedef struct LDROTE +{ + uint32_t ote_size; + uint32_t ote_base; + uint32_t ote_flags; + uint32_t ote_pagemap; + uint32_t ote_mapsize; + union + { + uint32_t ote_vddaddr; + uint32_t ote_krnaddr; + struct + { + uint16_t ote_selector; + uint16_t ote_handle; + } s; + }; +} LDROTE; +AssertCompileSize(LDROTE, 24); + + +/** + * 32-bit system anchor block segment header. + */ +typedef struct SAS +{ + uint8_t SAS_signature[4]; + uint16_t SAS_tables_data; /**< Offset to SASTABLES. */ + uint16_t SAS_flat_sel; /**< 32-bit kernel DS (flat). */ + uint16_t SAS_config_data; /**< Offset to SASCONFIG. */ + uint16_t SAS_dd_data; /**< Offset to SASDD. */ + uint16_t SAS_vm_data; /**< Offset to SASVM. */ + uint16_t SAS_task_data; /**< Offset to SASTASK. */ + uint16_t SAS_RAS_data; /**< Offset to SASRAS. */ + uint16_t SAS_file_data; /**< Offset to SASFILE. */ + uint16_t SAS_info_data; /**< Offset to SASINFO. */ + uint16_t SAS_mp_data; /**< Offset to SASMP. SMP only. */ +} SAS; +#define SAS_SIGNATURE "SAS " + +typedef struct SASTABLES +{ + uint16_t SAS_tbl_GDT; + uint16_t SAS_tbl_LDT; + uint16_t SAS_tbl_IDT; + uint16_t SAS_tbl_GDTPOOL; +} SASTABLES; + +typedef struct SASCONFIG +{ + uint16_t SAS_config_table; +} SASCONFIG; + +typedef struct SASDD +{ + uint16_t SAS_dd_bimodal_chain; + uint16_t SAS_dd_real_chain; + uint16_t SAS_dd_DPB_segment; + uint16_t SAS_dd_CDA_anchor_p; + uint16_t SAS_dd_CDA_anchor_r; + uint16_t SAS_dd_FSC; +} SASDD; + +typedef struct SASVM +{ + uint32_t SAS_vm_arena; + uint32_t SAS_vm_object; + uint32_t SAS_vm_context; + uint32_t SAS_vm_krnl_mte; /**< Flat address of kernel MTE. */ + uint32_t SAS_vm_glbl_mte; /**< Flat address of global MTE list head pointer variable. */ + uint32_t SAS_vm_pft; + uint32_t SAS_vm_prt; + uint32_t SAS_vm_swap; + uint32_t SAS_vm_idle_head; + uint32_t SAS_vm_free_head; + uint32_t SAS_vm_heap_info; + uint32_t SAS_vm_all_mte; /**< Flat address of global MTE list head pointer variable. */ +} SASVM; + + +#pragma pack(1) +typedef struct SASTASK +{ + uint16_t SAS_task_PTDA; /**< Current PTDA selector. */ + uint32_t SAS_task_ptdaptrs; /**< Flat address of process tree root. */ + uint32_t SAS_task_threadptrs; /**< Flat address array of thread pointer array. */ + uint32_t SAS_task_tasknumber; /**< Flat address of the TaskNumber variable. */ + uint32_t SAS_task_threadcount; /**< Flat address of the ThreadCount variable. */ +} SASTASK; +#pragma pack() + + +#pragma pack(1) +typedef struct SASRAS +{ + uint16_t SAS_RAS_STDA_p; + uint16_t SAS_RAS_STDA_r; + uint16_t SAS_RAS_event_mask; + uint32_t SAS_RAS_Perf_Buff; +} SASRAS; +#pragma pack() + +typedef struct SASFILE +{ + uint32_t SAS_file_MFT; /**< Handle. */ + uint16_t SAS_file_SFT; /**< Selector. */ + uint16_t SAS_file_VPB; /**< Selector. */ + uint16_t SAS_file_CDS; /**< Selector. */ + uint16_t SAS_file_buffers; /**< Selector. */ +} SASFILE; + +#pragma pack(1) +typedef struct SASINFO +{ + uint16_t SAS_info_global; /**< GIS selector. */ + uint32_t SAS_info_local; /**< 16:16 address of LIS for current task. */ + uint32_t SAS_info_localRM; + uint16_t SAS_info_CDIB; /**< Selector. */ +} SASINFO; +#pragma pack() + +typedef struct SASMP +{ + uint32_t SAS_mp_PCBFirst; /**< Flat address of PCB head. */ + uint32_t SAS_mp_pLockHandles; /**< Flat address of lock handles. */ + uint32_t SAS_mp_cProcessors; /**< Flat address of CPU count variable. */ + uint32_t SAS_mp_pIPCInfo; /**< Flat address of IPC info pointer variable. */ + uint32_t SAS_mp_pIPCHistory; /**< Flat address of IPC history pointer. */ + uint32_t SAS_mp_IPCHistoryIdx; /**< Flat address of IPC history index variable. */ + uint32_t SAS_mp_pFirstPSA; /**< Flat address of PSA. Added later. */ + uint32_t SAS_mp_pPSAPages; /**< Flat address of PSA pages. */ +} SASMP; + + +typedef struct OS2GIS +{ + uint32_t time; + uint32_t msecs; + uint8_t hour; + uint8_t minutes; + uint8_t seconds; + uint8_t hundredths; + int16_t timezone; + uint16_t cusecTimerInterval; + uint8_t day; + uint8_t month; + uint16_t year; + uint8_t weekday; + uint8_t uchMajorVersion; + uint8_t uchMinorVersion; + uint8_t chRevisionLetter; + uint8_t sgCurrent; + uint8_t sgMax; + uint8_t cHugeShift; + uint8_t fProtectModeOnly; + uint16_t pidForeground; + uint8_t fDynamicSched; + uint8_t csecMaxWait; + uint16_t cmsecMinSlice; + uint16_t cmsecMaxSlice; + uint16_t bootdrive; + uint8_t amecRAS[32]; + uint8_t csgWindowableVioMax; + uint8_t csgPMMax; + uint16_t SIS_Syslog; + uint16_t SIS_MMIOBase; + uint16_t SIS_MMIOAddr; + uint8_t SIS_MaxVDMs; + uint8_t SIS_Reserved; +} OS2GIS; + +typedef struct OS2LIS +{ + uint16_t pidCurrent; + uint16_t pidParent; + uint16_t prtyCurrent; + uint16_t tidCurrent; + uint16_t sgCurrent; + uint8_t rfProcStatus; + uint8_t bReserved1; + uint16_t fForeground; + uint8_t typeProcess; + uint8_t bReserved2; + uint16_t selEnvironment; + uint16_t offCmdLine; + uint16_t cbDataSegment; + uint16_t cbStack; + uint16_t cbHeap; + uint16_t hmod; + uint16_t selDS; +} OS2LIS; + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The 'SAS ' signature. */ +#define DIG_OS2_SAS_SIG RT_MAKE_U32_FROM_U8('S','A','S',' ') + +/** OS/2Warp on little endian ASCII systems. */ +#define DIG_OS2_MOD_TAG UINT64_C(0x43532f3257617270) + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static DECLCALLBACK(int) dbgDiggerOS2Init(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData); + + +static int dbgDiggerOS2DisplaySelectorAndInfoEx(PDBGDIGGEROS2 pThis, PCDBGFINFOHLP pHlp, uint16_t uSel, uint32_t off, + int cchWidth, const char *pszMessage, PDBGFSELINFO pSelInfo) +{ + RT_ZERO(*pSelInfo); + int rc = pThis->pVMM->pfnDBGFR3SelQueryInfo(pThis->pUVM, 0 /*idCpu*/, uSel, DBGFSELQI_FLAGS_DT_GUEST, pSelInfo); + if (RT_SUCCESS(rc)) + { + if (off == UINT32_MAX) + pHlp->pfnPrintf(pHlp, "%*s: %#06x (%RGv LB %#RX64 flags=%#x)\n", + cchWidth, pszMessage, uSel, pSelInfo->GCPtrBase, pSelInfo->cbLimit, pSelInfo->fFlags); + else + pHlp->pfnPrintf(pHlp, "%*s: %04x:%04x (%RGv LB %#RX64 flags=%#x)\n", + cchWidth, pszMessage, uSel, off, pSelInfo->GCPtrBase + off, pSelInfo->cbLimit - off, pSelInfo->fFlags); + } + else if (off == UINT32_MAX) + pHlp->pfnPrintf(pHlp, "%*s: %#06x (%Rrc)\n", cchWidth, pszMessage, uSel, rc); + else + pHlp->pfnPrintf(pHlp, "%*s: %04x:%04x (%Rrc)\n", cchWidth, pszMessage, uSel, off, rc); + return rc; +} + +DECLINLINE(int) dbgDiggerOS2DisplaySelectorAndInfo(PDBGDIGGEROS2 pThis, PCDBGFINFOHLP pHlp, uint16_t uSel, uint32_t off, + int cchWidth, const char *pszMessage) +{ + DBGFSELINFO SelInfo; + return dbgDiggerOS2DisplaySelectorAndInfoEx(pThis, pHlp, uSel, off, cchWidth, pszMessage, &SelInfo); +} + + +/** + * @callback_method_impl{FNDBGFHANDLEREXT, + * Display the OS/2 system anchor segment} + */ +static DECLCALLBACK(void) dbgDiggerOS2InfoSas(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs) +{ + RT_NOREF(pszArgs); + PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser; + PUVM const pUVM = pThis->pUVM; + PCVMMR3VTABLE const pVMM = pThis->pVMM; + + DBGFSELINFO SelInfo; + int rc = pVMM->pfnDBGFR3SelQueryInfo(pUVM, 0 /*idCpu*/, 0x70, DBGFSELQI_FLAGS_DT_GUEST, &SelInfo); + if (RT_FAILURE(rc)) + { + pHlp->pfnPrintf(pHlp, "DBGFR3SelQueryInfo failed on selector 0x70: %Rrc\n", rc); + return; + } + pHlp->pfnPrintf(pHlp, "Selector 0x70: %RGv LB %#RX64 (flags %#x)\n", + SelInfo.GCPtrBase, (uint64_t)SelInfo.cbLimit, SelInfo.fFlags); + + /* + * The SAS header. + */ + union + { + SAS Sas; + uint16_t au16Sas[sizeof(SAS) / sizeof(uint16_t)]; + }; + DBGFADDRESS Addr; + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase), + &Sas, sizeof(Sas)); + if (RT_FAILURE(rc)) + { + pHlp->pfnPrintf(pHlp, "Failed to read SAS header: %Rrc\n", rc); + return; + } + if (memcmp(&Sas.SAS_signature[0], SAS_SIGNATURE, sizeof(Sas.SAS_signature)) != 0) + { + pHlp->pfnPrintf(pHlp, "Invalid SAS signature: %#x %#x %#x %#x (expected %#x %#x %#x %#x)\n", + Sas.SAS_signature[0], Sas.SAS_signature[1], Sas.SAS_signature[2], Sas.SAS_signature[3], + SAS_SIGNATURE[0], SAS_SIGNATURE[1], SAS_SIGNATURE[2], SAS_SIGNATURE[3]); + return; + } + dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, Sas.SAS_flat_sel, UINT32_MAX, 15, "Flat kernel DS"); + pHlp->pfnPrintf(pHlp, "SAS_tables_data: %#06x (%#RGv)\n", Sas.SAS_tables_data, SelInfo.GCPtrBase + Sas.SAS_tables_data); + pHlp->pfnPrintf(pHlp, "SAS_config_data: %#06x (%#RGv)\n", Sas.SAS_config_data, SelInfo.GCPtrBase + Sas.SAS_config_data); + pHlp->pfnPrintf(pHlp, " SAS_dd_data: %#06x (%#RGv)\n", Sas.SAS_dd_data, SelInfo.GCPtrBase + Sas.SAS_dd_data); + pHlp->pfnPrintf(pHlp, " SAS_vm_data: %#06x (%#RGv)\n", Sas.SAS_vm_data, SelInfo.GCPtrBase + Sas.SAS_vm_data); + pHlp->pfnPrintf(pHlp, " SAS_task_data: %#06x (%#RGv)\n", Sas.SAS_task_data, SelInfo.GCPtrBase + Sas.SAS_task_data); + pHlp->pfnPrintf(pHlp, " SAS_RAS_data: %#06x (%#RGv)\n", Sas.SAS_RAS_data, SelInfo.GCPtrBase + Sas.SAS_RAS_data); + pHlp->pfnPrintf(pHlp, " SAS_file_data: %#06x (%#RGv)\n", Sas.SAS_file_data, SelInfo.GCPtrBase + Sas.SAS_file_data); + pHlp->pfnPrintf(pHlp, " SAS_info_data: %#06x (%#RGv)\n", Sas.SAS_info_data, SelInfo.GCPtrBase + Sas.SAS_info_data); + bool fIncludeMP = true; + if (Sas.SAS_mp_data < sizeof(Sas)) + fIncludeMP = false; + else + for (unsigned i = 2; i < RT_ELEMENTS(au16Sas) - 1; i++) + if (au16Sas[i] < sizeof(SAS)) + { + fIncludeMP = false; + break; + } + if (fIncludeMP) + pHlp->pfnPrintf(pHlp, " SAS_mp_data: %#06x (%#RGv)\n", Sas.SAS_mp_data, SelInfo.GCPtrBase + Sas.SAS_mp_data); + + /* shared databuf */ + union + { + SASINFO Info; + } u; + + /* + * Info data. + */ + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, + pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase + Sas.SAS_info_data), + &u.Info, sizeof(u.Info)); + if (RT_SUCCESS(rc)) + { + pHlp->pfnPrintf(pHlp, "SASINFO:\n"); + dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, u.Info.SAS_info_global, UINT32_MAX, 28, "Global info segment"); + pHlp->pfnPrintf(pHlp, "%28s: %#010x\n", "Local info segment", u.Info.SAS_info_local); + pHlp->pfnPrintf(pHlp, "%28s: %#010x\n", "Local info segment (RM)", u.Info.SAS_info_localRM); + dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, u.Info.SAS_info_CDIB, UINT32_MAX, 28, "SAS_info_CDIB"); + } + else + pHlp->pfnPrintf(pHlp, "Failed to read SAS info data: %Rrc\n", rc); + + /** @todo more */ +} + + +/** + * @callback_method_impl{FNDBGFHANDLEREXT, + * Display the OS/2 global info segment} + */ +static DECLCALLBACK(void) dbgDiggerOS2InfoGis(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs) +{ + RT_NOREF(pszArgs); + PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser; + PUVM const pUVM = pThis->pUVM; + PCVMMR3VTABLE const pVMM = pThis->pVMM; + + DBGFSELINFO SelInfo; + int rc = dbgDiggerOS2DisplaySelectorAndInfoEx(pThis, pHlp, pThis->selGis, UINT32_MAX, 0, "Global info segment", &SelInfo); + if (RT_FAILURE(rc)) + return; + + /* + * Read the GIS. + */ + DBGFADDRESS Addr; + OS2GIS Gis; + RT_ZERO(Gis); + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase), &Gis, + RT_MIN(sizeof(Gis), SelInfo.cbLimit + 1)); + if (RT_FAILURE(rc)) + { + pHlp->pfnPrintf(pHlp, "Failed to read GIS: %Rrc\n", rc); + return; + } + pHlp->pfnPrintf(pHlp, " time: %#010x\n", Gis.time); + pHlp->pfnPrintf(pHlp, " msecs: %#010x\n", Gis.msecs); + pHlp->pfnPrintf(pHlp, " timestamp: %04u-%02u-%02u %02u:%02u:%02u.%02u\n", + Gis.year, Gis.month, Gis.day, Gis.hour, Gis.minutes, Gis.seconds, Gis.hundredths); + pHlp->pfnPrintf(pHlp, " timezone: %+2d (min delta)\n", (int)Gis.timezone); + pHlp->pfnPrintf(pHlp, " weekday: %u\n", Gis.weekday); + pHlp->pfnPrintf(pHlp, " cusecTimerInterval: %u\n", Gis.cusecTimerInterval); + pHlp->pfnPrintf(pHlp, " version: %u.%u\n", Gis.uchMajorVersion, Gis.uchMinorVersion); + pHlp->pfnPrintf(pHlp, " revision: %#04x (%c)\n", Gis.chRevisionLetter, Gis.chRevisionLetter); + pHlp->pfnPrintf(pHlp, " current screen grp: %#04x (%u)\n", Gis.sgCurrent, Gis.sgCurrent); + pHlp->pfnPrintf(pHlp, " max screen groups: %#04x (%u)\n", Gis.sgMax, Gis.sgMax); + pHlp->pfnPrintf(pHlp, "csgWindowableVioMax: %#x (%u)\n", Gis.csgWindowableVioMax, Gis.csgWindowableVioMax); + pHlp->pfnPrintf(pHlp, " csgPMMax: %#x (%u)\n", Gis.csgPMMax, Gis.csgPMMax); + pHlp->pfnPrintf(pHlp, " cHugeShift: %#04x\n", Gis.cHugeShift); + pHlp->pfnPrintf(pHlp, " fProtectModeOnly: %d\n", Gis.fProtectModeOnly); + pHlp->pfnPrintf(pHlp, " pidForeground: %#04x (%u)\n", Gis.pidForeground, Gis.pidForeground); + pHlp->pfnPrintf(pHlp, " fDynamicSched: %u\n", Gis.fDynamicSched); + pHlp->pfnPrintf(pHlp, " csecMaxWait: %u\n", Gis.csecMaxWait); + pHlp->pfnPrintf(pHlp, " cmsecMinSlice: %u\n", Gis.cmsecMinSlice); + pHlp->pfnPrintf(pHlp, " cmsecMaxSlice: %u\n", Gis.cmsecMaxSlice); + pHlp->pfnPrintf(pHlp, " bootdrive: %#x\n", Gis.bootdrive); + pHlp->pfnPrintf(pHlp, " amecRAS: %.32Rhxs\n", &Gis.amecRAS[0]); + pHlp->pfnPrintf(pHlp, " SIS_Syslog: %#06x (%u)\n", Gis.SIS_Syslog, Gis.SIS_Syslog); + pHlp->pfnPrintf(pHlp, " SIS_MMIOBase: %#06x\n", Gis.SIS_MMIOBase); + pHlp->pfnPrintf(pHlp, " SIS_MMIOAddr: %#06x\n", Gis.SIS_MMIOAddr); + pHlp->pfnPrintf(pHlp, " SIS_MaxVDMs: %#04x (%u)\n", Gis.SIS_MaxVDMs, Gis.SIS_MaxVDMs); + pHlp->pfnPrintf(pHlp, " SIS_Reserved: %#04x\n", Gis.SIS_Reserved); +} + + +/** + * @callback_method_impl{FNDBGFHANDLEREXT, + * Display the OS/2 local info segment} + */ +static DECLCALLBACK(void) dbgDiggerOS2InfoLis(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs) +{ + RT_NOREF(pszArgs); + PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser; + PUVM const pUVM = pThis->pUVM; + PCVMMR3VTABLE const pVMM = pThis->pVMM; + + DBGFSELINFO SelInfo; + int rc = dbgDiggerOS2DisplaySelectorAndInfoEx(pThis, pHlp, pThis->Lis.sel, pThis->Lis.off, 19, "Local info segment", &SelInfo); + if (RT_FAILURE(rc)) + return; + + /* + * Read the LIS. + */ + DBGFADDRESS Addr; + OS2LIS Lis; + RT_ZERO(Lis); + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SelInfo.GCPtrBase + pThis->Lis.off), + &Lis, sizeof(Lis)); + if (RT_FAILURE(rc)) + { + pHlp->pfnPrintf(pHlp, "Failed to read LIS: %Rrc\n", rc); + return; + } + pHlp->pfnPrintf(pHlp, " pidCurrent: %#06x (%u)\n", Lis.pidCurrent, Lis.pidCurrent); + pHlp->pfnPrintf(pHlp, " pidParent: %#06x (%u)\n", Lis.pidParent, Lis.pidParent); + pHlp->pfnPrintf(pHlp, " prtyCurrent: %#06x (%u)\n", Lis.prtyCurrent, Lis.prtyCurrent); + pHlp->pfnPrintf(pHlp, " tidCurrent: %#06x (%u)\n", Lis.tidCurrent, Lis.tidCurrent); + pHlp->pfnPrintf(pHlp, " sgCurrent: %#06x (%u)\n", Lis.sgCurrent, Lis.sgCurrent); + pHlp->pfnPrintf(pHlp, " rfProcStatus: %#04x\n", Lis.rfProcStatus); + if (Lis.bReserved1) + pHlp->pfnPrintf(pHlp, " bReserved1: %#04x\n", Lis.bReserved1); + pHlp->pfnPrintf(pHlp, " fForeground: %#04x (%u)\n", Lis.fForeground, Lis.fForeground); + pHlp->pfnPrintf(pHlp, " typeProcess: %#04x (%u)\n", Lis.typeProcess, Lis.typeProcess); + if (Lis.bReserved2) + pHlp->pfnPrintf(pHlp, " bReserved2: %#04x\n", Lis.bReserved2); + dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, Lis.selEnvironment, UINT32_MAX, 19, "selEnvironment"); + pHlp->pfnPrintf(pHlp, " offCmdLine: %#06x (%u)\n", Lis.offCmdLine, Lis.offCmdLine); + pHlp->pfnPrintf(pHlp, " cbDataSegment: %#06x (%u)\n", Lis.cbDataSegment, Lis.cbDataSegment); + pHlp->pfnPrintf(pHlp, " cbStack: %#06x (%u)\n", Lis.cbStack, Lis.cbStack); + pHlp->pfnPrintf(pHlp, " cbHeap: %#06x (%u)\n", Lis.cbHeap, Lis.cbHeap); + pHlp->pfnPrintf(pHlp, " hmod: %#06x\n", Lis.hmod); /** @todo look up the name*/ + dbgDiggerOS2DisplaySelectorAndInfo(pThis, pHlp, Lis.selDS, UINT32_MAX, 19, "selDS"); +} + + +/** + * @callback_method_impl{FNDBGFHANDLEREXT, + * Display the OS/2 panic message} + */ +static DECLCALLBACK(void) dbgDiggerOS2InfoPanic(void *pvUser, PCDBGFINFOHLP pHlp, const char *pszArgs) +{ + RT_NOREF(pszArgs); + PDBGDIGGEROS2 const pThis = (PDBGDIGGEROS2)pvUser; + PUVM const pUVM = pThis->pUVM; + PCVMMR3VTABLE const pVMM = pThis->pVMM; + + DBGFADDRESS HitAddr; + int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &HitAddr, pThis->uKernelAddr), + pThis->cbKernel, 1, RT_STR_TUPLE("Exception in module:"), &HitAddr); + if (RT_FAILURE(rc)) + rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu&*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &HitAddr, pThis->uKernelAddr), + pThis->cbKernel, 1, RT_STR_TUPLE("Exception in device driver:"), &HitAddr); + /** @todo support pre-2001 kernels w/o the module/drivce name. */ + if (RT_SUCCESS(rc)) + { + char szMsg[728 + 1]; + RT_ZERO(szMsg); + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0, &HitAddr, szMsg, sizeof(szMsg) - 1); + if (szMsg[0] != '\0') + { + RTStrPurgeEncoding(szMsg); + char *psz = szMsg; + while (*psz != '\0') + { + char *pszEol = strchr(psz, '\r'); + if (pszEol) + *pszEol = '\0'; + pHlp->pfnPrintf(pHlp, "%s\n", psz); + if (!pszEol) + break; + psz = ++pszEol; + if (*psz == '\n') + psz++; + } + } + else + pHlp->pfnPrintf(pHlp, "DBGFR3MemRead -> %Rrc\n", rc); + } + else + pHlp->pfnPrintf(pHlp, "Unable to locate OS/2 panic message. (%Rrc)\n", rc); +} + + + +/** + * @copydoc DBGFOSREG::pfnStackUnwindAssist + */ +static DECLCALLBACK(int) dbgDiggerOS2StackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu, + PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, + RTDBGAS hAs, uint64_t *puScratch) +{ + RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch); + return VINF_SUCCESS; +} + + +/** + * @copydoc DBGFOSREG::pfnQueryInterface + */ +static DECLCALLBACK(void *) dbgDiggerOS2QueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf) +{ + RT_NOREF(pUVM, pVMM, pvData, enmIf); + return NULL; +} + + +/** + * @copydoc DBGFOSREG::pfnQueryVersion + */ +static DECLCALLBACK(int) dbgDiggerOS2QueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, + char *pszVersion, size_t cchVersion) +{ + PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData; + RT_NOREF(pUVM, pVMM); + Assert(pThis->fValid); + + char *achOS2ProductType[32]; + char *pszOS2ProductType = (char *)achOS2ProductType; + + if (pThis->OS2MajorVersion == 10) + { + RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 1.%02d", pThis->OS2MinorVersion); + pThis->enmVer = DBGDIGGEROS2VER_1_x; + } + else if (pThis->OS2MajorVersion == 20) + { + if (pThis->OS2MinorVersion < 30) + { + RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 2.%02d", pThis->OS2MinorVersion); + pThis->enmVer = DBGDIGGEROS2VER_2_x; + } + else if (pThis->OS2MinorVersion < 40) + { + RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 Warp"); + pThis->enmVer = DBGDIGGEROS2VER_3_0; + } + else if (pThis->OS2MinorVersion == 40) + { + RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 Warp 4"); + pThis->enmVer = DBGDIGGEROS2VER_4_0; + } + else + { + RTStrPrintf(pszOS2ProductType, sizeof(achOS2ProductType), "OS/2 Warp %d.%d", + pThis->OS2MinorVersion / 10, pThis->OS2MinorVersion % 10); + pThis->enmVer = DBGDIGGEROS2VER_4_5; + } + } + RTStrPrintf(pszVersion, cchVersion, "%u.%u (%s)", pThis->OS2MajorVersion, pThis->OS2MinorVersion, pszOS2ProductType); + return VINF_SUCCESS; +} + + +/** + * @copydoc DBGFOSREG::pfnTerm + */ +static DECLCALLBACK(void) dbgDiggerOS2Term(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData) +{ + PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData; + Assert(pThis->fValid); + + pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "sas"); + pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "gis"); + pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "lis"); + pVMM->pfnDBGFR3InfoDeregisterExternal(pUVM, "panic"); + + pThis->fValid = false; +} + + +/** + * @copydoc DBGFOSREG::pfnRefresh + */ +static DECLCALLBACK(int) dbgDiggerOS2Refresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData) +{ + PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData; + NOREF(pThis); + Assert(pThis->fValid); + + /* + * For now we'll flush and reload everything. + */ + RTDBGAS hDbgAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL); + if (hDbgAs != NIL_RTDBGAS) + { + uint32_t iMod = RTDbgAsModuleCount(hDbgAs); + while (iMod-- > 0) + { + RTDBGMOD hMod = RTDbgAsModuleByIndex(hDbgAs, iMod); + if (hMod != NIL_RTDBGMOD) + { + if (RTDbgModGetTag(hMod) == DIG_OS2_MOD_TAG) + { + int rc = RTDbgAsModuleUnlink(hDbgAs, hMod); + AssertRC(rc); + } + RTDbgModRelease(hMod); + } + } + RTDbgAsRelease(hDbgAs); + } + + dbgDiggerOS2Term(pUVM, pVMM, pvData); + return dbgDiggerOS2Init(pUVM, pVMM, pvData); +} + + +/** Buffer shared by dbgdiggerOS2ProcessModule and dbgDiggerOS2Init.*/ +typedef union DBGDIGGEROS2BUF +{ + uint8_t au8[0x2000]; + uint16_t au16[0x2000/2]; + uint32_t au32[0x2000/4]; + RTUTF16 wsz[0x2000/2]; + char ach[0x2000]; + LDROTE aOtes[0x2000 / sizeof(LDROTE)]; + SAS sas; + SASVM sasvm; + LDRMTE mte; + LDRSMTE smte; + LDROTE ote; +} DBGDIGGEROS2BUF; + +/** Arguments dbgdiggerOS2ProcessModule passes to the module open callback. */ +typedef struct +{ + const char *pszModPath; + const char *pszModName; + LDRMTE const *pMte; + LDRSMTE const *pSwapMte; +} DBGDIGGEROS2OPEN; + + +/** + * @callback_method_impl{FNRTDBGCFGOPEN, Debug image/image searching callback.} + */ +static DECLCALLBACK(int) dbgdiggerOs2OpenModule(RTDBGCFG hDbgCfg, const char *pszFilename, void *pvUser1, void *pvUser2) +{ + DBGDIGGEROS2OPEN *pArgs = (DBGDIGGEROS2OPEN *)pvUser1; + + RTDBGMOD hDbgMod = NIL_RTDBGMOD; + int rc = RTDbgModCreateFromImage(&hDbgMod, pszFilename, pArgs->pszModName, RTLDRARCH_WHATEVER, hDbgCfg); + if (RT_SUCCESS(rc)) + { + /** @todo Do some info matching before using it? */ + + *(PRTDBGMOD)pvUser2 = hDbgMod; + return VINF_CALLBACK_RETURN; + } + LogRel(("DbgDiggerOs2: dbgdiggerOs2OpenModule: %Rrc - %s\n", rc, pszFilename)); + return rc; +} + + +static void dbgdiggerOS2ProcessModule(PUVM pUVM, PCVMMR3VTABLE pVMM, PDBGDIGGEROS2 pThis, DBGDIGGEROS2BUF *pBuf, + const char *pszCacheSubDir, RTDBGAS hAs, RTDBGCFG hDbgCfg) +{ + RT_NOREF(pThis); + + /* + * Save the MTE. + */ + static const char * const s_apszMteFmts[4] = { "Reserved1", "NE", "LX", "Reserved2" }; + LDRMTE const Mte = pBuf->mte; + if ((Mte.mte_flags2 & MTEFORMATMASK) != MTEFORMATLX) + { + LogRel(("DbgDiggerOs2: MTE format not implemented: %s (%d)\n", + s_apszMteFmts[(Mte.mte_flags2 & MTEFORMATMASK)], Mte.mte_flags2 & MTEFORMATMASK)); + return; + } + + /* + * Don't load program modules into the global address spaces. + */ + if ((Mte.mte_flags1 & MTE1_CLASS_MASK) == MTE1_CLASS_PROGRAM) + { + LogRel(("DbgDiggerOs2: Program module, skipping.\n")); + return; + } + + /* + * Try read the swappable MTE. Save it too. + */ + DBGFADDRESS Addr; + int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, Mte.mte_swapmte), + &pBuf->smte, sizeof(pBuf->smte)); + if (RT_FAILURE(rc)) + { + LogRel(("DbgDiggerOs2: Error reading swap mte @ %RX32: %Rrc\n", Mte.mte_swapmte, rc)); + return; + } + LDRSMTE const SwapMte = pBuf->smte; + + /* Ignore empty modules or modules with too many segments. */ + if (SwapMte.smte_objcnt == 0 || SwapMte.smte_objcnt > RT_ELEMENTS(pBuf->aOtes)) + { + LogRel(("DbgDiggerOs2: Skipping: smte_objcnt= %#RX32\n", SwapMte.smte_objcnt)); + return; + } + + /* + * Try read the path name, falling back on module name. + */ + char szModPath[260]; + rc = VERR_READ_ERROR; + if (SwapMte.smte_path != 0 && SwapMte.smte_pathlen > 0) + { + uint32_t cbToRead = RT_MIN(SwapMte.smte_path, sizeof(szModPath) - 1); + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SwapMte.smte_path), + szModPath, cbToRead); + szModPath[cbToRead] = '\0'; + } + if (RT_FAILURE(rc)) + { + memcpy(szModPath, Mte.mte_modname, sizeof(Mte.mte_modname)); + szModPath[sizeof(Mte.mte_modname)] = '\0'; + RTStrStripR(szModPath); + } + LogRel(("DbgDiggerOS2: szModPath='%s'\n", szModPath)); + + /* + * Sanitize the module name. + */ + char szModName[16]; + memcpy(szModName, Mte.mte_modname, sizeof(Mte.mte_modname)); + szModName[sizeof(Mte.mte_modname)] = '\0'; + RTStrStripR(szModName); + + /* + * Read the object table into the buffer. + */ + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SwapMte.smte_objtab), + &pBuf->aOtes[0], sizeof(pBuf->aOtes[0]) * SwapMte.smte_objcnt); + if (RT_FAILURE(rc)) + { + LogRel(("DbgDiggerOs2: Error reading object table @ %#RX32 LB %#zx: %Rrc\n", + SwapMte.smte_objtab, sizeof(pBuf->aOtes[0]) * SwapMte.smte_objcnt, rc)); + return; + } + for (uint32_t i = 0; i < SwapMte.smte_objcnt; i++) + { + LogRel(("DbgDiggerOs2: seg%u: %RX32 LB %#x\n", i, pBuf->aOtes[i].ote_base, pBuf->aOtes[i].ote_size)); + /** @todo validate it. */ + } + + /* + * If it is the kernel, take down the general address range so we can easily search + * it all in one go when looking for panic messages and such. + */ + if (Mte.mte_flags1 & MTE1_DOSMOD) + { + uint32_t uMax = 0; + uint32_t uMin = UINT32_MAX; + for (uint32_t i = 0; i < SwapMte.smte_objcnt; i++) + if (pBuf->aOtes[i].ote_base > _512M) + { + if (pBuf->aOtes[i].ote_base < uMin) + uMin = pBuf->aOtes[i].ote_base; + uint32_t uTmp = pBuf->aOtes[i].ote_base + pBuf->aOtes[i].ote_size; + if (uTmp > uMax) + uMax = uTmp; + } + if (uMax != 0) + { + pThis->uKernelAddr = uMin; + pThis->cbKernel = uMax - uMin; + LogRel(("DbgDiggerOs2: High kernel range: %#RX32 LB %#RX32 (%#RX32)\n", uMin, pThis->cbKernel, uMax)); + } + } + + /* + * No need to continue without an address space (shouldn't happen). + */ + if (hAs == NIL_RTDBGAS) + return; + + /* + * Try find a debug file for this module. + */ + RTDBGMOD hDbgMod = NIL_RTDBGMOD; + if (hDbgCfg != NIL_RTDBGCFG) + { + DBGDIGGEROS2OPEN Args = { szModPath, szModName, &Mte, &SwapMte }; + RTDbgCfgOpenEx(hDbgCfg, szModPath, pszCacheSubDir, NULL, + RT_OPSYS_OS2 | RTDBGCFG_O_CASE_INSENSITIVE | RTDBGCFG_O_EXECUTABLE_IMAGE + | RTDBGCFG_O_RECURSIVE | RTDBGCFG_O_NO_SYSTEM_PATHS, + dbgdiggerOs2OpenModule, &Args, &hDbgMod); + } + + /* + * Fallback is a simple module into which we insert sections. + */ + uint32_t cSegments = SwapMte.smte_objcnt; + if (hDbgMod == NIL_RTDBGMOD) + { + rc = RTDbgModCreate(&hDbgMod, szModName, 0 /*cbSeg*/, 0 /*fFlags*/); + if (RT_SUCCESS(rc)) + { + uint32_t uRva = 0; + for (uint32_t i = 0; i < SwapMte.smte_objcnt; i++) + { + char szSegNm[16]; + RTStrPrintf(szSegNm, sizeof(szSegNm), "seg%u", i); + rc = RTDbgModSegmentAdd(hDbgMod, uRva, pBuf->aOtes[i].ote_size, szSegNm, 0 /*fFlags*/, NULL); + if (RT_FAILURE(rc)) + { + LogRel(("DbgDiggerOs2: RTDbgModSegmentAdd failed (i=%u, ote_size=%#x): %Rrc\n", + i, pBuf->aOtes[i].ote_size, rc)); + cSegments = i; + break; + } + uRva += RT_ALIGN_32(pBuf->aOtes[i].ote_size, _4K); + } + } + else + { + LogRel(("DbgDiggerOs2: RTDbgModCreate failed: %Rrc\n", rc)); + return; + } + } + + /* + * Tag the module and link its segments. + */ + rc = RTDbgModSetTag(hDbgMod, DIG_OS2_MOD_TAG); + if (RT_SUCCESS(rc)) + { + for (uint32_t i = 0; i < SwapMte.smte_objcnt; i++) + if (pBuf->aOtes[i].ote_base != 0) + { + rc = RTDbgAsModuleLinkSeg(hAs, hDbgMod, i, pBuf->aOtes[i].ote_base, RTDBGASLINK_FLAGS_REPLACE /*fFlags*/); + if (RT_FAILURE(rc)) + LogRel(("DbgDiggerOs2: RTDbgAsModuleLinkSeg failed (i=%u, ote_base=%#x): %Rrc\n", + i, pBuf->aOtes[i].ote_base, rc)); + } + } + else + LogRel(("DbgDiggerOs2: RTDbgModSetTag failed: %Rrc\n", rc)); + RTDbgModRelease(hDbgMod); +} + + +/** + * @copydoc DBGFOSREG::pfnInit + */ +static DECLCALLBACK(int) dbgDiggerOS2Init(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData) +{ + PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData; + Assert(!pThis->fValid); + + DBGDIGGEROS2BUF uBuf; + DBGFADDRESS Addr; + int rc; + + /* + * Determine the OS/2 version. + */ + /* Version info is at GIS:15h (major/minor/revision). */ + rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, pThis->selGis, 0x15); + if (RT_FAILURE(rc)) + return VERR_NOT_SUPPORTED; + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, uBuf.au32, sizeof(uint32_t)); + if (RT_FAILURE(rc)) + return VERR_NOT_SUPPORTED; + + pThis->OS2MajorVersion = uBuf.au8[0]; + pThis->OS2MinorVersion = uBuf.au8[1]; + + pThis->fValid = true; + + /* + * Try use SAS to find the module list. + */ + rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, 0x00); + if (RT_SUCCESS(rc)) + { + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.sas, sizeof(uBuf.sas)); + if (RT_SUCCESS(rc)) + { + rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, uBuf.sas.SAS_vm_data); + if (RT_SUCCESS(rc)) + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.sasvm, sizeof(uBuf.sasvm)); + if (RT_SUCCESS(rc)) + { + /* + * Work the module list. + */ + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.sasvm.SAS_vm_all_mte), + &uBuf.au32[0], sizeof(uBuf.au32[0])); + if (RT_SUCCESS(rc)) + { + uint32_t uOs2Krnl = UINT32_MAX; + RTDBGCFG hDbgCfg = pVMM->pfnDBGFR3AsGetConfig(pUVM); /* (don't release this) */ + RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_GLOBAL); + + char szCacheSubDir[24]; + RTStrPrintf(szCacheSubDir, sizeof(szCacheSubDir), "os2-%u.%u", pThis->OS2MajorVersion, pThis->OS2MinorVersion); + + pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.au32[0]); + while (Addr.FlatPtr != 0 && Addr.FlatPtr != UINT32_MAX) + { + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, &uBuf.mte, sizeof(uBuf.mte)); + if (RT_FAILURE(rc)) + break; + LogRel(("DbgDiggerOs2: Module @ %#010RX32: %.8s %#x %#x\n", (uint32_t)Addr.FlatPtr, + uBuf.mte.mte_modname, uBuf.mte.mte_flags1, uBuf.mte.mte_flags2)); + if (uBuf.mte.mte_flags1 & MTE1_DOSMOD) + uOs2Krnl = (uint32_t)Addr.FlatPtr; + + pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uBuf.mte.mte_link); + dbgdiggerOS2ProcessModule(pUVM, pVMM, pThis, &uBuf, szCacheSubDir, hAs, hDbgCfg); + } + + /* Load the kernel again. To make sure we didn't drop any segments due + to overlap/conflicts/whatever. */ + if (uOs2Krnl != UINT32_MAX) + { + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uOs2Krnl), + &uBuf.mte, sizeof(uBuf.mte)); + if (RT_SUCCESS(rc)) + { + LogRel(("DbgDiggerOs2: Module @ %#010RX32: %.8s %#x %#x [again]\n", (uint32_t)Addr.FlatPtr, + uBuf.mte.mte_modname, uBuf.mte.mte_flags1, uBuf.mte.mte_flags2)); + dbgdiggerOS2ProcessModule(pUVM, pVMM, pThis, &uBuf, szCacheSubDir, hAs, hDbgCfg); + } + } + + RTDbgAsRelease(hAs); + } + } + } + } + + /* + * Register info handlers. + */ + pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "sas", "Dumps the OS/2 system anchor block (SAS).", dbgDiggerOS2InfoSas, pThis); + pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "gis", "Dumps the OS/2 global info segment (GIS).", dbgDiggerOS2InfoGis, pThis); + pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "lis", "Dumps the OS/2 local info segment (current process).", dbgDiggerOS2InfoLis, pThis); + pVMM->pfnDBGFR3InfoRegisterExternal(pUVM, "panic", "Dumps the OS/2 system panic message.", dbgDiggerOS2InfoPanic, pThis); + + return VINF_SUCCESS; +} + + +/** + * @copydoc DBGFOSREG::pfnProbe + */ +static DECLCALLBACK(bool) dbgDiggerOS2Probe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData) +{ + PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData; + DBGFADDRESS Addr; + int rc; + uint16_t offInfo; + union + { + uint8_t au8[8192]; + uint16_t au16[8192/2]; + uint32_t au32[8192/4]; + RTUTF16 wsz[8192/2]; + } u; + + /* + * If the DWORD at 70:0 is 'SAS ' it's quite unlikely that this wouldn't be OS/2. + * Note: The SAS layout is similar between 16-bit and 32-bit OS/2, but not identical. + * 32-bit OS/2 will have the flat kernel data selector at SAS:06. The selector is 168h + * or similar. For 16-bit OS/2 the field contains a table offset into the SAS which will + * be much smaller. Fun fact: The global infoseg selector in the SAS is bimodal in 16-bit + * OS/2 and will work in real mode as well. + */ + do { + rc = pVMM->pfnDBGFR3AddrFromSelOff(pUVM, 0 /*idCpu*/, &Addr, 0x70, 0x00); + if (RT_FAILURE(rc)) + break; + rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &Addr, u.au32, 256); + if (RT_FAILURE(rc)) + break; + if (u.au32[0] != DIG_OS2_SAS_SIG) + break; + + /* This sure looks like OS/2, but a bit of paranoia won't hurt. */ + if (u.au16[2] >= u.au16[4]) + break; + + /* If 4th word is bigger than 5th, it's the flat kernel mode selector. */ + if (u.au16[3] > u.au16[4]) + pThis->f32Bit = true; + + /* Offset into info table is either at SAS:14h or SAS:16h. */ + if (pThis->f32Bit) + offInfo = u.au16[0x14/2]; + else + offInfo = u.au16[0x16/2]; + + /* The global infoseg selector is the first entry in the info table. */ + SASINFO const *pInfo = (SASINFO const *)&u.au8[offInfo]; + pThis->selGis = pInfo->SAS_info_global; + pThis->Lis.sel = RT_HI_U16(pInfo->SAS_info_local); + pThis->Lis.off = RT_LO_U16(pInfo->SAS_info_local); + return true; + } while (0); + + return false; +} + + +/** + * @copydoc DBGFOSREG::pfnDestruct + */ +static DECLCALLBACK(void) dbgDiggerOS2Destruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData) +{ + RT_NOREF(pUVM, pVMM, pvData); +} + + +/** + * @copydoc DBGFOSREG::pfnConstruct + */ +static DECLCALLBACK(int) dbgDiggerOS2Construct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData) +{ + PDBGDIGGEROS2 pThis = (PDBGDIGGEROS2)pvData; + pThis->fValid = false; + pThis->f32Bit = false; + pThis->enmVer = DBGDIGGEROS2VER_UNKNOWN; + pThis->pUVM = pUVM; + pThis->pVMM = pVMM; + return VINF_SUCCESS; +} + + +const DBGFOSREG g_DBGDiggerOS2 = +{ + /* .u32Magic = */ DBGFOSREG_MAGIC, + /* .fFlags = */ 0, + /* .cbData = */ sizeof(DBGDIGGEROS2), + /* .szName = */ "OS/2", + /* .pfnConstruct = */ dbgDiggerOS2Construct, + /* .pfnDestruct = */ dbgDiggerOS2Destruct, + /* .pfnProbe = */ dbgDiggerOS2Probe, + /* .pfnInit = */ dbgDiggerOS2Init, + /* .pfnRefresh = */ dbgDiggerOS2Refresh, + /* .pfnTerm = */ dbgDiggerOS2Term, + /* .pfnQueryVersion = */ dbgDiggerOS2QueryVersion, + /* .pfnQueryInterface = */ dbgDiggerOS2QueryInterface, + /* .pfnStackUnwindAssist = */ dbgDiggerOS2StackUnwindAssist, + /* .u32EndMagic = */ DBGFOSREG_MAGIC +}; |