Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1141 insertions, 0 deletions

diff --git a/src/VBox/Debugger/DBGPlugInSolaris.cpp b/src/VBox/Debugger/DBGPlugInSolaris.cpp
new file mode 100644
index 00000000..87e4d6d7
--- /dev/null
+++ b/src/VBox/Debugger/DBGPlugInSolaris.cpp
@@ -0,0 +1,1141 @@
+/* $Id: DBGPlugInSolaris.cpp $ */
+/** @file
+ * DBGPlugInSolaris - Debugger and Guest OS Digger Plugin For Solaris.
+ */
+
+/*
+ * Copyright (C) 2008-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DBGF /// @todo add new log group.
+#include "DBGPlugIns.h"
+#include "DBGPlugInCommonELF.h"
+#include <VBox/vmm/dbgf.h>
+#include <iprt/asm.h>
+#include <iprt/err.h>
+#include <iprt/mem.h>
+#include <iprt/stream.h>
+#include <iprt/string.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** Solaris on little endian ASCII systems. */
+#define DIG_SOL_MOD_TAG     UINT64_C(0x00736972616c6f53)
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+/** @name InternalSolaris structures
+ * @{ */
+
+/** sys/modctl.h */
+typedef struct SOL32v11_modctl
+{
+    uint32_t    mod_next;               /**<  0 */
+    uint32_t    mod_prev;               /**<  4 */
+    int32_t     mod_id;                 /**<  8 */
+    uint32_t    mod_mp;                 /**<  c Pointer to the kernel runtime loader bits. */
+    uint32_t    mod_inprogress_thread;  /**< 10 */
+    uint32_t    mod_modinfo;            /**< 14 */
+    uint32_t    mod_linkage;            /**< 18 */
+    uint32_t    mod_filename;           /**< 1c */
+    uint32_t    mod_modname;            /**< 20 */
+    int8_t      mod_busy;               /**< 24 */
+    int8_t      mod_want;               /**< 25 */
+    int8_t      mod_prim;               /**< 26 this is 1 for 'unix' and a few others. */
+    int8_t      mod_unused_padding;     /**< 27 */
+    int32_t     mod_ref;                /**< 28 */
+    int8_t      mod_loaded;             /**< 2c */
+    int8_t      mod_installed;          /**< 2d */
+    int8_t      mod_loadflags;          /**< 2e */
+    int8_t      mod_delay_unload;       /**< 2f */
+    uint32_t    mod_requisites;         /**< 30 */
+    uint32_t    mod___unused;           /**< 34 */
+    int32_t     mod_loadcnt;            /**< 38 */
+    int32_t     mod_nenabled;           /**< 3c */
+    uint32_t    mod_text;               /**< 40 */
+    uint32_t    mod_text_size;          /**< 44 */
+    int32_t     mod_gencount;           /**< 48 */
+    uint32_t    mod_requisite_loading;  /**< 4c */
+} SOL32v11_modctl_t;
+AssertCompileSize(SOL32v11_modctl_t, 0x50);
+
+typedef struct SOL64v11_modctl
+{
+    uint64_t    mod_next;               /**<  0 */
+    uint64_t    mod_prev;               /**<  8 */
+    int32_t     mod_id;                 /**< 10 */
+    int32_t     mod_padding0;
+    uint64_t    mod_mp;                 /**< 18 Pointer to the kernel runtime loader bits. */
+    uint64_t    mod_inprogress_thread;  /**< 20 */
+    uint64_t    mod_modinfo;            /**< 28 */
+    uint64_t    mod_linkage;            /**< 30 */
+    uint64_t    mod_filename;           /**< 38 */
+    uint64_t    mod_modname;            /**< 40 */
+    int8_t      mod_busy;               /**< 48 */
+    int8_t      mod_want;               /**< 49 */
+    int8_t      mod_prim;               /**< 4a this is 1 for 'unix' and a few others. */
+    int8_t      mod_unused_padding;     /**< 4b */
+    int32_t     mod_ref;                /**< 4c */
+    int8_t      mod_loaded;             /**< 50 */
+    int8_t      mod_installed;          /**< 51 */
+    int8_t      mod_loadflags;          /**< 52 */
+    int8_t      mod_delay_unload;       /**< 53 */
+    int32_t     mod_padding1;
+    uint64_t    mod_requisites;         /**< 58 */
+    uint64_t    mod___unused;           /**< 60 */
+    int32_t     mod_loadcnt;            /**< 68 */
+    int32_t     mod_nenabled;           /**< 6c */
+    uint64_t    mod_text;               /**< 70 */
+    uint64_t    mod_text_size;          /**< 78 */
+    int32_t     mod_gencount;           /**< 80 */
+    int32_t     mod_padding2;
+    uint64_t    mod_requisite_loading;  /**< 88 */
+} SOL64v11_modctl_t;
+AssertCompileSize(SOL64v11_modctl_t, 0x90);
+
+typedef struct SOL32v9_modctl
+{
+    uint32_t    mod_next;               /**<  0 */
+    uint32_t    mod_prev;               /**<  4 */
+    int32_t     mod_id;                 /**<  8 */
+    uint32_t    mod_mp;                 /**<  c Pointer to the kernel runtime loader bits. */
+    uint32_t    mod_inprogress_thread;  /**< 10 */
+    uint32_t    mod_modinfo;            /**< 14 */
+    uint32_t    mod_linkage;            /**< 18 */
+    uint32_t    mod_filename;           /**< 1c */
+    uint32_t    mod_modname;            /**< 20 */
+    int32_t     mod_busy;               /**< 24 */
+    int32_t     mod_stub;               /**< 28 DIFF 1 */
+    int8_t      mod_loaded;             /**< 2c */
+    int8_t      mod_installed;          /**< 2d */
+    int8_t      mod_loadflags;          /**< 2e */
+    int8_t      mod_want;               /**< 2f DIFF 2 */
+    uint32_t    mod_requisites;         /**< 30 */
+    uint32_t    mod_dependents;         /**< 34 DIFF 3 */
+    int32_t     mod_loadcnt;            /**< 38 */
+                                             /* DIFF 4: 4 bytes added in v11 */
+    uint32_t    mod_text;               /**< 3c */
+    uint32_t    mod_text_size;          /**< 40 */
+                                             /* DIFF 5: 8 bytes added in v11 */
+} SOL32v9_modctl_t;
+AssertCompileSize(SOL32v9_modctl_t, 0x44);
+
+typedef struct SOL64v9_modctl
+{
+    uint64_t    mod_next;               /**<  0 */
+    uint64_t    mod_prev;               /**<  8 */
+    int32_t     mod_id;                 /**< 10 */
+    int32_t     mod_padding0;
+    uint64_t    mod_mp;                 /**< 18 Pointer to the kernel runtime loader bits. */
+    uint64_t    mod_inprogress_thread;  /**< 20 */
+    uint64_t    mod_modinfo;            /**< 28 */
+    uint64_t    mod_linkage;            /**< 30 */
+    uint64_t    mod_filename;           /**< 38 */
+    uint64_t    mod_modname;            /**< 40 */
+    int32_t     mod_busy;               /**< 48 */
+    int32_t     mod_stub;               /**< 4c DIFF 1 - is this a pointer? */
+    int8_t      mod_loaded;             /**< 50 */
+    int8_t      mod_installed;          /**< 51 */
+    int8_t      mod_loadflags;          /**< 52 */
+    int8_t      mod_want;               /**< 53 DIFF 2 */
+    int32_t     mod_padding1;
+    uint64_t    mod_requisites;         /**< 58 */
+    uint64_t    mod_dependencies;       /**< 60 DIFF 3 */
+    int32_t     mod_loadcnt;            /**< 68 */
+    int32_t     mod_padding3;           /**< 6c DIFF 4 */
+    uint64_t    mod_text;               /**< 70 */
+    uint64_t    mod_text_size;          /**< 78 */
+                                             /* DIFF 5: 8 bytes added in v11 */
+} SOL64v9_modctl_t;
+AssertCompileSize(SOL64v9_modctl_t, 0x80);
+
+typedef union SOL_modctl
+{
+    SOL32v9_modctl_t    v9_32;
+    SOL32v11_modctl_t   v11_32;
+    SOL64v9_modctl_t    v9_64;
+    SOL64v11_modctl_t   v11_64;
+} SOL_modctl_t;
+
+/** sys/kobj.h */
+typedef struct SOL32_module
+{
+    int32_t     total_allocated;        /**<  0 */
+    Elf32_Ehdr  hdr;                    /**<  4 Easy to validate */
+    uint32_t    shdrs;                  /**< 38 */
+    uint32_t    symhdr;                 /**< 3c */
+    uint32_t    strhdr;                 /**< 40 */
+    uint32_t    depends_on;             /**< 44 */
+    uint32_t    symsize;                /**< 48 */
+    uint32_t    symspace;               /**< 4c */
+    int32_t     flags;                  /**< 50 */
+    uint32_t    text_size;              /**< 54 */
+    uint32_t    data_size;              /**< 58 */
+    uint32_t    text;                   /**< 5c */
+    uint32_t    data;                   /**< 60 */
+    uint32_t    symtbl_section;         /**< 64 */
+    uint32_t    symtbl;                 /**< 68 */
+    uint32_t    strings;                /**< 6c */
+    uint32_t    hashsize;               /**< 70 */
+    uint32_t    buckets;                /**< 74 */
+    uint32_t    chains;                 /**< 78 */
+    uint32_t    nsyms;                  /**< 7c */
+    uint32_t    bss_align;              /**< 80 */
+    uint32_t    bss_size;               /**< 84 */
+    uint32_t    bss;                    /**< 88 */
+    uint32_t    filename;               /**< 8c */
+    uint32_t    head;                   /**< 90 */
+    uint32_t    tail;                   /**< 94 */
+    uint32_t    destination;            /**< 98 */
+    uint32_t    machdata;               /**< 9c */
+    uint32_t    ctfdata;                /**< a0 */
+    uint32_t    ctfsize;                /**< a4 */
+    uint32_t    fbt_tab;                /**< a8 */
+    uint32_t    fbt_size;               /**< ac */
+    uint32_t    fbt_nentries;           /**< b0 */
+    uint32_t    textwin;                /**< b4 */
+    uint32_t    textwin_base;           /**< b8 */
+    uint32_t    sdt_probes;             /**< bc */
+    uint32_t    sdt_nprobes;            /**< c0 */
+    uint32_t    sdt_tab;                /**< c4 */
+    uint32_t    sdt_size;               /**< c8 */
+    uint32_t    sigdata;                /**< cc */
+    uint32_t    sigsize;                /**< d0 */
+} SOL32_module_t;
+AssertCompileSize(Elf32_Ehdr, 0x34);
+AssertCompileSize(SOL32_module_t, 0xd4);
+
+typedef struct SOL64_module
+{
+    int32_t     total_allocated;        /**<  0 */
+    int32_t     padding0;
+    Elf64_Ehdr  hdr;                    /**<  8 Easy to validate */
+    uint64_t    shdrs;                  /**< 48 */
+    uint64_t    symhdr;                 /**< 50 */
+    uint64_t    strhdr;                 /**< 58 */
+    uint64_t    depends_on;             /**< 60 */
+    uint64_t    symsize;                /**< 68 */
+    uint64_t    symspace;               /**< 70 */
+    int32_t     flags;                  /**< 78 */
+    int32_t     padding1;
+    uint64_t    text_size;              /**< 80 */
+    uint64_t    data_size;              /**< 88 */
+    uint64_t    text;                   /**< 90 */
+    uint64_t    data;                   /**< 98 */
+    uint32_t    symtbl_section;         /**< a0 */
+    int32_t     padding2;
+    uint64_t    symtbl;                 /**< a8 */
+    uint64_t    strings;                /**< b0 */
+    uint32_t    hashsize;               /**< b8 */
+    int32_t     padding3;
+    uint64_t    buckets;                /**< c0 */
+    uint64_t    chains;                 /**< c8 */
+    uint32_t    nsyms;                  /**< d0 */
+    uint32_t    bss_align;              /**< d4 */
+    uint64_t    bss_size;               /**< d8 */
+    uint64_t    bss;                    /**< e0 */
+    uint64_t    filename;               /**< e8 */
+    uint64_t    head;                   /**< f0 */
+    uint64_t    tail;                   /**< f8 */
+    uint64_t    destination;            /**< 100 */
+    uint64_t    machdata;               /**< 108 */
+    uint64_t    ctfdata;                /**< 110 */
+    uint64_t    ctfsize;                /**< 118 */
+    uint64_t    fbt_tab;                /**< 120 */
+    uint64_t    fbt_size;               /**< 128 */
+    uint64_t    fbt_nentries;           /**< 130 */
+    uint64_t    textwin;                /**< 138 */
+    uint64_t    textwin_base;           /**< 140 */
+    uint64_t    sdt_probes;             /**< 148 */
+    uint64_t    sdt_nprobes;            /**< 150 */
+    uint64_t    sdt_tab;                /**< 158 */
+    uint64_t    sdt_size;               /**< 160 */
+    uint64_t    sigdata;                /**< 168 */
+    uint64_t    sigsize;                /**< 170 */
+} SOL64_module_t;
+AssertCompileSize(Elf64_Ehdr, 0x40);
+AssertCompileSize(SOL64_module_t, 0x178);
+
+typedef struct SOL_utsname
+{
+    char        sysname[257];
+    char        nodename[257];
+    char        release[257];
+    char        version[257];
+    char        machine[257];
+} SOL_utsname_t;
+AssertCompileSize(SOL_utsname_t, 5 * 257);
+
+/** @} */
+
+
+/**
+ * Solaris guest OS digger instance data.
+ */
+typedef struct DBGDIGGERSOLARIS
+{
+    /** Whether the information is valid or not.
+     * (For fending off illegal interface method calls.) */
+    bool fValid;
+
+    /** Address of the 'unix' text segment.
+     * This is set during probing. */
+    DBGFADDRESS AddrUnixText;
+    /** Address of the 'unix' text segment.
+     * This is set during probing. */
+    DBGFADDRESS AddrUnixData;
+    /** Address of the 'unix' modctl_t (aka modules). */
+    DBGFADDRESS AddrUnixModCtl;
+    /** modctl_t version number. */
+    int         iModCtlVer;
+    /** 64-bit/32-bit indicator. */
+    bool        f64Bit;
+
+} DBGDIGGERSOLARIS;
+/** Pointer to the solaris guest OS digger instance data. */
+typedef DBGDIGGERSOLARIS *PDBGDIGGERSOLARIS;
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** Min kernel address. */
+#define SOL32_MIN_KRNL_ADDR             UINT32_C(0x80000000)
+/** Max kernel address.  */
+#define SOL32_MAX_KRNL_ADDR             UINT32_C(0xfffff000)
+
+/** Min kernel address.  */
+#define SOL64_MIN_KRNL_ADDR             UINT64_C(0xFFFFC00000000000)
+/** Max kernel address.  */
+#define SOL64_MAX_KRNL_ADDR             UINT64_C(0xFFFFFFFFFFF00000)
+
+
+/** Validates a 32-bit solaris kernel address */
+#if 0 /* OpenSolaris, early boot have symspace at 0x27a2000 */
+# define SOL32_VALID_ADDRESS(Addr)      ((Addr) > SOL32_MIN_KRNL_ADDR && (Addr) < SOL32_MAX_KRNL_ADDR)
+#else
+# define SOL32_VALID_ADDRESS(Addr)      (   ((Addr) > SOL32_MIN_KRNL_ADDR && (Addr) < SOL32_MAX_KRNL_ADDR) \
+                                         || ((Addr) > UINT32_C(0x02000000) && (Addr) < UINT32_C(0x04000000)) /* boot */ )
+#endif
+
+/** Validates a 64-bit solaris kernel address */
+#define SOL64_VALID_ADDRESS(Addr)       (   (Addr) > SOL64_MIN_KRNL_ADDR \
+                                         && (Addr) < SOL64_MAX_KRNL_ADDR)
+
+/** The max data segment size of the 'unix' module. */
+#define SOL_UNIX_MAX_DATA_SEG_SIZE      0x01000000
+
+/** The max code segment size of the 'unix' module.
+ * This is the same for both 64-bit and 32-bit.  */
+#define SOL_UNIX_MAX_CODE_SEG_SIZE      0x00400000
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static DECLCALLBACK(int)  dbgDiggerSolarisInit(PUVM pUVM, void *pvData);
+
+
+
+/**
+ * @copydoc DBGFOSREG::pfnStackUnwindAssist
+ */
+static DECLCALLBACK(int) dbgDiggerSolarisStackUnwindAssist(PUVM pUVM, void *pvData, VMCPUID idCpu, PDBGFSTACKFRAME pFrame,
+                                                           PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx, RTDBGAS hAs,
+                                                           uint64_t *puScratch)
+{
+    RT_NOREF(pUVM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc DBGFOSREG::pfnQueryInterface
+ */
+static DECLCALLBACK(void *) dbgDiggerSolarisQueryInterface(PUVM pUVM, void *pvData, DBGFOSINTERFACE enmIf)
+{
+    RT_NOREF3(pUVM, pvData, enmIf);
+    return NULL;
+}
+
+
+/**
+ * @copydoc DBGFOSREG::pfnQueryVersion
+ */
+static DECLCALLBACK(int)  dbgDiggerSolarisQueryVersion(PUVM pUVM, void *pvData, char *pszVersion, size_t cchVersion)
+{
+    PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
+    Assert(pThis->fValid);
+
+    /*
+     * It's all in the utsname symbol...
+     */
+    SOL_utsname_t UtsName;
+    RT_ZERO(UtsName);                   /* Make MSC happy. */
+    DBGFADDRESS Addr;
+    RTDBGSYMBOL SymUtsName;
+    int rc = DBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "utsname", &SymUtsName, NULL);
+    if (RT_SUCCESS(rc))
+        rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, SymUtsName.Value), &UtsName, sizeof(UtsName));
+    if (RT_FAILURE(rc))
+    {
+        /*
+         * Try searching by the name...
+         */
+        memset(&UtsName, '\0', sizeof(UtsName));
+        strcpy(&UtsName.sysname[0], "SunOS");
+        rc = DBGFR3MemScan(pUVM, 0, &pThis->AddrUnixData, SOL_UNIX_MAX_DATA_SEG_SIZE, 1,
+                           &UtsName.sysname[0], sizeof(UtsName.sysname), &Addr);
+        if (RT_SUCCESS(rc))
+            rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Addr.FlatPtr - RT_OFFSETOF(SOL_utsname_t, sysname)),
+                               &UtsName, sizeof(UtsName));
+    }
+
+    /*
+     * Copy out the result (if any).
+     */
+    if (RT_SUCCESS(rc))
+    {
+        if (    UtsName.sysname[sizeof(UtsName.sysname) - 1] != '\0'
+            ||  UtsName.nodename[sizeof(UtsName.nodename) - 1] != '\0'
+            ||  UtsName.release[sizeof(UtsName.release) - 1] != '\0'
+            ||  UtsName.version[sizeof(UtsName.version) - 1] != '\0'
+            ||  UtsName.machine[sizeof(UtsName.machine) - 1] != '\0')
+        {
+            //rc = VERR_DBGF_UNEXPECTED_OS_DATA;
+            rc = VERR_GENERAL_FAILURE;
+            RTStrPrintf(pszVersion, cchVersion, "failed - bogus utsname");
+        }
+        else
+            RTStrPrintf(pszVersion, cchVersion, "%s %s", UtsName.version, UtsName.release);
+    }
+    else
+        RTStrPrintf(pszVersion, cchVersion, "failed - %Rrc", rc);
+
+    return rc;
+}
+
+
+
+/**
+ * Processes a modctl_t.
+ *
+ * @param   pUVM    The user mode VM handle.
+ * @param   pThis   Our instance data.
+ * @param   pModCtl Pointer to the modctl structure.
+ */
+static void dbgDiggerSolarisProcessModCtl32(PUVM pUVM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
+{
+    RT_NOREF1(pThis);
+
+    /* skip it if it's not loaded and installed */
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_loaded,    v9_32.mod_loaded);
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_installed, v9_32.mod_installed);
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_id,        v9_32.mod_id);
+    if (    (   !pModCtl->v9_32.mod_loaded
+             || !pModCtl->v9_32.mod_installed)
+        &&  pModCtl->v9_32.mod_id > 3)
+        return;
+
+    /*
+     * Read the module and file names first
+     */
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_modname, v9_32.mod_modname);
+    char szModName[64];
+    DBGFADDRESS Addr;
+    int rc = DBGFR3MemReadString(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_modname), szModName, sizeof(szModName));
+    if (RT_FAILURE(rc))
+        return;
+    if (!RTStrEnd(szModName, sizeof(szModName)))
+        szModName[sizeof(szModName) - 1] = '\0';
+
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_filename, v9_32.mod_filename);
+    char szFilename[256];
+    rc = DBGFR3MemReadString(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_filename), szFilename, sizeof(szFilename));
+    if (RT_FAILURE(rc))
+        strcpy(szFilename, szModName);
+    else if (!RTStrEnd(szFilename, sizeof(szFilename)))
+        szFilename[sizeof(szFilename) - 1] = '\0';
+
+    /*
+     * Then read the module struct and validate it.
+     */
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_mp, v9_32.mod_mp);
+    struct SOL32_module Module;
+    rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_32.mod_mp), &Module, sizeof(Module));
+    if (RT_FAILURE(rc))
+        return;
+
+    /* Basic validations of the elf header. */
+    if (    Module.hdr.e_ident[EI_MAG0] != ELFMAG0
+        ||  Module.hdr.e_ident[EI_MAG1] != ELFMAG1
+        ||  Module.hdr.e_ident[EI_MAG2] != ELFMAG2
+        ||  Module.hdr.e_ident[EI_MAG3] != ELFMAG3
+        ||  Module.hdr.e_ident[EI_CLASS] != ELFCLASS32
+        ||  Module.hdr.e_ident[EI_DATA] != ELFDATA2LSB
+        ||  Module.hdr.e_ident[EI_VERSION] != EV_CURRENT
+        ||  !ASMMemIsZero(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD)
+        )
+        return;
+    if (Module.hdr.e_version != EV_CURRENT)
+        return;
+    if (Module.hdr.e_ehsize != sizeof(Module.hdr))
+        return;
+    if (    Module.hdr.e_type != ET_DYN
+        &&  Module.hdr.e_type != ET_REL
+        &&  Module.hdr.e_type != ET_EXEC) //??
+        return;
+    if (    Module.hdr.e_machine != EM_386
+        &&  Module.hdr.e_machine != EM_486)
+        return;
+    if (    Module.hdr.e_phentsize != sizeof(Elf32_Phdr)
+        &&  Module.hdr.e_phentsize) //??
+        return;
+    if (Module.hdr.e_shentsize != sizeof(Elf32_Shdr))
+        return;
+
+    if (Module.hdr.e_shentsize != sizeof(Elf32_Shdr))
+        return;
+
+    /* Basic validations of the rest of the stuff. */
+    if (    !SOL32_VALID_ADDRESS(Module.shdrs)
+        ||  !SOL32_VALID_ADDRESS(Module.symhdr)
+        ||  !SOL32_VALID_ADDRESS(Module.strhdr)
+        ||  (!SOL32_VALID_ADDRESS(Module.symspace) && Module.symspace)
+        ||  !SOL32_VALID_ADDRESS(Module.text)
+        ||  !SOL32_VALID_ADDRESS(Module.data)
+        ||  (!SOL32_VALID_ADDRESS(Module.symtbl) && Module.symtbl)
+        ||  (!SOL32_VALID_ADDRESS(Module.strings) && Module.strings)
+        ||  (!SOL32_VALID_ADDRESS(Module.head) && Module.head)
+        ||  (!SOL32_VALID_ADDRESS(Module.tail) && Module.tail)
+        ||  !SOL32_VALID_ADDRESS(Module.filename))
+        return;
+    if (    Module.symsize > _4M
+        ||  Module.hdr.e_shnum > 4096
+        ||  Module.nsyms > _256K)
+        return;
+
+    /* Ignore modules without symbols. */
+    if (!Module.symtbl || !Module.strings || !Module.symspace || !Module.symsize)
+        return;
+
+    /* Check that the symtbl and strings points inside the symspace. */
+    if (Module.strings - Module.symspace >= Module.symsize)
+        return;
+    if (Module.symtbl - Module.symspace >= Module.symsize)
+        return;
+
+    /*
+     * Read the section headers, symbol table and string tables.
+     */
+    size_t cb = Module.hdr.e_shnum * sizeof(Elf32_Shdr);
+    Elf32_Shdr *paShdrs = (Elf32_Shdr *)RTMemTmpAlloc(cb);
+    if (!paShdrs)
+        return;
+    rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
+    if (RT_SUCCESS(rc))
+    {
+        void *pvSymSpace = RTMemTmpAlloc(Module.symsize + 1);
+        if (pvSymSpace)
+        {
+            rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace), pvSymSpace, Module.symsize);
+            if (RT_SUCCESS(rc))
+            {
+                ((uint8_t *)pvSymSpace)[Module.symsize] = 0;
+
+                /*
+                 * Hand it over to the common ELF32 module parser.
+                 */
+                char const *pbStrings = (char const *)pvSymSpace + (Module.strings - Module.symspace);
+                size_t cbMaxStrings = Module.symsize - (Module.strings - Module.symspace);
+
+                Elf32_Sym const *paSyms = (Elf32_Sym const *)((uintptr_t)pvSymSpace + (Module.symtbl - Module.symspace));
+                size_t cMaxSyms = (Module.symsize - (Module.symtbl - Module.symspace)) / sizeof(Elf32_Sym);
+                cMaxSyms = RT_MIN(cMaxSyms, Module.nsyms);
+
+                DBGDiggerCommonParseElf32Mod(pUVM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
+                                             &Module.hdr, paShdrs, paSyms, cMaxSyms, pbStrings, cbMaxStrings,
+                                             SOL32_MIN_KRNL_ADDR, SOL32_MAX_KRNL_ADDR - 1, DIG_SOL_MOD_TAG);
+            }
+            RTMemTmpFree(pvSymSpace);
+        }
+    }
+
+    RTMemTmpFree(paShdrs);
+    return;
+}
+
+
+/**
+ * Processes a modctl_t.
+ *
+ * @param   pUVM    The user mode VM handle.
+ * @param   pThis   Our instance data.
+ * @param   pModCtl Pointer to the modctl structure.
+ */
+static void dbgDiggerSolarisProcessModCtl64(PUVM pUVM, PDBGDIGGERSOLARIS pThis, SOL_modctl_t const *pModCtl)
+{
+    RT_NOREF1(pThis);
+
+    /* skip it if it's not loaded and installed */
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_loaded,    v9_64.mod_loaded);
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_installed, v9_64.mod_installed);
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_id,        v9_64.mod_id);
+    if (    (   !pModCtl->v9_64.mod_loaded
+             || !pModCtl->v9_64.mod_installed)
+        &&  pModCtl->v9_64.mod_id > 3)
+        return;
+
+    /*
+     * Read the module and file names first
+     */
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_modname, v9_64.mod_modname);
+    char szModName[64];
+    DBGFADDRESS Addr;
+    int rc = DBGFR3MemReadString(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_modname), szModName, sizeof(szModName));
+    if (RT_FAILURE(rc))
+        return;
+    if (!RTStrEnd(szModName, sizeof(szModName)))
+        szModName[sizeof(szModName) - 1] = '\0';
+
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_filename, v9_64.mod_filename);
+    char szFilename[256];
+    rc = DBGFR3MemReadString(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_filename), szFilename, sizeof(szFilename));
+    if (RT_FAILURE(rc))
+        strcpy(szFilename, szModName);
+    else if (!RTStrEnd(szFilename, sizeof(szFilename)))
+        szFilename[sizeof(szFilename) - 1] = '\0';
+
+    /*
+     * Then read the module struct and validate it.
+     */
+    AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_mp, v9_64.mod_mp);
+    struct SOL64_module Module;
+    rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, pModCtl->v9_64.mod_mp), &Module, sizeof(Module));
+    if (RT_FAILURE(rc))
+        return;
+
+    /* Basic validations of the elf header. */
+    if (    Module.hdr.e_ident[EI_MAG0] != ELFMAG0
+        ||  Module.hdr.e_ident[EI_MAG1] != ELFMAG1
+        ||  Module.hdr.e_ident[EI_MAG2] != ELFMAG2
+        ||  Module.hdr.e_ident[EI_MAG3] != ELFMAG3
+        ||  Module.hdr.e_ident[EI_CLASS] != ELFCLASS64
+        ||  Module.hdr.e_ident[EI_DATA] != ELFDATA2LSB
+        ||  Module.hdr.e_ident[EI_VERSION] != EV_CURRENT
+        ||  !ASMMemIsZero(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD)
+        )
+        return;
+    if (Module.hdr.e_version != EV_CURRENT)
+        return;
+    if (Module.hdr.e_ehsize != sizeof(Module.hdr))
+        return;
+    if (    Module.hdr.e_type != ET_DYN
+        &&  Module.hdr.e_type != ET_REL
+        &&  Module.hdr.e_type != ET_EXEC) //??
+        return;
+    if (Module.hdr.e_machine != EM_X86_64)
+        return;
+    if (    Module.hdr.e_phentsize != sizeof(Elf64_Phdr)
+        &&  Module.hdr.e_phentsize) //??
+        return;
+    if (Module.hdr.e_shentsize != sizeof(Elf64_Shdr))
+        return;
+
+    if (Module.hdr.e_shentsize != sizeof(Elf64_Shdr))
+        return;
+
+    /* Basic validations of the rest of the stuff. */
+    if (    !SOL64_VALID_ADDRESS(Module.shdrs)
+        ||  !SOL64_VALID_ADDRESS(Module.symhdr)
+        ||  !SOL64_VALID_ADDRESS(Module.strhdr)
+        ||  (!SOL64_VALID_ADDRESS(Module.symspace) && Module.symspace)
+        ||  !SOL64_VALID_ADDRESS(Module.text)
+        ||  !SOL64_VALID_ADDRESS(Module.data)
+        ||  (!SOL64_VALID_ADDRESS(Module.symtbl) && Module.symtbl)
+        ||  (!SOL64_VALID_ADDRESS(Module.strings) && Module.strings)
+        ||  (!SOL64_VALID_ADDRESS(Module.head) && Module.head)
+        ||  (!SOL64_VALID_ADDRESS(Module.tail) && Module.tail)
+        ||  !SOL64_VALID_ADDRESS(Module.filename))
+        return;
+    if (    Module.symsize > _4M
+        ||  Module.hdr.e_shnum > 4096
+        ||  Module.nsyms > _256K)
+        return;
+
+    /* Ignore modules without symbols. */
+    if (!Module.symtbl || !Module.strings || !Module.symspace || !Module.symsize)
+        return;
+
+    /* Check that the symtbl and strings points inside the symspace. */
+    if (Module.strings - Module.symspace >= Module.symsize)
+        return;
+    if (Module.symtbl - Module.symspace >= Module.symsize)
+        return;
+
+    /*
+     * Read the section headers, symbol table and string tables.
+     */
+    size_t cb = Module.hdr.e_shnum * sizeof(Elf64_Shdr);
+    Elf64_Shdr *paShdrs = (Elf64_Shdr *)RTMemTmpAlloc(cb);
+    if (!paShdrs)
+        return;
+    rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Module.shdrs), paShdrs, cb);
+    if (RT_SUCCESS(rc))
+    {
+        void *pvSymSpace = RTMemTmpAlloc(Module.symsize + 1);
+        if (pvSymSpace)
+        {
+            rc = DBGFR3MemRead(pUVM, 0, DBGFR3AddrFromFlat(pUVM, &Addr, Module.symspace), pvSymSpace, Module.symsize);
+            if (RT_SUCCESS(rc))
+            {
+                ((uint8_t *)pvSymSpace)[Module.symsize] = 0;
+
+                /*
+                 * Hand it over to the common ELF64 module parser.
+                 */
+                char const *pbStrings = (char const *)pvSymSpace + (Module.strings - Module.symspace);
+                size_t cbMaxStrings = Module.symsize - (Module.strings - Module.symspace);
+
+                Elf64_Sym const *paSyms = (Elf64_Sym const *)((uintptr_t)pvSymSpace + (uintptr_t)(Module.symtbl - Module.symspace));
+                size_t cMaxSyms = (Module.symsize - (Module.symtbl - Module.symspace)) / sizeof(Elf32_Sym);
+                cMaxSyms = RT_MIN(cMaxSyms, Module.nsyms);
+
+                DBGDiggerCommonParseElf64Mod(pUVM, szModName, szFilename, DBG_DIGGER_ELF_FUNNY_SHDRS,
+                                             &Module.hdr, paShdrs, paSyms, cMaxSyms, pbStrings, cbMaxStrings,
+                                             SOL64_MIN_KRNL_ADDR, SOL64_MAX_KRNL_ADDR - 1, DIG_SOL_MOD_TAG);
+            }
+            RTMemTmpFree(pvSymSpace);
+        }
+    }
+
+    RTMemTmpFree(paShdrs);
+    return;
+}
+
+
+/**
+ * @copydoc DBGFOSREG::pfnTerm
+ */
+static DECLCALLBACK(void)  dbgDiggerSolarisTerm(PUVM pUVM, void *pvData)
+{
+    RT_NOREF1(pUVM);
+    PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
+    Assert(pThis->fValid);
+
+    pThis->fValid = false;
+}
+
+
+/**
+ * @copydoc DBGFOSREG::pfnRefresh
+ */
+static DECLCALLBACK(int)  dbgDiggerSolarisRefresh(PUVM pUVM, void *pvData)
+{
+    PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
+    NOREF(pThis);
+    Assert(pThis->fValid);
+
+    /*
+     * For now we'll flush and reload everything.
+     */
+    RTDBGAS hDbgAs = DBGFR3AsResolveAndRetain(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_SOL_MOD_TAG)
+                {
+                    int rc = RTDbgAsModuleUnlink(hDbgAs, hMod);
+                    AssertRC(rc);
+                }
+                RTDbgModRelease(hMod);
+            }
+        }
+        RTDbgAsRelease(hDbgAs);
+    }
+
+    dbgDiggerSolarisTerm(pUVM, pvData);
+    return dbgDiggerSolarisInit(pUVM, pvData);
+}
+
+
+/**
+ * @copydoc DBGFOSREG::pfnInit
+ */
+static DECLCALLBACK(int)  dbgDiggerSolarisInit(PUVM pUVM, void *pvData)
+{
+    PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
+    Assert(!pThis->fValid);
+    int rc;
+    size_t cbModCtl = 0;
+
+    /*
+     * On Solaris the kernel and is the global address space.
+     */
+    DBGFR3AsSetAlias(pUVM, DBGF_AS_KERNEL, DBGF_AS_GLOBAL);
+
+/** @todo Use debug_info, build 7x / S10U6. */
+
+    /*
+     * Find the 'unix' modctl_t structure (aka modules).
+     * We know it resides in the unix data segment.
+     */
+    DBGFR3AddrFromFlat(pUVM, &pThis->AddrUnixModCtl, 0);
+
+    DBGFADDRESS     CurAddr = pThis->AddrUnixData;
+    DBGFADDRESS     MaxAddr;
+    DBGFR3AddrFromFlat(pUVM, &MaxAddr, CurAddr.FlatPtr + SOL_UNIX_MAX_DATA_SEG_SIZE);
+    const uint8_t  *pbExpr = (const uint8_t *)&pThis->AddrUnixText.FlatPtr;
+    const uint32_t  cbExpr = pThis->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t);
+    while (   CurAddr.FlatPtr < MaxAddr.FlatPtr
+           && CurAddr.FlatPtr >= pThis->AddrUnixData.FlatPtr)
+    {
+        DBGFADDRESS HitAddr;
+        rc = DBGFR3MemScan(pUVM, 0, &CurAddr, MaxAddr.FlatPtr - CurAddr.FlatPtr, 1, pbExpr, cbExpr, &HitAddr);
+        if (RT_FAILURE(rc))
+            break;
+
+        /*
+         * Read out the modctl_t structure.
+         */
+        DBGFADDRESS ModCtlAddr;
+
+        /* v11 */
+        if (pThis->f64Bit)
+        {
+            DBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
+            SOL64v11_modctl_t ModCtlv11;
+            rc = DBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
+            if (RT_SUCCESS(rc))
+            {
+                if (    SOL64_VALID_ADDRESS(ModCtlv11.mod_next)
+                    &&  SOL64_VALID_ADDRESS(ModCtlv11.mod_prev)
+                    &&  ModCtlv11.mod_id == 0
+                    &&  SOL64_VALID_ADDRESS(ModCtlv11.mod_mp)
+                    &&  SOL64_VALID_ADDRESS(ModCtlv11.mod_filename)
+                    &&  SOL64_VALID_ADDRESS(ModCtlv11.mod_modname)
+                    &&  ModCtlv11.mod_prim == 1
+                    &&  ModCtlv11.mod_loaded == 1
+                    &&  ModCtlv11.mod_installed == 1
+                    &&  ModCtlv11.mod_requisites == 0
+                    &&  ModCtlv11.mod_loadcnt == 1
+                    /*&&  ModCtlv11.mod_text == pThis->AddrUnixText.FlatPtr*/
+                    &&  ModCtlv11.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE
+                    &&  ModCtlv11.mod_text_size >= _128K)
+                {
+                    char szUnix[5];
+                    DBGFADDRESS NameAddr;
+                    DBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
+                    rc = DBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (!strcmp(szUnix, "unix"))
+                        {
+                            pThis->AddrUnixModCtl = ModCtlAddr;
+                            pThis->iModCtlVer = 11;
+                            cbModCtl = sizeof(ModCtlv11);
+                            break;
+                        }
+                        Log(("sol64 mod_name=%.*s v11\n", sizeof(szUnix), szUnix));
+                    }
+                }
+            }
+        }
+        else
+        {
+            DBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v11_modctl_t, mod_text));
+            SOL32v11_modctl_t ModCtlv11;
+            rc = DBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv11, sizeof(ModCtlv11));
+            if (RT_SUCCESS(rc))
+            {
+                if (    SOL32_VALID_ADDRESS(ModCtlv11.mod_next)
+                    &&  SOL32_VALID_ADDRESS(ModCtlv11.mod_prev)
+                    &&  ModCtlv11.mod_id == 0
+                    &&  SOL32_VALID_ADDRESS(ModCtlv11.mod_mp)
+                    &&  SOL32_VALID_ADDRESS(ModCtlv11.mod_filename)
+                    &&  SOL32_VALID_ADDRESS(ModCtlv11.mod_modname)
+                    &&  ModCtlv11.mod_prim == 1
+                    &&  ModCtlv11.mod_loaded == 1
+                    &&  ModCtlv11.mod_installed == 1
+                    &&  ModCtlv11.mod_requisites == 0
+                    &&  ModCtlv11.mod_loadcnt == 1
+                    /*&&  ModCtlv11.mod_text == pThis->AddrUnixText.FlatPtr*/
+                    &&  ModCtlv11.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE
+                    &&  ModCtlv11.mod_text_size >= _128K)
+                {
+                    char szUnix[5];
+                    DBGFADDRESS NameAddr;
+                    DBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv11.mod_modname);
+                    rc = DBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (!strcmp(szUnix, "unix"))
+                        {
+                            pThis->AddrUnixModCtl = ModCtlAddr;
+                            pThis->iModCtlVer = 11;
+                            cbModCtl = sizeof(ModCtlv11);
+                            break;
+                        }
+                        Log(("sol32 mod_name=%.*s v11\n", sizeof(szUnix), szUnix));
+                    }
+                }
+            }
+        }
+
+        /* v9 */
+        if (pThis->f64Bit)
+        {
+            DBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL64v9_modctl_t, mod_text));
+            SOL64v9_modctl_t ModCtlv9;
+            rc = DBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
+            if (RT_SUCCESS(rc))
+            {
+                if (    SOL64_VALID_ADDRESS(ModCtlv9.mod_next)
+                    &&  SOL64_VALID_ADDRESS(ModCtlv9.mod_prev)
+                    &&  ModCtlv9.mod_id == 0
+                    &&  SOL64_VALID_ADDRESS(ModCtlv9.mod_mp)
+                    &&  SOL64_VALID_ADDRESS(ModCtlv9.mod_filename)
+                    &&  SOL64_VALID_ADDRESS(ModCtlv9.mod_modname)
+                    &&  (ModCtlv9.mod_loaded == 1    || ModCtlv9.mod_loaded == 0)
+                    &&  (ModCtlv9.mod_installed == 1 || ModCtlv9.mod_installed == 0)
+                    &&  ModCtlv9.mod_requisites == 0
+                    &&  (ModCtlv9.mod_loadcnt == 1   || ModCtlv9.mod_loadcnt == 0)
+                    /*&&  ModCtlv9.mod_text == pThis->AddrUnixText.FlatPtr*/
+                    &&  ModCtlv9.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE)
+                {
+                    char szUnix[5];
+                    DBGFADDRESS NameAddr;
+                    DBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
+                    rc = DBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (!strcmp(szUnix, "unix"))
+                        {
+                            pThis->AddrUnixModCtl = ModCtlAddr;
+                            pThis->iModCtlVer = 9;
+                            cbModCtl = sizeof(ModCtlv9);
+                            break;
+                        }
+                        Log(("sol64 mod_name=%.*s v9\n", sizeof(szUnix), szUnix));
+                    }
+                }
+            }
+        }
+        else
+        {
+            DBGFR3AddrFromFlat(pUVM, &ModCtlAddr, HitAddr.FlatPtr - RT_OFFSETOF(SOL32v9_modctl_t, mod_text));
+            SOL32v9_modctl_t ModCtlv9;
+            rc = DBGFR3MemRead(pUVM, 0, &ModCtlAddr, &ModCtlv9, sizeof(ModCtlv9));
+            if (RT_SUCCESS(rc))
+            {
+                if (    SOL32_VALID_ADDRESS(ModCtlv9.mod_next)
+                    &&  SOL32_VALID_ADDRESS(ModCtlv9.mod_prev)
+                    &&  ModCtlv9.mod_id == 0
+                    &&  SOL32_VALID_ADDRESS(ModCtlv9.mod_mp)
+                    &&  SOL32_VALID_ADDRESS(ModCtlv9.mod_filename)
+                    &&  SOL32_VALID_ADDRESS(ModCtlv9.mod_modname)
+                    &&  (ModCtlv9.mod_loaded == 1    || ModCtlv9.mod_loaded == 0)
+                    &&  (ModCtlv9.mod_installed == 1 || ModCtlv9.mod_installed == 0)
+                    &&  ModCtlv9.mod_requisites == 0
+                    &&  (ModCtlv9.mod_loadcnt == 1   || ModCtlv9.mod_loadcnt == 0)
+                    /*&&  ModCtlv9.mod_text == pThis->AddrUnixText.FlatPtr*/
+                    &&  ModCtlv9.mod_text_size < SOL_UNIX_MAX_CODE_SEG_SIZE )
+                {
+                    char szUnix[5];
+                    DBGFADDRESS NameAddr;
+                    DBGFR3AddrFromFlat(pUVM, &NameAddr, ModCtlv9.mod_modname);
+                    rc = DBGFR3MemRead(pUVM, 0, &NameAddr, &szUnix, sizeof(szUnix));
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (!strcmp(szUnix, "unix"))
+                        {
+                            pThis->AddrUnixModCtl = ModCtlAddr;
+                            pThis->iModCtlVer = 9;
+                            cbModCtl = sizeof(ModCtlv9);
+                            break;
+                        }
+                        Log(("sol32 mod_name=%.*s v9\n", sizeof(szUnix), szUnix));
+                    }
+                }
+            }
+        }
+
+        /* next */
+        DBGFR3AddrFromFlat(pUVM, &CurAddr, HitAddr.FlatPtr + cbExpr);
+    }
+
+    /*
+     * Walk the module chain and add the modules and their symbols.
+     */
+    if (pThis->AddrUnixModCtl.FlatPtr)
+    {
+        int iMod = 0;
+        CurAddr = pThis->AddrUnixModCtl;
+        do
+        {
+            /* read it */
+            SOL_modctl_t ModCtl;
+            rc = DBGFR3MemRead(pUVM, 0, &CurAddr, &ModCtl, cbModCtl);
+            if (RT_FAILURE(rc))
+            {
+                LogRel(("sol: bad modctl_t chain for module %d: %RGv - %Rrc\n", iMod, CurAddr.FlatPtr, rc));
+                break;
+            }
+
+            /* process it. */
+            if (pThis->f64Bit)
+                dbgDiggerSolarisProcessModCtl64(pUVM, pThis, &ModCtl);
+            else
+                dbgDiggerSolarisProcessModCtl32(pUVM, pThis, &ModCtl);
+
+            /* next */
+            if (pThis->f64Bit)
+            {
+                AssertCompile2MemberOffsets(SOL_modctl_t, v11_64.mod_next, v9_64.mod_next);
+                if (!SOL64_VALID_ADDRESS(ModCtl.v9_64.mod_next))
+                {
+                    LogRel(("sol64: bad modctl_t chain for module %d at %RGv: %RGv\n", iMod, CurAddr.FlatPtr, (RTGCUINTPTR)ModCtl.v9_64.mod_next));
+                    break;
+                }
+                DBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_64.mod_next);
+            }
+            else
+            {
+                AssertCompile2MemberOffsets(SOL_modctl_t, v11_32.mod_next, v9_32.mod_next);
+                if (!SOL32_VALID_ADDRESS(ModCtl.v9_32.mod_next))
+                {
+                    LogRel(("sol32: bad modctl_t chain for module %d at %RGv: %RGv\n", iMod, CurAddr.FlatPtr, (RTGCUINTPTR)ModCtl.v9_32.mod_next));
+                    break;
+                }
+                DBGFR3AddrFromFlat(pUVM, &CurAddr, ModCtl.v9_32.mod_next);
+            }
+            if (++iMod >= 1024)
+            {
+                LogRel(("sol32: too many modules (%d)\n", iMod));
+                break;
+            }
+        } while (CurAddr.FlatPtr != pThis->AddrUnixModCtl.FlatPtr);
+    }
+
+    pThis->fValid = true;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc DBGFOSREG::pfnProbe
+ */
+static DECLCALLBACK(bool)  dbgDiggerSolarisProbe(PUVM pUVM, void *pvData)
+{
+    PDBGDIGGERSOLARIS pThis = (PDBGDIGGERSOLARIS)pvData;
+
+    /*
+     * Look for "SunOS Release" in the text segment.
+     */
+    DBGFADDRESS Addr;
+    bool        f64Bit = false;
+
+    /* 32-bit search range. */
+    DBGFR3AddrFromFlat(pUVM, &Addr, 0xfe800000);
+    RTGCUINTPTR cbRange = 0xfec00000 - 0xfe800000;
+
+    DBGFADDRESS HitAddr;
+    static const uint8_t s_abSunRelease[] = "SunOS Release ";
+    int rc = DBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
+    if (RT_FAILURE(rc))
+    {
+        /* 64-bit.... */
+        DBGFR3AddrFromFlat(pUVM, &Addr, UINT64_C(0xfffffffffb800000));
+        cbRange = UINT64_C(0xfffffffffbd00000) - UINT64_C(0xfffffffffb800000);
+        rc = DBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSunRelease, sizeof(s_abSunRelease) - 1, &HitAddr);
+        if (RT_FAILURE(rc))
+            return false;
+        f64Bit = true;
+    }
+
+    /*
+     * Look for the copyright string too, just to be sure.
+     */
+    static const uint8_t s_abSMI[] = "Sun Microsystems, Inc.";
+    static const uint8_t s_abORCL[] = "Oracle and/or its affiliates.";
+    rc = DBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abSMI, sizeof(s_abSMI) - 1, &HitAddr);
+    if (RT_FAILURE(rc))
+    {
+        /* Try the alternate copyright string. */
+        rc = DBGFR3MemScan(pUVM, 0, &Addr, cbRange, 1, s_abORCL, sizeof(s_abORCL) - 1, &HitAddr);
+        if (RT_FAILURE(rc))
+            return false;
+    }
+
+    /*
+     * Remember the unix text and data addresses and bitness.
+     */
+    pThis->AddrUnixText = Addr;
+    DBGFR3AddrAdd(&Addr, SOL_UNIX_MAX_CODE_SEG_SIZE);
+    pThis->AddrUnixData = Addr;
+    pThis->f64Bit       = f64Bit;
+
+    return true;
+}
+
+
+/**
+ * @copydoc DBGFOSREG::pfnDestruct
+ */
+static DECLCALLBACK(void)  dbgDiggerSolarisDestruct(PUVM pUVM, void *pvData)
+{
+    RT_NOREF2(pUVM, pvData);
+
+}
+
+
+/**
+ * @copydoc DBGFOSREG::pfnConstruct
+ */
+static DECLCALLBACK(int)  dbgDiggerSolarisConstruct(PUVM pUVM, void *pvData)
+{
+    RT_NOREF2(pUVM, pvData);
+    return VINF_SUCCESS;
+}
+
+
+const DBGFOSREG g_DBGDiggerSolaris =
+{
+    /* .u32Magic = */               DBGFOSREG_MAGIC,
+    /* .fFlags = */                 0,
+    /* .cbData = */                 sizeof(DBGDIGGERSOLARIS),
+    /* .szName = */                 "Solaris",
+    /* .pfnConstruct = */           dbgDiggerSolarisConstruct,
+    /* .pfnDestruct = */            dbgDiggerSolarisDestruct,
+    /* .pfnProbe = */               dbgDiggerSolarisProbe,
+    /* .pfnInit = */                dbgDiggerSolarisInit,
+    /* .pfnRefresh = */             dbgDiggerSolarisRefresh,
+    /* .pfnTerm = */                dbgDiggerSolarisTerm,
+    /* .pfnQueryVersion = */        dbgDiggerSolarisQueryVersion,
+    /* .pfnQueryInterface = */      dbgDiggerSolarisQueryInterface,
+    /* .pfnStackUnwindAssist = */   dbgDiggerSolarisStackUnwindAssist,
+    /* .u32EndMagic = */            DBGFOSREG_MAGIC
+};
+