MiniDumpWriteDump with callbacks in Go

Question content

I am trying to implement MiniDumpWriteDump## using callbacks in Go #.

Call

MiniDumpWriteDump:

callback := syscall.NewCallback(miniDumpCallback)
    var newCallbackRoutine MINIDUMP_CALLBACK_INFORMATION
    newCallbackRoutine.CallbackParam = 0
    newCallbackRoutine.CallbackRoutine = callback
    ret, _, err := miniDumpWriteDump.Call(
        uintptr(processHandle),
        uintptr(processId),
        uintptr(dumpFile),
        uintptr(options),
        0,
        0,
        uintptr(unsafe.Pointer(&newCallbackRoutine)),
    )

CallbackThe function itself:

func miniDumpCallback(_ uintptr, CallbackInput *MINIDUMP_CALLBACK_INPUT, _ uintptr) uintptr {
    fmt.Println(CallbackInput.ProcessId, CallbackInput.CallbackType)
    return 1
}

TypeDefinition:

type MINIDUMP_CALLBACK_INPUT struct {
    ProcessId     win32.ULONG
    ProcessHandle win32.HANDLE
    CallbackType  win32.ULONG
    CallbackInfo  uintptr
}

type MINIDUMP_CALLBACK_INFORMATION struct {
    CallbackRoutine uintptr
    CallbackParam   uintptr
}

The callback is called and some fields receive correct data, but some fields get

meaningless values.

For example, the callback above correctly receives the

ProcessId field of the CallbackInput, but receives a random integer as the CallbackType MINIDUMP_CALLBACK_TYPE when it should. enumerate.

Output:

12544 0
12544 1133445120
12544 12548
12544 13028
12544 1114112
12544 1023344640
12544 999620608
12544 990117888
12544 992542720
12544 1005518848
12544 1994850304
12544 1114112
12544 1994915840

Correct answer

As the comments suggest, the problem is with

structural alignment.

As @IInspectable explained, minidumpapiset.h, which exports the MiniDumpWriteDump function and MINIDUMP_CALLBACK_INPUT structure, uses

4-byte alignment ## for both 32-bit and 64-bit. # strong> architecture, while Go uses 8-byte alignment by default for 64-bit and does not provide a way to automatically change it. The solution is to read the structure manually. Here is a working example:

type MINIDUMP_CALLBACK_INPUT struct {
ProcessId     uint32
ProcessHandle uintptr
CallbackType  uint32
CallbackInfo uintptr}

func ptrToMinidumpCallbackInput(ptrCallbackInput uintptr) MINIDUMP_CALLBACK_INPUT{
    var input MINIDUMP_CALLBACK_INPUT
    input.ProcessId = *(*uint32)(unsafe.Pointer(ptrCallbackInput))
    input.ProcessHandle = *(*uintptr)(unsafe.Pointer(ptrCallbackInput + unsafe.Sizeof(uint32(0))))
    input.CallbackType = *(*uint32)(unsafe.Pointer(ptrCallbackInput + unsafe.Sizeof(uint32(0)) + unsafe.Sizeof(uintptr(0))))
    input.CallbackInfo = *(*uintptr)(unsafe.Pointer(ptrCallbackInput + unsafe.Sizeof(uint32(0)) + unsafe.Sizeof(uintptr(0)) + unsafe.Sizeof(uint32(0))))
    return input}

The original code should work fine on 32-bit architectures because its padding (4 bytes) matches the padding used by minidumpapiset.h.

The above is the detailed content of MiniDumpWriteDump with callbacks in Go. For more information, please follow other related articles on the PHP Chinese website!