Comment faire pour obtenir une trace de pile à partir du fichier de vidage sous Windows

Question

Je souhaite récupérer la trace de pile à partir d'un fichier de vidage d'utilisateur par programme. Il y a cette sauvegarde d'utilisateur à un emplacement connu et je veux en extraire juste la trace de la pile et la mettre dans un fichier texte - y a-t-il un moyen de le faire?

REMARQUE: je peux le faire manuellement - Ouvrir windbg et tapez "k" commande - mais comme je l'ai mentionné plus tôt je veux faire cela par programmation.

Merci

Answer 1

vous devriez vérifier le sous-dossier windbg sdk avec des exemples sur la façon dont dbgeng.dll peut être utilisé par un programme.
l'échantillon de code:

PSTR g_DumpFile; 
PSTR g_ImagePath; 
PSTR g_SymbolPath; 

ULONG64 g_TraceFrom[3]; 

IDebugClient* g_Client; 
IDebugControl* g_Control; 
IDebugSymbols* g_Symbols; 

    void CreateInterfaces(void) 
    { 
    HRESULT Status; 

    // Start things off by getting an initial interface from 
    // the engine. This can be any engine interface but is 
    // generally IDebugClient as the client interface is 
    // where sessions are started. 
    if ((Status = DebugCreate(__uuidof(IDebugClient), 
           (void**)&g_Client)) != S_OK) 
    { 
     Exit(1, "DebugCreate failed, 0x%X\n", Status); 
    } 

    // Query for some other interfaces that we'll need. 
    if ((Status = g_Client->QueryInterface(__uuidof(IDebugControl), 
              (void**)&g_Control)) != S_OK || 
     (Status = g_Client->QueryInterface(__uuidof(IDebugSymbols), 
              (void**)&g_Symbols)) != S_OK) 
    { 
     Exit(1, "QueryInterface failed, 0x%X\n", Status); 
    } 
} 

void 
DumpStack(void) 
{ 
    HRESULT Status; 
    PDEBUG_STACK_FRAME Frames = NULL; 
    int Count = 50; 

    printf("\nFirst %d frames of the call stack:\n", Count); 

    if (g_TraceFrom[0] || g_TraceFrom[1] || g_TraceFrom[2]) 
    { 
     ULONG Filled; 

     Frames = new DEBUG_STACK_FRAME[Count]; 
     if (Frames == NULL) 
     { 
      Exit(1, "Unable to allocate stack frames\n"); 
     } 

     if ((Status = g_Control-> 
      GetStackTrace(g_TraceFrom[0], g_TraceFrom[1], g_TraceFrom[2], 
          Frames, Count, &Filled)) != S_OK) 
     { 
      Exit(1, "GetStackTrace failed, 0x%X\n", Status); 
     } 

     Count = Filled; 
    } 

    // Print the call stack. 
    if ((Status = g_Control-> 
     OutputStackTrace(DEBUG_OUTCTL_ALL_CLIENTS, Frames, 
          Count, DEBUG_STACK_SOURCE_LINE | 
          DEBUG_STACK_FRAME_ADDRESSES | 
          DEBUG_STACK_COLUMN_NAMES | 
          DEBUG_STACK_FRAME_NUMBERS)) != S_OK) 
    { 
     Exit(1, "OutputStackTrace failed, 0x%X\n", Status); 
    } 

    delete[] Frames; 
} 


void __cdecl main(int Argc, __in_ecount(Argc) char** Argv) 
{ 
    CreateInterfaces(); 

    ParseCommandLine(Argc, Argv); 

    ApplyCommandLineArguments(); 

    DumpStack(); 

    Exit(0, NULL); 
} 

Answer 2

J'ai écrit un article sur le dumping de la pile en C/C++ sous Windows et Unix/Linux à DDJ il y a quelques années. Il n'utilise pas de cordon, mais il écrit des cadres de pile dans un fichier journal, sur des erreurs internes ou lorsque le système d'exploitation détermine un défaut d'application.

Peut-être vous aide:

Voir http://www.ddj.com/architect/185300443