[31510] | 1 | /* $Id: DBGPlugInDarwin.cpp 104609 2024-05-13 16:07:39Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
[49044] | 3 | * DBGPlugInDarwin - Debugger and Guest OS Digger Plugin For Darwin / OS X.
|
---|
[31510] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2008-2023 Oracle and/or its affiliates.
|
---|
[31510] | 8 | *
|
---|
[96407] | 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
|
---|
[31510] | 26 | */
|
---|
| 27 |
|
---|
| 28 |
|
---|
[57358] | 29 | /*********************************************************************************************************************************
|
---|
| 30 | * Header Files *
|
---|
| 31 | *********************************************************************************************************************************/
|
---|
[63567] | 32 | #define LOG_GROUP LOG_GROUP_DBGF /// @todo add new log group.
|
---|
[31510] | 33 | #include "DBGPlugIns.h"
|
---|
[93470] | 34 | #include <VBox/vmm/vmmr3vtable.h>
|
---|
[76389] | 35 | #include <iprt/err.h>
|
---|
[31510] | 36 | #include <iprt/mem.h>
|
---|
| 37 | #include <iprt/stream.h>
|
---|
[76389] | 38 | #include <iprt/string.h>
|
---|
[49044] | 39 | #include <iprt/uuid.h>
|
---|
[31510] | 40 | #include <iprt/ctype.h>
|
---|
[49044] | 41 | #include <iprt/formats/mach-o.h>
|
---|
[31510] | 42 |
|
---|
[83083] | 43 | #undef LogRel2
|
---|
| 44 | #define LogRel2 LogRel
|
---|
[31510] | 45 |
|
---|
[83083] | 46 |
|
---|
[57358] | 47 | /*********************************************************************************************************************************
|
---|
| 48 | * Structures and Typedefs *
|
---|
| 49 | *********************************************************************************************************************************/
|
---|
[31510] | 50 |
|
---|
[49044] | 51 | /** @name Internal Darwin structures
|
---|
[31510] | 52 | * @{ */
|
---|
| 53 |
|
---|
[49075] | 54 | /**
|
---|
| 55 | * 32-bit darwin kernel module info structure (kmod_info_t).
|
---|
| 56 | */
|
---|
| 57 | typedef struct OSX32_kmod_info
|
---|
| 58 | {
|
---|
| 59 | uint32_t next;
|
---|
| 60 | int32_t info_version;
|
---|
| 61 | uint32_t id;
|
---|
| 62 | char name[64];
|
---|
| 63 | char version[64];
|
---|
| 64 | int32_t reference_count;
|
---|
| 65 | uint32_t reference_list; /**< Points to kmod_reference_t. */
|
---|
| 66 | uint32_t address; /**< Where in memory the kext is loaded. */
|
---|
| 67 | uint32_t size;
|
---|
| 68 | uint32_t hdr_size;
|
---|
| 69 | uint32_t start; /**< Address of kmod_start_func_t. */
|
---|
| 70 | uint32_t stop; /**< Address of kmod_stop_func_t. */
|
---|
| 71 | } OSX32_kmod_info_t;
|
---|
[31510] | 72 |
|
---|
[49075] | 73 | /**
|
---|
| 74 | * 32-bit darwin kernel module info structure (kmod_info_t).
|
---|
| 75 | */
|
---|
| 76 | #pragma pack(1)
|
---|
| 77 | typedef struct OSX64_kmod_info
|
---|
| 78 | {
|
---|
| 79 | uint64_t next;
|
---|
| 80 | int32_t info_version;
|
---|
| 81 | uint32_t id;
|
---|
| 82 | char name[64];
|
---|
| 83 | char version[64];
|
---|
| 84 | int32_t reference_count;
|
---|
| 85 | uint64_t reference_list; /**< Points to kmod_reference_t. Misaligned, duh. */
|
---|
| 86 | uint64_t address; /**< Where in memory the kext is loaded. */
|
---|
| 87 | uint64_t size;
|
---|
| 88 | uint64_t hdr_size;
|
---|
| 89 | uint64_t start; /**< Address of kmod_start_func_t. */
|
---|
| 90 | uint64_t stop; /**< Address of kmod_stop_func_t. */
|
---|
| 91 | } OSX64_kmod_info_t;
|
---|
| 92 | #pragma pack()
|
---|
| 93 |
|
---|
| 94 | /** The value of the info_version field. */
|
---|
| 95 | #define OSX_KMOD_INFO_VERSION INT32_C(1)
|
---|
| 96 |
|
---|
[31510] | 97 | /** @} */
|
---|
| 98 |
|
---|
| 99 |
|
---|
| 100 | /**
|
---|
| 101 | * Linux guest OS digger instance data.
|
---|
| 102 | */
|
---|
[49044] | 103 | typedef struct DBGDIGGERDARWIN
|
---|
[31510] | 104 | {
|
---|
| 105 | /** Whether the information is valid or not.
|
---|
| 106 | * (For fending off illegal interface method calls.) */
|
---|
| 107 | bool fValid;
|
---|
| 108 |
|
---|
[54232] | 109 | /** Set if 64-bit kernel, clear if 32-bit.
|
---|
| 110 | * Set during probing. */
|
---|
| 111 | bool f64Bit;
|
---|
[49044] | 112 | /** The address of an kernel version string (there are several).
|
---|
[31510] | 113 | * This is set during probing. */
|
---|
[49044] | 114 | DBGFADDRESS AddrKernelVersion;
|
---|
[31510] | 115 | /** Kernel base address.
|
---|
| 116 | * This is set during probing. */
|
---|
[49044] | 117 | DBGFADDRESS AddrKernel;
|
---|
[54232] | 118 |
|
---|
| 119 | /** The kernel message log interface. */
|
---|
| 120 | DBGFOSIDMESG IDmesg;
|
---|
[49044] | 121 | } DBGDIGGERDARWIN;
|
---|
[31510] | 122 | /** Pointer to the linux guest OS digger instance data. */
|
---|
[49044] | 123 | typedef DBGDIGGERDARWIN *PDBGDIGGERDARWIN;
|
---|
[31510] | 124 |
|
---|
| 125 |
|
---|
[57358] | 126 | /*********************************************************************************************************************************
|
---|
| 127 | * Defined Constants And Macros *
|
---|
| 128 | *********************************************************************************************************************************/
|
---|
[49075] | 129 | /** Validates a 32-bit darwin kernel address */
|
---|
| 130 | #define OSX32_VALID_ADDRESS(Addr) ((Addr) > UINT32_C(0x00001000) && (Addr) < UINT32_C(0xfffff000))
|
---|
| 131 | /** Validates a 64-bit darwin kernel address */
|
---|
[49081] | 132 | #define OSX64_VALID_ADDRESS(Addr) ((Addr) > UINT64_C(0xffff800000000000) && (Addr) < UINT64_C(0xfffffffffffff000))
|
---|
[49075] | 133 | /** Validates a 32-bit or 64-bit darwin kernel address. */
|
---|
| 134 | #define OSX_VALID_ADDRESS(a_f64Bits, a_Addr) \
|
---|
| 135 | ((a_f64Bits) ? OSX64_VALID_ADDRESS(a_Addr) : OSX32_VALID_ADDRESS(a_Addr))
|
---|
[31510] | 136 |
|
---|
[49044] | 137 | /** AppleOsX on little endian ASCII systems. */
|
---|
| 138 | #define DIG_DARWIN_MOD_TAG UINT64_C(0x58734f656c707041)
|
---|
[31510] | 139 |
|
---|
[49044] | 140 |
|
---|
[57358] | 141 | /*********************************************************************************************************************************
|
---|
| 142 | * Internal Functions *
|
---|
| 143 | *********************************************************************************************************************************/
|
---|
[93470] | 144 | static DECLCALLBACK(int) dbgDiggerDarwinInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData);
|
---|
[31510] | 145 |
|
---|
| 146 |
|
---|
[73460] | 147 |
|
---|
[31510] | 148 | /**
|
---|
[54232] | 149 | * @interface_method_impl{DBGFOSIDMESG,pfnQueryKernelLog}
|
---|
| 150 | */
|
---|
[93470] | 151 | static DECLCALLBACK(int) dbgDiggerDarwinIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, PCVMMR3VTABLE pVMM, uint32_t fFlags,
|
---|
| 152 | uint32_t cMessages, char *pszBuf, size_t cbBuf, size_t *pcbActual)
|
---|
[54232] | 153 | {
|
---|
[62838] | 154 | RT_NOREF1(fFlags);
|
---|
[54232] | 155 | PDBGDIGGERDARWIN pData = RT_FROM_MEMBER(pThis, DBGDIGGERDARWIN, IDmesg);
|
---|
| 156 |
|
---|
| 157 | if (cMessages < 1)
|
---|
| 158 | return VERR_INVALID_PARAMETER;
|
---|
| 159 |
|
---|
| 160 | /*
|
---|
| 161 | * The 'msgbufp' variable points to a struct msgbuf (bsd/kern/subr_log.c).
|
---|
| 162 | */
|
---|
[93470] | 163 | RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
|
---|
[54232] | 164 | RTDBGMOD hMod;
|
---|
| 165 | int rc = RTDbgAsModuleByName(hAs, "mach_kernel", 0, &hMod);
|
---|
| 166 | if (RT_FAILURE(rc))
|
---|
| 167 | return VERR_NOT_FOUND;
|
---|
| 168 | RTDbgAsRelease(hAs);
|
---|
| 169 |
|
---|
| 170 | DBGFADDRESS Addr;
|
---|
| 171 | RTGCPTR GCPtrMsgBufP = 0;
|
---|
| 172 | RTDBGSYMBOL SymInfo;
|
---|
| 173 | rc = RTDbgModSymbolByName(hMod, "_msgbufp", &SymInfo);
|
---|
| 174 | if (RT_SUCCESS(rc))
|
---|
| 175 | {
|
---|
[93470] | 176 | rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
|
---|
| 177 | pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, SymInfo.Value + pData->AddrKernel.FlatPtr),
|
---|
| 178 | &GCPtrMsgBufP, pData->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t));
|
---|
[54232] | 179 | if (RT_FAILURE(rc))
|
---|
| 180 | {
|
---|
[83083] | 181 | LogRel(("dbgDiggerDarwinIDmsg_QueryKernelLog: failed to read _msgbufp at %RGv: %Rrc\n", Addr.FlatPtr, rc));
|
---|
[54232] | 182 | return VERR_NOT_FOUND;
|
---|
| 183 | }
|
---|
| 184 | if (!OSX_VALID_ADDRESS(pData->f64Bit, GCPtrMsgBufP))
|
---|
| 185 | {
|
---|
[83083] | 186 | LogRel(("dbgDiggerDarwinIDmsg_QueryKernelLog: Invalid address for _msgbufp: %RGv\n", GCPtrMsgBufP));
|
---|
[54232] | 187 | return VERR_NOT_FOUND;
|
---|
| 188 | }
|
---|
| 189 | }
|
---|
| 190 | else
|
---|
| 191 | {
|
---|
| 192 | rc = RTDbgModSymbolByName(hMod, "_msgbuf", &SymInfo);
|
---|
| 193 | if (RT_FAILURE(rc))
|
---|
| 194 | {
|
---|
[83083] | 195 | LogRel(("dbgDiggerDarwinIDmsg_QueryKernelLog: failed to find _msgbufp and _msgbuf: %Rrc\n", rc));
|
---|
[54232] | 196 | return VERR_NOT_FOUND;
|
---|
| 197 | }
|
---|
| 198 | GCPtrMsgBufP = SymInfo.Value + pData->AddrKernel.FlatPtr;
|
---|
| 199 | if (!OSX_VALID_ADDRESS(pData->f64Bit, GCPtrMsgBufP))
|
---|
| 200 | {
|
---|
[83083] | 201 | LogRel(("dbgDiggerDarwinIDmsg_QueryKernelLog: Invalid address for _msgbuf: %RGv\n", GCPtrMsgBufP));
|
---|
[54232] | 202 | return VERR_NOT_FOUND;
|
---|
| 203 | }
|
---|
| 204 | }
|
---|
| 205 |
|
---|
| 206 | /*
|
---|
| 207 | * Read the msgbuf structure.
|
---|
| 208 | */
|
---|
| 209 | struct
|
---|
| 210 | {
|
---|
| 211 | uint32_t msg_magic;
|
---|
| 212 | uint32_t msg_size;
|
---|
| 213 | uint32_t msg_bufx;
|
---|
| 214 | uint32_t msg_bufr;
|
---|
| 215 | uint64_t msg_bufc; /**< Size depends on windows size. */
|
---|
| 216 | } MsgBuf;
|
---|
[93470] | 217 | rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, GCPtrMsgBufP),
|
---|
| 218 | &MsgBuf, sizeof(MsgBuf) - (pData->f64Bit ? 0 : sizeof(uint32_t)) );
|
---|
[54232] | 219 | if (RT_FAILURE(rc))
|
---|
| 220 | {
|
---|
[83083] | 221 | LogRel(("dbgDiggerDarwinIDmsg_QueryKernelLog: failed to read msgbuf struct at %RGv: %Rrc\n", Addr.FlatPtr, rc));
|
---|
[54232] | 222 | return VERR_NOT_FOUND;
|
---|
| 223 | }
|
---|
| 224 | if (!pData->f64Bit)
|
---|
| 225 | MsgBuf.msg_bufc &= UINT32_MAX;
|
---|
| 226 |
|
---|
| 227 | /*
|
---|
| 228 | * Validate the structure.
|
---|
| 229 | */
|
---|
| 230 | if ( MsgBuf.msg_magic != UINT32_C(0x63061)
|
---|
| 231 | || MsgBuf.msg_size < UINT32_C(4096)
|
---|
| 232 | || MsgBuf.msg_size > 16*_1M
|
---|
| 233 | || MsgBuf.msg_bufx > MsgBuf.msg_size
|
---|
| 234 | || MsgBuf.msg_bufr > MsgBuf.msg_size
|
---|
| 235 | || !OSX_VALID_ADDRESS(pData->f64Bit, MsgBuf.msg_bufc) )
|
---|
| 236 | {
|
---|
[83083] | 237 | LogRel(("dbgDiggerDarwinIDmsg_QueryKernelLog: Invalid MsgBuf data: magic=%#x size=%#x bufx=%#x bufr=%#x bufc=%RGv\n",
|
---|
| 238 | MsgBuf.msg_magic, MsgBuf.msg_size, MsgBuf.msg_bufx, MsgBuf.msg_bufr, MsgBuf.msg_bufc));
|
---|
[54232] | 239 | return VERR_INVALID_STATE;
|
---|
| 240 | }
|
---|
| 241 |
|
---|
| 242 | /*
|
---|
| 243 | * Read the buffer.
|
---|
| 244 | */
|
---|
| 245 | char *pchMsgBuf = (char *)RTMemAlloc(MsgBuf.msg_size);
|
---|
| 246 | if (!pchMsgBuf)
|
---|
| 247 | {
|
---|
[83083] | 248 | LogRel(("dbgDiggerDarwinIDmsg_QueryKernelLog: Failed to allocate %#x bytes of memory for the log buffer\n",
|
---|
| 249 | MsgBuf.msg_size));
|
---|
[54232] | 250 | return VERR_INVALID_STATE;
|
---|
| 251 | }
|
---|
[93470] | 252 | rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
|
---|
| 253 | pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, MsgBuf.msg_bufc), pchMsgBuf, MsgBuf.msg_size);
|
---|
[54232] | 254 | if (RT_SUCCESS(rc))
|
---|
| 255 | {
|
---|
| 256 | /*
|
---|
| 257 | * Copy it out raw.
|
---|
| 258 | */
|
---|
| 259 | uint32_t offDst = 0;
|
---|
| 260 | if (MsgBuf.msg_bufr < MsgBuf.msg_bufx)
|
---|
| 261 | {
|
---|
| 262 | /* Single chunk between the read and write offsets. */
|
---|
| 263 | uint32_t cbToCopy = MsgBuf.msg_bufx - MsgBuf.msg_bufr;
|
---|
| 264 | if (cbToCopy < cbBuf)
|
---|
| 265 | {
|
---|
| 266 | memcpy(pszBuf, &pchMsgBuf[MsgBuf.msg_bufr], cbToCopy);
|
---|
| 267 | pszBuf[cbToCopy] = '\0';
|
---|
| 268 | rc = VINF_SUCCESS;
|
---|
| 269 | }
|
---|
| 270 | else
|
---|
| 271 | {
|
---|
| 272 | if (cbBuf)
|
---|
| 273 | {
|
---|
| 274 | memcpy(pszBuf, &pchMsgBuf[MsgBuf.msg_bufr], cbBuf - 1);
|
---|
| 275 | pszBuf[cbBuf - 1] = '\0';
|
---|
| 276 | }
|
---|
| 277 | rc = VERR_BUFFER_OVERFLOW;
|
---|
| 278 | }
|
---|
| 279 | offDst = cbToCopy + 1;
|
---|
| 280 | }
|
---|
| 281 | else
|
---|
| 282 | {
|
---|
| 283 | /* Two chunks, read offset to end, start to write offset. */
|
---|
| 284 | uint32_t cbFirst = MsgBuf.msg_size - MsgBuf.msg_bufr;
|
---|
| 285 | uint32_t cbSecond = MsgBuf.msg_bufx;
|
---|
| 286 | if (cbFirst + cbSecond < cbBuf)
|
---|
| 287 | {
|
---|
| 288 | memcpy(pszBuf, &pchMsgBuf[MsgBuf.msg_bufr], cbFirst);
|
---|
| 289 | memcpy(&pszBuf[cbFirst], pchMsgBuf, cbSecond);
|
---|
| 290 | offDst = cbFirst + cbSecond;
|
---|
| 291 | pszBuf[offDst++] = '\0';
|
---|
| 292 | rc = VINF_SUCCESS;
|
---|
| 293 | }
|
---|
| 294 | else
|
---|
| 295 | {
|
---|
| 296 | offDst = cbFirst + cbSecond + 1;
|
---|
| 297 | if (cbFirst < cbBuf)
|
---|
| 298 | {
|
---|
| 299 | memcpy(pszBuf, &pchMsgBuf[MsgBuf.msg_bufr], cbFirst);
|
---|
| 300 | memcpy(&pszBuf[cbFirst], pchMsgBuf, cbBuf - cbFirst);
|
---|
| 301 | pszBuf[cbBuf - 1] = '\0';
|
---|
| 302 | }
|
---|
| 303 | else if (cbBuf)
|
---|
| 304 | {
|
---|
| 305 | memcpy(pszBuf, &pchMsgBuf[MsgBuf.msg_bufr], cbBuf - 1);
|
---|
| 306 | pszBuf[cbBuf - 1] = '\0';
|
---|
| 307 | }
|
---|
| 308 | rc = VERR_BUFFER_OVERFLOW;
|
---|
| 309 | }
|
---|
| 310 | }
|
---|
| 311 |
|
---|
| 312 | if (pcbActual)
|
---|
| 313 | *pcbActual = offDst;
|
---|
| 314 | }
|
---|
| 315 | else
|
---|
[83083] | 316 | LogRel(("dbgDiggerDarwinIDmsg_QueryKernelLog: Error reading %#x bytes at %RGv: %Rrc\n",
|
---|
| 317 | MsgBuf.msg_size, MsgBuf.msg_bufc, rc));
|
---|
[54232] | 318 | RTMemFree(pchMsgBuf);
|
---|
| 319 | return rc;
|
---|
| 320 | }
|
---|
| 321 |
|
---|
| 322 |
|
---|
| 323 | /**
|
---|
[73460] | 324 | * @copydoc DBGFOSREG::pfnStackUnwindAssist
|
---|
| 325 | */
|
---|
[93470] | 326 | static DECLCALLBACK(int) dbgDiggerDarwinStackUnwindAssist(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, VMCPUID idCpu,
|
---|
| 327 | PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState, PCCPUMCTX pInitialCtx,
|
---|
| 328 | RTDBGAS hAs, uint64_t *puScratch)
|
---|
[73460] | 329 | {
|
---|
[93470] | 330 | RT_NOREF(pUVM, pVMM, pvData, idCpu, pFrame, pState, pInitialCtx, hAs, puScratch);
|
---|
[73460] | 331 | return VINF_SUCCESS;
|
---|
| 332 | }
|
---|
| 333 |
|
---|
| 334 |
|
---|
| 335 | /**
|
---|
[31510] | 336 | * @copydoc DBGFOSREG::pfnQueryInterface
|
---|
| 337 | */
|
---|
[93470] | 338 | static DECLCALLBACK(void *) dbgDiggerDarwinQueryInterface(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData, DBGFOSINTERFACE enmIf)
|
---|
[31510] | 339 | {
|
---|
[93470] | 340 | RT_NOREF(pUVM, pVMM);
|
---|
[54232] | 341 | PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
|
---|
| 342 | switch (enmIf)
|
---|
| 343 | {
|
---|
| 344 | case DBGFOSINTERFACE_DMESG:
|
---|
| 345 | return &pThis->IDmesg;
|
---|
| 346 |
|
---|
| 347 | default:
|
---|
| 348 | return NULL;
|
---|
| 349 | }
|
---|
[31510] | 350 | }
|
---|
| 351 |
|
---|
| 352 |
|
---|
| 353 | /**
|
---|
| 354 | * @copydoc DBGFOSREG::pfnQueryVersion
|
---|
| 355 | */
|
---|
[93470] | 356 | static DECLCALLBACK(int) dbgDiggerDarwinQueryVersion(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData,
|
---|
| 357 | char *pszVersion, size_t cchVersion)
|
---|
[31510] | 358 | {
|
---|
[49044] | 359 | PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
|
---|
[31510] | 360 | Assert(pThis->fValid);
|
---|
| 361 |
|
---|
| 362 | /*
|
---|
| 363 | * It's all in the linux banner.
|
---|
| 364 | */
|
---|
[93470] | 365 | int rc = pVMM->pfnDBGFR3MemReadString(pUVM, 0, &pThis->AddrKernelVersion, pszVersion, cchVersion);
|
---|
[31510] | 366 | if (RT_SUCCESS(rc))
|
---|
| 367 | {
|
---|
| 368 | char *pszEnd = RTStrEnd(pszVersion, cchVersion);
|
---|
| 369 | AssertReturn(pszEnd, VERR_BUFFER_OVERFLOW);
|
---|
| 370 | while ( pszEnd > pszVersion
|
---|
| 371 | && RT_C_IS_SPACE(pszEnd[-1]))
|
---|
| 372 | pszEnd--;
|
---|
| 373 | *pszEnd = '\0';
|
---|
| 374 | }
|
---|
| 375 | else
|
---|
| 376 | RTStrPrintf(pszVersion, cchVersion, "DBGFR3MemRead -> %Rrc", rc);
|
---|
| 377 |
|
---|
| 378 | return rc;
|
---|
| 379 | }
|
---|
| 380 |
|
---|
| 381 |
|
---|
| 382 | /**
|
---|
| 383 | * @copydoc DBGFOSREG::pfnTerm
|
---|
| 384 | */
|
---|
[93470] | 385 | static DECLCALLBACK(void) dbgDiggerDarwinTerm(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
|
---|
[31510] | 386 | {
|
---|
[93470] | 387 | RT_NOREF(pUVM, pVMM);
|
---|
[49044] | 388 | PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
|
---|
[31510] | 389 |
|
---|
| 390 | pThis->fValid = false;
|
---|
| 391 | }
|
---|
| 392 |
|
---|
| 393 |
|
---|
| 394 | /**
|
---|
| 395 | * @copydoc DBGFOSREG::pfnRefresh
|
---|
| 396 | */
|
---|
[93470] | 397 | static DECLCALLBACK(int) dbgDiggerDarwinRefresh(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
|
---|
[31510] | 398 | {
|
---|
[49044] | 399 | PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
|
---|
[31510] | 400 | NOREF(pThis);
|
---|
| 401 | Assert(pThis->fValid);
|
---|
| 402 |
|
---|
| 403 | /*
|
---|
| 404 | * For now we'll flush and reload everything.
|
---|
| 405 | */
|
---|
[93470] | 406 | dbgDiggerDarwinTerm(pUVM, pVMM, pvData);
|
---|
| 407 | return dbgDiggerDarwinInit(pUVM, pVMM, pvData);
|
---|
[31510] | 408 | }
|
---|
| 409 |
|
---|
| 410 |
|
---|
| 411 | /**
|
---|
[83083] | 412 | * Helper function that tries to accertain whether a segment (__LINKEDIT) is
|
---|
| 413 | * present or not.
|
---|
| 414 | *
|
---|
| 415 | * @returns true if present, false if not.
|
---|
| 416 | * @param pUVM The user mode VM structure.
|
---|
[93470] | 417 | * @param pVMM The VMM function table.
|
---|
[83083] | 418 | * @param uSegAddr The segment addresss.
|
---|
| 419 | * @param cbSeg The segment size.
|
---|
| 420 | * @param uMinAddr Lowest allowed address.
|
---|
| 421 | * @param uMaxAddr Highest allowed address.
|
---|
| 422 | */
|
---|
[93470] | 423 | static bool dbgDiggerDarwinIsSegmentPresent(PUVM pUVM, PCVMMR3VTABLE pVMM, uint64_t uSegAddr, uint64_t cbSeg,
|
---|
| 424 | uint64_t uMinAddr, uint64_t uMaxAddr)
|
---|
[83083] | 425 | {
|
---|
| 426 | /*
|
---|
| 427 | * Validate the size and address.
|
---|
| 428 | */
|
---|
| 429 | if (cbSeg < 32)
|
---|
| 430 | {
|
---|
| 431 | LogRel(("OSXDig: __LINKEDIT too small %#RX64\n", cbSeg));
|
---|
| 432 | return false;
|
---|
| 433 | }
|
---|
| 434 | if (cbSeg > uMaxAddr - uMinAddr)
|
---|
| 435 | {
|
---|
| 436 | LogRel(("OSXDig: __LINKEDIT too big %#RX64, max %#RX64\n", cbSeg, uMaxAddr - uMinAddr));
|
---|
| 437 | return false;
|
---|
| 438 | }
|
---|
| 439 |
|
---|
| 440 | if (uSegAddr < uMinAddr)
|
---|
| 441 | {
|
---|
| 442 | LogRel(("OSXDig: __LINKEDIT too low %#RX64, min %#RX64\n", uSegAddr, uMinAddr));
|
---|
| 443 | return false;
|
---|
| 444 | }
|
---|
| 445 | if (uSegAddr > uMaxAddr)
|
---|
| 446 | {
|
---|
| 447 | LogRel(("OSXDig: __LINKEDIT too high %#RX64, max %#RX64\n", uSegAddr, uMaxAddr));
|
---|
| 448 | return false;
|
---|
| 449 | }
|
---|
| 450 | if (uSegAddr + cbSeg > uMaxAddr)
|
---|
| 451 | {
|
---|
| 452 | LogRel(("OSXDig: __LINKEDIT ends too high %#RX64 (%#RX64+%#RX64), max %#RX64\n",
|
---|
| 453 | uSegAddr + cbSeg, uSegAddr, cbSeg, uMaxAddr));
|
---|
| 454 | return false;
|
---|
| 455 | }
|
---|
| 456 |
|
---|
| 457 | /*
|
---|
| 458 | * Check that all the pages are present.
|
---|
| 459 | */
|
---|
[102855] | 460 | cbSeg += uSegAddr & GUEST_PAGE_OFFSET_MASK;
|
---|
| 461 | uSegAddr &= ~(uint64_t)GUEST_PAGE_OFFSET_MASK;
|
---|
[83083] | 462 | for (;;)
|
---|
| 463 | {
|
---|
| 464 | uint8_t abBuf[8];
|
---|
| 465 | DBGFADDRESS Addr;
|
---|
[93470] | 466 | int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &Addr, uSegAddr),
|
---|
| 467 | abBuf, sizeof(abBuf));
|
---|
[83083] | 468 | if (RT_FAILURE(rc))
|
---|
| 469 | {
|
---|
| 470 | LogRel(("OSXDig: __LINKEDIT read error at %#RX64: %Rrc\n", uSegAddr, rc));
|
---|
| 471 | return false;
|
---|
| 472 | }
|
---|
| 473 |
|
---|
| 474 | /* Advance */
|
---|
[102855] | 475 | if (cbSeg <= GUEST_PAGE_SIZE)
|
---|
[83083] | 476 | return true;
|
---|
[102855] | 477 | cbSeg -= GUEST_PAGE_SIZE;
|
---|
| 478 | uSegAddr += GUEST_PAGE_SIZE;
|
---|
[83083] | 479 | }
|
---|
| 480 | }
|
---|
| 481 |
|
---|
| 482 |
|
---|
| 483 | /**
|
---|
[49044] | 484 | * Helper function that validates a segment (or section) name.
|
---|
| 485 | *
|
---|
| 486 | * @returns true if valid, false if not.
|
---|
| 487 | * @param pszName The name string.
|
---|
| 488 | * @param cbName The size of the string, including terminator.
|
---|
| 489 | */
|
---|
| 490 | static bool dbgDiggerDarwinIsValidSegOrSectName(const char *pszName, size_t cbName)
|
---|
| 491 | {
|
---|
| 492 | /* ascii chars */
|
---|
| 493 | char ch;
|
---|
| 494 | size_t off = 0;
|
---|
| 495 | while (off < cbName && (ch = pszName[off]))
|
---|
| 496 | {
|
---|
[49081] | 497 | if (RT_C_IS_CNTRL(ch) || ch >= 127)
|
---|
[49044] | 498 | return false;
|
---|
| 499 | off++;
|
---|
| 500 | }
|
---|
| 501 |
|
---|
| 502 | /* Not empty nor 100% full. */
|
---|
| 503 | if (off == 0 || off == cbName)
|
---|
| 504 | return false;
|
---|
| 505 |
|
---|
| 506 | /* remainder should be zeros. */
|
---|
| 507 | while (off < cbName)
|
---|
| 508 | {
|
---|
| 509 | if (pszName[off])
|
---|
| 510 | return false;
|
---|
| 511 | off++;
|
---|
| 512 | }
|
---|
| 513 |
|
---|
| 514 | return true;
|
---|
| 515 | }
|
---|
| 516 |
|
---|
| 517 |
|
---|
[93470] | 518 | static int dbgDiggerDarwinAddModule(PDBGDIGGERDARWIN pThis, PUVM pUVM, PCVMMR3VTABLE pVMM,
|
---|
| 519 | uint64_t uModAddr, const char *pszName, bool *pf64Bit)
|
---|
[49044] | 520 | {
|
---|
[62838] | 521 | RT_NOREF1(pThis);
|
---|
[49044] | 522 | union
|
---|
| 523 | {
|
---|
[102855] | 524 | uint8_t ab[2 * GUEST_PAGE_SIZE];
|
---|
[49044] | 525 | mach_header_64_t Hdr64;
|
---|
| 526 | mach_header_32_t Hdr32;
|
---|
| 527 | } uBuf;
|
---|
| 528 |
|
---|
| 529 | /* Read the first page of the image. */
|
---|
| 530 | DBGFADDRESS ModAddr;
|
---|
[93470] | 531 | int rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/,
|
---|
[102855] | 532 | pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModAddr, uModAddr), uBuf.ab, GUEST_PAGE_SIZE);
|
---|
[49044] | 533 | if (RT_FAILURE(rc))
|
---|
| 534 | return rc;
|
---|
| 535 |
|
---|
| 536 | /* Validate the header. */
|
---|
| 537 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, magic, mach_header_32_t, magic);
|
---|
| 538 | if ( uBuf.Hdr64.magic != IMAGE_MACHO64_SIGNATURE
|
---|
| 539 | && uBuf.Hdr32.magic != IMAGE_MACHO32_SIGNATURE)
|
---|
| 540 | return VERR_INVALID_EXE_SIGNATURE;
|
---|
| 541 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, cputype, mach_header_32_t, cputype);
|
---|
| 542 | bool f64Bit = uBuf.Hdr64.magic == IMAGE_MACHO64_SIGNATURE;
|
---|
| 543 | if (uBuf.Hdr32.cputype != (f64Bit ? CPU_TYPE_X86_64 : CPU_TYPE_I386))
|
---|
| 544 | return VERR_LDR_ARCH_MISMATCH;
|
---|
| 545 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, filetype, mach_header_32_t, filetype);
|
---|
| 546 | if ( uBuf.Hdr32.filetype != MH_EXECUTE
|
---|
| 547 | && uBuf.Hdr32.filetype != (f64Bit ? MH_KEXT_BUNDLE : MH_OBJECT))
|
---|
| 548 | return VERR_BAD_EXE_FORMAT;
|
---|
| 549 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, ncmds, mach_header_32_t, ncmds);
|
---|
| 550 | if (uBuf.Hdr32.ncmds > 256)
|
---|
| 551 | return VERR_BAD_EXE_FORMAT;
|
---|
| 552 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, sizeofcmds, mach_header_32_t, sizeofcmds);
|
---|
[102855] | 553 | if (uBuf.Hdr32.sizeofcmds > GUEST_PAGE_SIZE * 2 - sizeof(mach_header_64_t))
|
---|
[49044] | 554 | return VERR_BAD_EXE_FORMAT;
|
---|
| 555 |
|
---|
| 556 | /* Do we need to read a 2nd page to get all the load commands? If so, do it. */
|
---|
[102855] | 557 | if (uBuf.Hdr32.sizeofcmds + (f64Bit ? sizeof(mach_header_64_t) : sizeof(mach_header_32_t)) > GUEST_PAGE_SIZE)
|
---|
[49044] | 558 | {
|
---|
[102855] | 559 | rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &ModAddr, uModAddr + GUEST_PAGE_SIZE),
|
---|
| 560 | &uBuf.ab[GUEST_PAGE_SIZE], GUEST_PAGE_SIZE);
|
---|
[49044] | 561 | if (RT_FAILURE(rc))
|
---|
| 562 | return rc;
|
---|
| 563 | }
|
---|
| 564 |
|
---|
| 565 | /*
|
---|
| 566 | * Process the load commands.
|
---|
| 567 | */
|
---|
[83084] | 568 | RTUUID Uuid = RTUUID_INITIALIZE_NULL;
|
---|
[50616] | 569 | RTDBGSEGMENT aSegs[24];
|
---|
[49044] | 570 | uint32_t cSegs = 0;
|
---|
[83084] | 571 | bool fHasLinkEdit = false;
|
---|
[49044] | 572 | uint32_t cLeft = uBuf.Hdr32.ncmds;
|
---|
| 573 | uint32_t cbLeft = uBuf.Hdr32.sizeofcmds;
|
---|
| 574 | union
|
---|
| 575 | {
|
---|
| 576 | uint8_t const *pb;
|
---|
| 577 | load_command_t const *pGenric;
|
---|
| 578 | segment_command_32_t const *pSeg32;
|
---|
| 579 | segment_command_64_t const *pSeg64;
|
---|
| 580 | uuid_command_t const *pUuid;
|
---|
| 581 | } uLCmd;
|
---|
| 582 | uLCmd.pb = &uBuf.ab[f64Bit ? sizeof(mach_header_64_t) : sizeof(mach_header_32_t)];
|
---|
| 583 |
|
---|
| 584 | while (cLeft-- > 0)
|
---|
| 585 | {
|
---|
| 586 | uint32_t const cbCmd = uLCmd.pGenric->cmdsize;
|
---|
| 587 | if (cbCmd > cbLeft || cbCmd < sizeof(load_command_t))
|
---|
| 588 | return VERR_BAD_EXE_FORMAT;
|
---|
| 589 |
|
---|
| 590 | switch (uLCmd.pGenric->cmd)
|
---|
| 591 | {
|
---|
| 592 | case LC_SEGMENT_32:
|
---|
| 593 | if (cbCmd != sizeof(segment_command_32_t) + uLCmd.pSeg32->nsects * sizeof(section_32_t))
|
---|
| 594 | return VERR_BAD_EXE_FORMAT;
|
---|
| 595 | if (!dbgDiggerDarwinIsValidSegOrSectName(uLCmd.pSeg32->segname, sizeof(uLCmd.pSeg32->segname)))
|
---|
| 596 | return VERR_INVALID_NAME;
|
---|
[83083] | 597 | if ( !strcmp(uLCmd.pSeg32->segname, "__LINKEDIT")
|
---|
[93470] | 598 | && !(fHasLinkEdit = dbgDiggerDarwinIsSegmentPresent(pUVM, pVMM, uLCmd.pSeg32->vmaddr, uLCmd.pSeg32->vmsize,
|
---|
[83084] | 599 | uModAddr, uModAddr + _64M)))
|
---|
[49061] | 600 | break; /* This usually is discarded or not loaded at all. */
|
---|
[49044] | 601 | if (cSegs >= RT_ELEMENTS(aSegs))
|
---|
| 602 | return VERR_BUFFER_OVERFLOW;
|
---|
| 603 | aSegs[cSegs].Address = uLCmd.pSeg32->vmaddr;
|
---|
| 604 | aSegs[cSegs].uRva = uLCmd.pSeg32->vmaddr - uModAddr;
|
---|
| 605 | aSegs[cSegs].cb = uLCmd.pSeg32->vmsize;
|
---|
| 606 | aSegs[cSegs].fFlags = uLCmd.pSeg32->flags; /* Abusing the flags field here... */
|
---|
| 607 | aSegs[cSegs].iSeg = cSegs;
|
---|
| 608 | AssertCompile(RTDBG_SEGMENT_NAME_LENGTH > sizeof(uLCmd.pSeg32->segname));
|
---|
| 609 | strcpy(aSegs[cSegs].szName, uLCmd.pSeg32->segname);
|
---|
| 610 | cSegs++;
|
---|
| 611 | break;
|
---|
| 612 |
|
---|
| 613 | case LC_SEGMENT_64:
|
---|
| 614 | if (cbCmd != sizeof(segment_command_64_t) + uLCmd.pSeg64->nsects * sizeof(section_64_t))
|
---|
| 615 | return VERR_BAD_EXE_FORMAT;
|
---|
| 616 | if (!dbgDiggerDarwinIsValidSegOrSectName(uLCmd.pSeg64->segname, sizeof(uLCmd.pSeg64->segname)))
|
---|
| 617 | return VERR_INVALID_NAME;
|
---|
[83083] | 618 | if ( !strcmp(uLCmd.pSeg64->segname, "__LINKEDIT")
|
---|
[93470] | 619 | && !(fHasLinkEdit = dbgDiggerDarwinIsSegmentPresent(pUVM, pVMM, uLCmd.pSeg64->vmaddr, uLCmd.pSeg64->vmsize,
|
---|
[83084] | 620 | uModAddr, uModAddr + _128M)))
|
---|
[49061] | 621 | break; /* This usually is discarded or not loaded at all. */
|
---|
[49044] | 622 | if (cSegs >= RT_ELEMENTS(aSegs))
|
---|
| 623 | return VERR_BUFFER_OVERFLOW;
|
---|
| 624 | aSegs[cSegs].Address = uLCmd.pSeg64->vmaddr;
|
---|
| 625 | aSegs[cSegs].uRva = uLCmd.pSeg64->vmaddr - uModAddr;
|
---|
| 626 | aSegs[cSegs].cb = uLCmd.pSeg64->vmsize;
|
---|
| 627 | aSegs[cSegs].fFlags = uLCmd.pSeg64->flags; /* Abusing the flags field here... */
|
---|
| 628 | aSegs[cSegs].iSeg = cSegs;
|
---|
| 629 | AssertCompile(RTDBG_SEGMENT_NAME_LENGTH > sizeof(uLCmd.pSeg64->segname));
|
---|
| 630 | strcpy(aSegs[cSegs].szName, uLCmd.pSeg64->segname);
|
---|
| 631 | cSegs++;
|
---|
| 632 | break;
|
---|
| 633 |
|
---|
| 634 | case LC_UUID:
|
---|
| 635 | if (cbCmd != sizeof(uuid_command_t))
|
---|
| 636 | return VERR_BAD_EXE_FORMAT;
|
---|
| 637 | if (RTUuidIsNull((PCRTUUID)&uLCmd.pUuid->uuid[0]))
|
---|
| 638 | return VERR_BAD_EXE_FORMAT;
|
---|
| 639 | memcpy(&Uuid, &uLCmd.pUuid->uuid[0], sizeof(uLCmd.pUuid->uuid));
|
---|
| 640 | break;
|
---|
| 641 |
|
---|
| 642 | default:
|
---|
| 643 | /* Current known max plus a lot of slack. */
|
---|
| 644 | if (uLCmd.pGenric->cmd > LC_DYLIB_CODE_SIGN_DRS + 32)
|
---|
| 645 | return VERR_BAD_EXE_FORMAT;
|
---|
| 646 | break;
|
---|
| 647 | }
|
---|
| 648 |
|
---|
| 649 | /* next */
|
---|
| 650 | cbLeft -= cbCmd;
|
---|
| 651 | uLCmd.pb += cbCmd;
|
---|
| 652 | }
|
---|
| 653 |
|
---|
| 654 | if (cbLeft != 0)
|
---|
[83084] | 655 | {
|
---|
| 656 | LogRel(("OSXDig: uModAddr=%#RX64 - %u bytes of command left over!\n", uModAddr, cbLeft));
|
---|
[49044] | 657 | return VERR_BAD_EXE_FORMAT;
|
---|
[83084] | 658 | }
|
---|
[49044] | 659 |
|
---|
| 660 | /*
|
---|
| 661 | * Some post processing checks.
|
---|
| 662 | */
|
---|
| 663 | uint32_t iSeg;
|
---|
| 664 | for (iSeg = 0; iSeg < cSegs; iSeg++)
|
---|
| 665 | if (aSegs[iSeg].Address == uModAddr)
|
---|
| 666 | break;
|
---|
| 667 | if (iSeg >= cSegs)
|
---|
[83083] | 668 | {
|
---|
| 669 | LogRel2(("OSXDig: uModAddr=%#RX64 was not found among the segments segments\n", uModAddr));
|
---|
[49044] | 670 | return VERR_ADDRESS_CONFLICT;
|
---|
[83083] | 671 | }
|
---|
[49044] | 672 |
|
---|
| 673 | /*
|
---|
| 674 | * Create a debug module.
|
---|
| 675 | */
|
---|
| 676 | RTDBGMOD hMod;
|
---|
[83085] | 677 | rc = RTDbgModCreateFromMachOImage(&hMod, pszName, NULL, f64Bit ? RTLDRARCH_AMD64 : RTLDRARCH_X86_32, NULL /*phLdrModIn*/,
|
---|
[93470] | 678 | 0 /*cbImage*/, cSegs, aSegs, &Uuid, pVMM->pfnDBGFR3AsGetConfig(pUVM),
|
---|
[83084] | 679 | RTDBGMOD_F_NOT_DEFERRED | (fHasLinkEdit ? RTDBGMOD_F_MACHO_LOAD_LINKEDIT : 0));
|
---|
[49044] | 680 |
|
---|
[83085] | 681 |
|
---|
| 682 | /*
|
---|
| 683 | * If module creation failed and we've got a linkedit segment, try open the
|
---|
| 684 | * image in-memory, because that will at a minimum give us symbol table symbols.
|
---|
| 685 | */
|
---|
| 686 | if (RT_FAILURE(rc) && fHasLinkEdit)
|
---|
| 687 | {
|
---|
| 688 | DBGFADDRESS DbgfAddr;
|
---|
| 689 | RTERRINFOSTATIC ErrInfo;
|
---|
[93470] | 690 | rc = pVMM->pfnDBGFR3ModInMem(pUVM, pVMM->pfnDBGFR3AddrFromFlat(pUVM, &DbgfAddr, uModAddr),
|
---|
| 691 | DBGFMODINMEM_F_NO_CONTAINER_FALLBACK,
|
---|
| 692 | pszName, NULL /*pszFilename*/, f64Bit ? RTLDRARCH_AMD64 : RTLDRARCH_X86_32, 0 /*cbImage */,
|
---|
| 693 | &hMod, RTErrInfoInitStatic(&ErrInfo));
|
---|
[83085] | 694 | if (RT_FAILURE(rc))
|
---|
| 695 | LogRel(("OSXDig: Failed to do an in-memory-opening of '%s' at %#RX64: %Rrc%s%s\n", pszName, uModAddr, rc,
|
---|
| 696 | RTErrInfoIsSet(&ErrInfo.Core) ? " - " : "", RTErrInfoIsSet(&ErrInfo.Core) ? ErrInfo.Core.pszMsg : ""));
|
---|
| 697 | }
|
---|
| 698 |
|
---|
| 699 | /*
|
---|
| 700 | * Final fallback is a container module.
|
---|
| 701 | */
|
---|
[49044] | 702 | if (RT_FAILURE(rc))
|
---|
| 703 | {
|
---|
| 704 | rc = RTDbgModCreate(&hMod, pszName, 0, 0);
|
---|
| 705 | if (RT_FAILURE(rc))
|
---|
| 706 | return rc;
|
---|
| 707 |
|
---|
| 708 | uint64_t uRvaNext = 0;
|
---|
| 709 | for (iSeg = 0; iSeg < cSegs && RT_SUCCESS(rc); iSeg++)
|
---|
| 710 | {
|
---|
| 711 | if ( aSegs[iSeg].uRva > uRvaNext
|
---|
| 712 | && aSegs[iSeg].uRva - uRvaNext < _1M)
|
---|
| 713 | uRvaNext = aSegs[iSeg].uRva;
|
---|
| 714 | rc = RTDbgModSegmentAdd(hMod, aSegs[iSeg].uRva, aSegs[iSeg].cb, aSegs[iSeg].szName, 0, NULL);
|
---|
| 715 | if (aSegs[iSeg].cb > 0 && RT_SUCCESS(rc))
|
---|
| 716 | {
|
---|
[103424] | 717 | static const char s_szSuffix[] = "_start";
|
---|
| 718 | size_t const cchName = RTStrNLen(aSegs[iSeg].szName, sizeof(aSegs[iSeg].szName));
|
---|
| 719 | char szTmp[sizeof(aSegs[iSeg].szName) + sizeof(s_szSuffix)];
|
---|
| 720 | memcpy(mempcpy(szTmp, aSegs[iSeg].szName, cchName), s_szSuffix, sizeof(s_szSuffix));
|
---|
| 721 | rc = RTDbgModSymbolAdd(hMod, szTmp, iSeg, 0 /*uRva*/, 0 /*cb*/, 0 /*fFlags*/, NULL);
|
---|
[49044] | 722 | }
|
---|
| 723 | uRvaNext += aSegs[iSeg].cb;
|
---|
| 724 | }
|
---|
| 725 |
|
---|
| 726 | if (RT_FAILURE(rc))
|
---|
| 727 | {
|
---|
| 728 | RTDbgModRelease(hMod);
|
---|
| 729 | return rc;
|
---|
| 730 | }
|
---|
| 731 | }
|
---|
| 732 |
|
---|
| 733 | /* Tag the module. */
|
---|
| 734 | rc = RTDbgModSetTag(hMod, DIG_DARWIN_MOD_TAG);
|
---|
| 735 | AssertRC(rc);
|
---|
| 736 |
|
---|
| 737 | /*
|
---|
| 738 | * Link the module.
|
---|
| 739 | */
|
---|
[93470] | 740 | RTDBGAS hAs = pVMM->pfnDBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
|
---|
[49044] | 741 | if (hAs != NIL_RTDBGAS)
|
---|
| 742 | {
|
---|
[62838] | 743 | //uint64_t uRvaNext = 0; - what was this?
|
---|
[49044] | 744 | uint32_t cLinked = 0;
|
---|
[49061] | 745 | iSeg = cSegs;
|
---|
| 746 | while (iSeg-- > 0) /* HACK: Map in reverse order to avoid replacing __TEXT. */
|
---|
[49044] | 747 | if (aSegs[iSeg].cb)
|
---|
| 748 | {
|
---|
[49061] | 749 | /* Find matching segment in the debug module. */
|
---|
| 750 | uint32_t iDbgSeg = 0;
|
---|
| 751 | while (iDbgSeg < cSegs)
|
---|
| 752 | {
|
---|
| 753 | RTDBGSEGMENT SegInfo;
|
---|
| 754 | int rc3 = RTDbgModSegmentByIndex(hMod, iDbgSeg, &SegInfo);
|
---|
| 755 | if (RT_SUCCESS(rc3) && !strcmp(SegInfo.szName, aSegs[iSeg].szName))
|
---|
| 756 | break;
|
---|
| 757 | iDbgSeg++;
|
---|
| 758 | }
|
---|
| 759 | AssertMsgStmt(iDbgSeg < cSegs, ("%s\n", aSegs[iSeg].szName), continue);
|
---|
| 760 |
|
---|
| 761 | /* Map it. */
|
---|
| 762 | int rc2 = RTDbgAsModuleLinkSeg(hAs, hMod, iDbgSeg, aSegs[iSeg].Address, RTDBGASLINK_FLAGS_REPLACE /*fFlags*/);
|
---|
[49044] | 763 | if (RT_SUCCESS(rc2))
|
---|
| 764 | cLinked++;
|
---|
| 765 | else if (RT_SUCCESS(rc))
|
---|
| 766 | rc = rc2;
|
---|
| 767 | }
|
---|
| 768 | if (RT_FAILURE(rc) && cLinked != 0)
|
---|
| 769 | rc = -rc;
|
---|
| 770 | }
|
---|
| 771 | else
|
---|
| 772 | rc = VERR_INTERNAL_ERROR;
|
---|
[49075] | 773 |
|
---|
[49044] | 774 | RTDbgModRelease(hMod);
|
---|
| 775 | RTDbgAsRelease(hAs);
|
---|
| 776 |
|
---|
[49075] | 777 | if (pf64Bit)
|
---|
| 778 | *pf64Bit = f64Bit;
|
---|
[49044] | 779 | return rc;
|
---|
| 780 | }
|
---|
| 781 |
|
---|
[49075] | 782 |
|
---|
| 783 | static bool dbgDiggerDarwinIsValidName(const char *pszName)
|
---|
| 784 | {
|
---|
| 785 | char ch;
|
---|
| 786 | while ((ch = *pszName++) != '\0')
|
---|
| 787 | {
|
---|
| 788 | if (ch < 0x20 || ch >= 127)
|
---|
| 789 | return false;
|
---|
| 790 | }
|
---|
| 791 | return true;
|
---|
| 792 | }
|
---|
| 793 |
|
---|
| 794 |
|
---|
| 795 | static bool dbgDiggerDarwinIsValidVersion(const char *pszVersion)
|
---|
| 796 | {
|
---|
| 797 | char ch;
|
---|
| 798 | while ((ch = *pszVersion++) != '\0')
|
---|
| 799 | {
|
---|
| 800 | if (ch < 0x20 || ch >= 127)
|
---|
| 801 | return false;
|
---|
| 802 | }
|
---|
| 803 | return true;
|
---|
| 804 | }
|
---|
| 805 |
|
---|
| 806 |
|
---|
[49044] | 807 | /**
|
---|
[31510] | 808 | * @copydoc DBGFOSREG::pfnInit
|
---|
| 809 | */
|
---|
[93470] | 810 | static DECLCALLBACK(int) dbgDiggerDarwinInit(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
|
---|
[31510] | 811 | {
|
---|
[49044] | 812 | PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
|
---|
[31510] | 813 | Assert(!pThis->fValid);
|
---|
| 814 |
|
---|
| 815 | /*
|
---|
[49075] | 816 | * Add the kernel module.
|
---|
[31510] | 817 | */
|
---|
[49075] | 818 | bool f64Bit;
|
---|
[93470] | 819 | int rc = dbgDiggerDarwinAddModule(pThis, pUVM, pVMM, pThis->AddrKernel.FlatPtr, "mach_kernel", &f64Bit);
|
---|
[49044] | 820 | if (RT_SUCCESS(rc))
|
---|
| 821 | {
|
---|
[49075] | 822 | /*
|
---|
| 823 | * The list of modules can be found at the 'kmod' symbol, that means
|
---|
| 824 | * that we currently require some kind of symbol file for the kernel
|
---|
| 825 | * to be loaded at this point.
|
---|
| 826 | *
|
---|
| 827 | * Note! Could also use the 'gLoadedKextSummaries', but I don't think
|
---|
| 828 | * it's any easier to find without any kernel map than 'kmod'.
|
---|
| 829 | */
|
---|
| 830 | RTDBGSYMBOL SymInfo;
|
---|
[93470] | 831 | rc = pVMM->pfnDBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "mach_kernel!kmod", &SymInfo, NULL);
|
---|
[49075] | 832 | if (RT_FAILURE(rc))
|
---|
[93470] | 833 | rc = pVMM->pfnDBGFR3AsSymbolByName(pUVM, DBGF_AS_KERNEL, "mach_kernel!_kmod", &SymInfo, NULL);
|
---|
[49075] | 834 | if (RT_SUCCESS(rc))
|
---|
| 835 | {
|
---|
| 836 | DBGFADDRESS AddrModInfo;
|
---|
[93470] | 837 | pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrModInfo, SymInfo.Value);
|
---|
[49075] | 838 |
|
---|
| 839 | /* Read the variable. */
|
---|
| 840 | RTUINT64U uKmodValue = { 0 };
|
---|
| 841 | if (f64Bit)
|
---|
[93470] | 842 | rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrModInfo, &uKmodValue.u, sizeof(uKmodValue.u));
|
---|
[49075] | 843 | else
|
---|
[93470] | 844 | rc = pVMM->pfnDBGFR3MemRead (pUVM, 0 /*idCpu*/, &AddrModInfo, &uKmodValue.s.Lo, sizeof(uKmodValue.s.Lo));
|
---|
[49075] | 845 | if (RT_SUCCESS(rc))
|
---|
| 846 | {
|
---|
[93470] | 847 | pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrModInfo, uKmodValue.u);
|
---|
[49075] | 848 |
|
---|
| 849 | /* Walk the list of modules. */
|
---|
| 850 | uint32_t cIterations = 0;
|
---|
| 851 | while (AddrModInfo.FlatPtr != 0)
|
---|
| 852 | {
|
---|
| 853 | /* Some extra loop conditions... */
|
---|
| 854 | if (!OSX_VALID_ADDRESS(f64Bit, AddrModInfo.FlatPtr))
|
---|
| 855 | {
|
---|
[83083] | 856 | LogRel(("OSXDig: Invalid kmod_info pointer: %RGv\n", AddrModInfo.FlatPtr));
|
---|
[49075] | 857 | break;
|
---|
| 858 | }
|
---|
| 859 | if (AddrModInfo.FlatPtr == uKmodValue.u && cIterations != 0)
|
---|
| 860 | {
|
---|
[83083] | 861 | LogRel(("OSXDig: kmod_info list looped back to the start.\n"));
|
---|
[49075] | 862 | break;
|
---|
| 863 | }
|
---|
| 864 | if (cIterations++ >= 2048)
|
---|
| 865 | {
|
---|
[83083] | 866 | LogRel(("OSXDig: Too many mod_info loops (%u)\n", cIterations));
|
---|
[49075] | 867 | break;
|
---|
| 868 | }
|
---|
| 869 |
|
---|
| 870 | /*
|
---|
| 871 | * Read the kmod_info_t structure.
|
---|
| 872 | */
|
---|
| 873 | union
|
---|
| 874 | {
|
---|
| 875 | OSX64_kmod_info_t Info64;
|
---|
| 876 | OSX32_kmod_info_t Info32;
|
---|
| 877 | } uMod;
|
---|
| 878 | RT_ZERO(uMod);
|
---|
[93470] | 879 | rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &AddrModInfo, &uMod,
|
---|
| 880 | f64Bit ? sizeof(uMod.Info64) : sizeof(uMod.Info32));
|
---|
[49075] | 881 | if (RT_FAILURE(rc))
|
---|
| 882 | {
|
---|
[83083] | 883 | LogRel(("OSXDig: Error reading kmod_info structure at %RGv: %Rrc\n", AddrModInfo.FlatPtr, rc));
|
---|
[49075] | 884 | break;
|
---|
| 885 | }
|
---|
| 886 |
|
---|
| 887 | /*
|
---|
| 888 | * Validate the kmod_info_t structure.
|
---|
| 889 | */
|
---|
| 890 | int32_t iInfoVer = f64Bit ? uMod.Info64.info_version : uMod.Info32.info_version;
|
---|
| 891 | if (iInfoVer != OSX_KMOD_INFO_VERSION)
|
---|
| 892 | {
|
---|
[83083] | 893 | LogRel(("OSXDig: kmod_info @%RGv: Bad info_version %d\n", AddrModInfo.FlatPtr, iInfoVer));
|
---|
[49075] | 894 | break;
|
---|
| 895 | }
|
---|
| 896 |
|
---|
| 897 | const char *pszName = f64Bit ? uMod.Info64.name : uMod.Info32.name;
|
---|
| 898 | if ( !*pszName
|
---|
| 899 | || !RTStrEnd(pszName, sizeof(uMod.Info64.name))
|
---|
| 900 | || !dbgDiggerDarwinIsValidName(pszName) )
|
---|
| 901 | {
|
---|
[83083] | 902 | LogRel(("OSXDig: kmod_info @%RGv: Bad name '%.*s'\n", AddrModInfo.FlatPtr,
|
---|
| 903 | sizeof(uMod.Info64.name), pszName));
|
---|
[49075] | 904 | break;
|
---|
| 905 | }
|
---|
| 906 |
|
---|
| 907 | const char *pszVersion = f64Bit ? uMod.Info64.version : uMod.Info32.version;
|
---|
| 908 | if ( !RTStrEnd(pszVersion, sizeof(uMod.Info64.version))
|
---|
| 909 | || !dbgDiggerDarwinIsValidVersion(pszVersion) )
|
---|
| 910 | {
|
---|
[83083] | 911 | LogRel(("OSXDig: kmod_info @%RGv: Bad version '%.*s'\n", AddrModInfo.FlatPtr,
|
---|
[49075] | 912 | sizeof(uMod.Info64.version), pszVersion));
|
---|
| 913 | break;
|
---|
| 914 | }
|
---|
| 915 |
|
---|
| 916 | int32_t cRefs = f64Bit ? uMod.Info64.reference_count : uMod.Info32.reference_count;
|
---|
| 917 | if (cRefs < -1 || cRefs > 16384)
|
---|
| 918 | {
|
---|
[83083] | 919 | LogRel(("OSXDig: kmod_info @%RGv: Bad reference_count %d\n", AddrModInfo.FlatPtr, cRefs));
|
---|
[49075] | 920 | break;
|
---|
| 921 | }
|
---|
| 922 |
|
---|
| 923 | uint64_t uImageAddr = f64Bit ? uMod.Info64.address : uMod.Info32.address;
|
---|
| 924 | if (!OSX_VALID_ADDRESS(f64Bit, uImageAddr))
|
---|
| 925 | {
|
---|
[83083] | 926 | LogRel(("OSXDig: kmod_info @%RGv: Bad address %#llx\n", AddrModInfo.FlatPtr, uImageAddr));
|
---|
[49075] | 927 | break;
|
---|
| 928 | }
|
---|
| 929 |
|
---|
| 930 | uint64_t cbImage = f64Bit ? uMod.Info64.size : uMod.Info32.size;
|
---|
| 931 | if (cbImage > 64U*_1M)
|
---|
| 932 | {
|
---|
[83083] | 933 | LogRel(("OSXDig: kmod_info @%RGv: Bad size %#llx\n", AddrModInfo.FlatPtr, cbImage));
|
---|
[49075] | 934 | break;
|
---|
| 935 | }
|
---|
| 936 |
|
---|
| 937 | uint64_t cbHdr = f64Bit ? uMod.Info64.hdr_size : uMod.Info32.hdr_size;
|
---|
| 938 | if (cbHdr > 16U*_1M)
|
---|
| 939 | {
|
---|
[83083] | 940 | LogRel(("OSXDig: kmod_info @%RGv: Bad hdr_size %#llx\n", AddrModInfo.FlatPtr, cbHdr));
|
---|
[49075] | 941 | break;
|
---|
| 942 | }
|
---|
| 943 |
|
---|
| 944 | uint64_t uStartAddr = f64Bit ? uMod.Info64.start : uMod.Info32.start;
|
---|
| 945 | if (!uStartAddr && !OSX_VALID_ADDRESS(f64Bit, uStartAddr))
|
---|
| 946 | {
|
---|
[83083] | 947 | LogRel(("OSXDig: kmod_info @%RGv: Bad start function %#llx\n", AddrModInfo.FlatPtr, uStartAddr));
|
---|
[49075] | 948 | break;
|
---|
| 949 | }
|
---|
| 950 |
|
---|
| 951 | uint64_t uStopAddr = f64Bit ? uMod.Info64.stop : uMod.Info32.stop;
|
---|
| 952 | if (!uStopAddr && !OSX_VALID_ADDRESS(f64Bit, uStopAddr))
|
---|
| 953 | {
|
---|
[83083] | 954 | LogRel(("OSXDig: kmod_info @%RGv: Bad stop function %#llx\n", AddrModInfo.FlatPtr, uStopAddr));
|
---|
[49075] | 955 | break;
|
---|
| 956 | }
|
---|
| 957 |
|
---|
| 958 | /*
|
---|
| 959 | * Try add the module.
|
---|
| 960 | */
|
---|
[93470] | 961 | rc = dbgDiggerDarwinAddModule(pThis, pUVM, pVMM, uImageAddr, pszName, NULL);
|
---|
[104609] | 962 | LogRel(("OSXDig: kmod_info @%RGv: '%s' ver '%s', image @%#llx LB %#llx cbHdr=%#llx -> %Rrc\n", AddrModInfo.FlatPtr,
|
---|
| 963 | pszName, pszVersion, uImageAddr, cbImage, cbHdr, rc));
|
---|
[49075] | 964 |
|
---|
| 965 | /*
|
---|
| 966 | * Advance to the next kmod_info entry.
|
---|
| 967 | */
|
---|
[93470] | 968 | pVMM->pfnDBGFR3AddrFromFlat(pUVM, &AddrModInfo, f64Bit ? uMod.Info64.next : uMod.Info32.next);
|
---|
[49075] | 969 | }
|
---|
| 970 | }
|
---|
| 971 | else
|
---|
[83083] | 972 | LogRel(("OSXDig: Error reading the 'kmod' variable: %Rrc\n", rc));
|
---|
[49075] | 973 | }
|
---|
| 974 | else
|
---|
[83083] | 975 | LogRel(("OSXDig: Failed to locate the 'kmod' variable in mach_kernel.\n"));
|
---|
[49075] | 976 |
|
---|
[49044] | 977 | pThis->fValid = true;
|
---|
| 978 | return VINF_SUCCESS;
|
---|
| 979 | }
|
---|
[31510] | 980 |
|
---|
[49044] | 981 | return rc;
|
---|
[31510] | 982 | }
|
---|
| 983 |
|
---|
| 984 |
|
---|
| 985 | /**
|
---|
| 986 | * @copydoc DBGFOSREG::pfnProbe
|
---|
| 987 | */
|
---|
[93470] | 988 | static DECLCALLBACK(bool) dbgDiggerDarwinProbe(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
|
---|
[31510] | 989 | {
|
---|
[49044] | 990 | PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
|
---|
[31510] | 991 |
|
---|
| 992 | /*
|
---|
[49044] | 993 | * Look for a section + segment combo that normally only occures in
|
---|
| 994 | * mach_kernel. Follow it up with probing of the rest of the executable
|
---|
| 995 | * header. We must search a largish area because the more recent versions
|
---|
| 996 | * of darwin have random load address for security raisins.
|
---|
[31510] | 997 | */
|
---|
[49044] | 998 | static struct { uint64_t uStart, uEnd; } const s_aRanges[] =
|
---|
[31510] | 999 | {
|
---|
[49044] | 1000 | /* 64-bit: */
|
---|
| 1001 | { UINT64_C(0xffffff8000000000), UINT64_C(0xffffff81ffffffff), },
|
---|
| 1002 |
|
---|
| 1003 | /* 32-bit - always search for this because of the hybrid 32-bit kernel
|
---|
| 1004 | with cpu in long mode that darwin used for a number of versions. */
|
---|
| 1005 | { UINT64_C(0x00001000), UINT64_C(0x0ffff000), }
|
---|
| 1006 | };
|
---|
[93470] | 1007 | for (unsigned iRange = pVMM->pfnDBGFR3CpuGetMode(pUVM, 0 /*idCpu*/) != CPUMMODE_LONG;
|
---|
[49044] | 1008 | iRange < RT_ELEMENTS(s_aRanges);
|
---|
| 1009 | iRange++)
|
---|
| 1010 | {
|
---|
| 1011 | DBGFADDRESS KernelAddr;
|
---|
[93470] | 1012 | for (pVMM->pfnDBGFR3AddrFromFlat(pUVM, &KernelAddr, s_aRanges[iRange].uStart);
|
---|
[49044] | 1013 | KernelAddr.FlatPtr < s_aRanges[iRange].uEnd;
|
---|
[102855] | 1014 | KernelAddr.FlatPtr += GUEST_PAGE_SIZE)
|
---|
[31510] | 1015 | {
|
---|
[49044] | 1016 | static const uint8_t s_abNeedle[16 + 16] =
|
---|
[31510] | 1017 | {
|
---|
[49044] | 1018 | '_','_','t','e','x','t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* section_32_t::sectname */
|
---|
| 1019 | '_','_','K','L','D', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* section_32_t::segname. */
|
---|
| 1020 | };
|
---|
| 1021 |
|
---|
[93470] | 1022 | int rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, s_aRanges[iRange].uEnd - KernelAddr.FlatPtr,
|
---|
| 1023 | 1, s_abNeedle, sizeof(s_abNeedle), &KernelAddr);
|
---|
[49044] | 1024 | if (RT_FAILURE(rc))
|
---|
| 1025 | break;
|
---|
[102855] | 1026 | pVMM->pfnDBGFR3AddrSub(&KernelAddr, KernelAddr.FlatPtr & GUEST_PAGE_OFFSET_MASK);
|
---|
[49044] | 1027 |
|
---|
| 1028 | /*
|
---|
| 1029 | * Read the first page of the image and check the headers.
|
---|
| 1030 | */
|
---|
| 1031 | union
|
---|
| 1032 | {
|
---|
[102855] | 1033 | uint8_t ab[GUEST_PAGE_SIZE];
|
---|
[49044] | 1034 | mach_header_64_t Hdr64;
|
---|
| 1035 | mach_header_32_t Hdr32;
|
---|
| 1036 | } uBuf;
|
---|
[102855] | 1037 | rc = pVMM->pfnDBGFR3MemRead(pUVM, 0 /*idCpu*/, &KernelAddr, uBuf.ab, GUEST_PAGE_SIZE);
|
---|
[49044] | 1038 | if (RT_FAILURE(rc))
|
---|
| 1039 | continue;
|
---|
| 1040 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, magic, mach_header_32_t, magic);
|
---|
| 1041 | if ( uBuf.Hdr64.magic != IMAGE_MACHO64_SIGNATURE
|
---|
| 1042 | && uBuf.Hdr32.magic != IMAGE_MACHO32_SIGNATURE)
|
---|
| 1043 | continue;
|
---|
| 1044 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, cputype, mach_header_32_t, cputype);
|
---|
| 1045 | bool f64Bit = uBuf.Hdr64.magic == IMAGE_MACHO64_SIGNATURE;
|
---|
| 1046 | if (uBuf.Hdr32.cputype != (f64Bit ? CPU_TYPE_X86_64 : CPU_TYPE_I386))
|
---|
| 1047 | continue;
|
---|
| 1048 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, filetype, mach_header_32_t, filetype);
|
---|
| 1049 | if (uBuf.Hdr32.filetype != MH_EXECUTE)
|
---|
| 1050 | continue;
|
---|
| 1051 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, ncmds, mach_header_32_t, ncmds);
|
---|
| 1052 | if (uBuf.Hdr32.ncmds > 256)
|
---|
| 1053 | continue;
|
---|
| 1054 | AssertCompileMembersSameSizeAndOffset(mach_header_64_t, sizeofcmds, mach_header_32_t, sizeofcmds);
|
---|
[102855] | 1055 | if (uBuf.Hdr32.sizeofcmds > GUEST_PAGE_SIZE * 2 - sizeof(mach_header_64_t))
|
---|
[49044] | 1056 | continue;
|
---|
| 1057 |
|
---|
| 1058 | /* Seems good enough for now.
|
---|
| 1059 |
|
---|
| 1060 | If the above causes false positives, check the segments and make
|
---|
| 1061 | sure there is a kernel version string in the right one. */
|
---|
| 1062 | pThis->AddrKernel = KernelAddr;
|
---|
[54232] | 1063 | pThis->f64Bit = f64Bit;
|
---|
[49044] | 1064 |
|
---|
| 1065 | /*
|
---|
| 1066 | * Finally, find the kernel version string.
|
---|
| 1067 | */
|
---|
[93470] | 1068 | rc = pVMM->pfnDBGFR3MemScan(pUVM, 0 /*idCpu*/, &KernelAddr, 32*_1M, 1, RT_STR_TUPLE("Darwin Kernel Version"),
|
---|
| 1069 | &pThis->AddrKernelVersion);
|
---|
[49044] | 1070 | if (RT_FAILURE(rc))
|
---|
[93470] | 1071 | pVMM->pfnDBGFR3AddrFromFlat(pUVM, &pThis->AddrKernelVersion, 0);
|
---|
[49044] | 1072 | return true;
|
---|
[31510] | 1073 | }
|
---|
| 1074 | }
|
---|
| 1075 | return false;
|
---|
| 1076 | }
|
---|
| 1077 |
|
---|
| 1078 |
|
---|
| 1079 | /**
|
---|
| 1080 | * @copydoc DBGFOSREG::pfnDestruct
|
---|
| 1081 | */
|
---|
[93470] | 1082 | static DECLCALLBACK(void) dbgDiggerDarwinDestruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
|
---|
[31510] | 1083 | {
|
---|
[93470] | 1084 | RT_NOREF(pUVM, pVMM, pvData);
|
---|
[31510] | 1085 | }
|
---|
| 1086 |
|
---|
| 1087 |
|
---|
| 1088 | /**
|
---|
| 1089 | * @copydoc DBGFOSREG::pfnConstruct
|
---|
| 1090 | */
|
---|
[93470] | 1091 | static DECLCALLBACK(int) dbgDiggerDarwinConstruct(PUVM pUVM, PCVMMR3VTABLE pVMM, void *pvData)
|
---|
[31510] | 1092 | {
|
---|
[93470] | 1093 | RT_NOREF(pUVM, pVMM);
|
---|
[54232] | 1094 | PDBGDIGGERDARWIN pThis = (PDBGDIGGERDARWIN)pvData;
|
---|
| 1095 |
|
---|
| 1096 | pThis->IDmesg.u32Magic = DBGFOSIDMESG_MAGIC;
|
---|
| 1097 | pThis->IDmesg.pfnQueryKernelLog = dbgDiggerDarwinIDmsg_QueryKernelLog;
|
---|
| 1098 | pThis->IDmesg.u32EndMagic = DBGFOSIDMESG_MAGIC;
|
---|
| 1099 |
|
---|
[31510] | 1100 | return VINF_SUCCESS;
|
---|
| 1101 | }
|
---|
| 1102 |
|
---|
| 1103 |
|
---|
[49044] | 1104 | const DBGFOSREG g_DBGDiggerDarwin =
|
---|
[31510] | 1105 | {
|
---|
[73460] | 1106 | /* .u32Magic = */ DBGFOSREG_MAGIC,
|
---|
| 1107 | /* .fFlags = */ 0,
|
---|
| 1108 | /* .cbData = */ sizeof(DBGDIGGERDARWIN),
|
---|
| 1109 | /* .szName = */ "Darwin",
|
---|
| 1110 | /* .pfnConstruct = */ dbgDiggerDarwinConstruct,
|
---|
| 1111 | /* .pfnDestruct = */ dbgDiggerDarwinDestruct,
|
---|
| 1112 | /* .pfnProbe = */ dbgDiggerDarwinProbe,
|
---|
| 1113 | /* .pfnInit = */ dbgDiggerDarwinInit,
|
---|
| 1114 | /* .pfnRefresh = */ dbgDiggerDarwinRefresh,
|
---|
| 1115 | /* .pfnTerm = */ dbgDiggerDarwinTerm,
|
---|
| 1116 | /* .pfnQueryVersion = */ dbgDiggerDarwinQueryVersion,
|
---|
| 1117 | /* .pfnQueryInterface = */ dbgDiggerDarwinQueryInterface,
|
---|
| 1118 | /* .pfnStackUnwindAssist = */ dbgDiggerDarwinStackUnwindAssist,
|
---|
| 1119 | /* .u32EndMagic = */ DBGFOSREG_MAGIC
|
---|
[31510] | 1120 | };
|
---|
| 1121 |
|
---|