Discussion :

[anykeyh]

Bonjour a tous, je souhaiterais recuperer les valeurs de la pile memoire dans un but de debuggage.

Voici le code que j'ai ecrit (sous GCC):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
            asm(
            ".intel_syntax noprefix\n"
 
            "push edi\n"                // Save data in stack for next code
            "push edx\n"                //
            "push ecx\n"                //
            "push eax\n"                //
             //Initialisation
            "xor ecx, ecx\n"            //ecx = 0
            "mov edi, _st_head\n"       //edi = &stacktrace[0]
 
            "unstack:\n"                //while(true) {
 
                "mov eax, esp\n"        //  if(esp+ecx == ebp) {
                "add eax, ecx\n"        //
                "cmp eax, ebp\n"        //
                "je end_unstack\n"      //      break;
                                        //  } else {
                "mov edx, [eax]\n"      //
                "mov [edi], edx\n"      //      stack_trace[n] = *(esp+ecx);
                "add edi, 4\n"          //      n ++;
                "add ecx, 4\n"          //      ecx += 4;
                                        //  }
 
                "jmp unstack\n"         //}
 
            "end_unstack:\n"
 
            "sub edi, _st_head\n"               // stack_size = 4 * n
            "mov _stack_size, edi\n"            //
            "shr DWORD PTR _stack_size, 2\n"    //stack_size >>= 2
            "pop eax\n"                         //
            "pop ecx\n"                         //
            "pop edx\n"                         // Get back stack data!
            "pop edi\n"                         //
 
            ".att_syntax \n"
            );

Bon, ça fonctionne, cependant il m'affiche que les dix dernieres entrée dans la pile.
Apres reflexion cela semble evident: je recupere d'ebp à esp, donc je recup uniquement les valeur du contexte de la fonction et non du programme en entier...
Y'a-t-il une solution? existe-t-il une valeur en dure définissant le bas de la pile (à utiliser au lieu de ebp...)?

[Neitsa]

Bonjour,

c'est pour quel système d'exploitation ?

[anykeyh]

C'est de l'assembleur x86, tout d'abord pour MS Windows. Cependant c'est une bibliotheque que je souhaiterais porté sous linux voir sous d'autre architecture lorsque j'aurais le temps.

[Neitsa]

Sous Windows c'est mon rayon pour Linux, faudrait que je demande aux collègues...

La solution fonctionne pour les noyaux à technologie NT (donc pas pour les 9x) ce qui comprend NT, 2k, 2k3, XP et Vista. (j'ai oublié comment ça se passait sous 9x, faudra que je cherche).

Pour l'adresse de début (et de fin de pile si ça t'intéresse) tu doit passer par le segment FS qui pointe vers la strcuture interne nommée Thread Environment Block (TEB) et plus exactement vers la structure NT_TIB (NT Thread Information Block), puisque chaque Thread a sa propre pile.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
mov esi, dword ptr fs:[18h] ; esi = pointeur linéaire vers NT_TIB
mov eax, dword ptr [esi+4] ; eax = base de la pile
mov ebx, dword ptr [esi+8] ; ebx = haut de la pile

[anykeyh]

Yes! Merci pour votre reponse clair et rapide !

Je pense pas que j'aurais trouvé en plus

[anykeyh]

J'ai integré le code et sa marche parfaitement... Ou presque

A vrai dire j'ai un petit soucis: J'utilise ce code pour recuperer la pile d'appel de mon programme lors d'un plantage.
Pour les interruptions de type abort, floating point operation ou cancel by user c'est niquel.
Pour les signaux segfaults la parcontre...

Peut-etre savez vous si lorsqu'un thread fait une violation mémoire:

* La zone memoire fs:[0x18] ne se bloque pas? Ou alors est-ce mon code qui est foireux?

Merci d'avance pour ces eclaircissements

[Neitsa]

Bonjour,

Peut-etre savez vous si lorsqu'un thread fait une violation mémoire:

* La zone memoire fs:[0x18] ne se bloque pas? Ou alors est-ce mon code qui est foireux?

Le pointeur linéaire vers NT_TIB est garanti "fonctionnel" dans tout les cas. En fait la structure est tellement critique qu'elle doit être atteignable par Windows (et même un programme utilisateur) quoi qu'il puisse arriver.

l'adresse FS[0], par exemple, est en réalité un pointeur vers une structure de type EXCEPTION_REGISTRATION_RECORD qui sert aux SEH (Structured Exception Handling) de Windows.

Donc quelle que soit l'erreur occasionnée (et un segfault en fait partie) Windows - et le programme lui-même - doivent pouvoir y accéder.

P.S : Ah oui au fait, j'ai oublier de mentionner un point important pour les limites de la pile, car je viens de le tester à l'instant :

- la limite basse de la pile n'est pas inclusive.
- la limite haute est "variable" et mise à jour en temps réel.

En d'autres termes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
mov esi, dword ptr fs:[18h] ; esi = pointeur linéaire vers NT_TIB
mov eax, dword ptr [esi+4] ; eax = base de la pile (non inclus, ne doit pas être atteignable par le prog)
mov ebx, dword ptr [esi+8] ; ebx = haut de la pile
sub eax, 4 ; eax = valeur base de la pile atteignable par le prog.
sub ebx, 4 ; ebx = adresse haut dessus la limite haute
mov dword ptr [ebx], 0 ; tentative d'écriture
mov ebx, dword ptr [esi+8] ; la limite haute a changée dû à l'écriture précédente !

N'hésites pas si tu as d'autres questions

[anykeyh]

Effectivement, je cherché au mauvais endroit! Du coup ça marche!

En fait, le tableau allouée pour sauvegarder la pile été trop petite (128 entrée max), et forcement je debordais a coté

Je l'ai changé par un tableau dynamique et la plus de soucis!
Un grand merci pour votre aide, maintenant il ne me reste plus qu'à trier et lier certaines des valeurs de la pile vers le nom des fonctions appelée, ce qui ne sera pas de tout repos


Voilà le code pour ceux que ça interresse:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
//Sous GCC...    
#define intel_asm(x...) asm ( ".intel_syntax noprefix\n"  #x  ".att_syntax \n" )
//Sous VC++
#define intel_asm(x...) asm { x }
 
        #if ATL_ARCHITECTURE == X86
                    //Drop stack to the global stacktrace var
                    std::cout << "Try to read stack..." << std::endl;
                    intel_asm (
 
                    push edi\n                // Push data in stack for next code
                    push esi\n                //
                    push edx\n                //
                    push ecx\n                //
                    push ebx\n                //
                     //Initialisation
                    xor ecx, ecx\n            //ecx = 0
                    mov edi, _st_head\n       //edi = &stacktrace[0]
 
                    #if ATL_OS == WINNT
                    push esi\n
                        //Thanks to Neitsa =========================================
                        mov esi, fs:[0x18]\n// linear pointer to NT_TIB
                        mov eax, [esi+4]\n  // get stack base in eax
                        sub eax, 4\n        //the base of stack is non inclusive
                        //==========================================================
                    pop esi\n
                    #else
                        mov DWORD PTR _stack_size, 0\n
                        jmp non_implemented_yet\n
                    #endif
                    //==========================================================
 
                    unstack:  \n              //while(true) {
 
                        mov ebx, ebp \n       //  if(ebp+ecx == ebp) {
                        add ebx, ecx \n       //
                        cmp ebx, eax \n       //
                        je end_unstack\n      //      break;
                                                //  } else {
                        mov edx, [ebx]\n      //
                        mov [edi], edx\n     //      stack_trace[n] = *(ebp+ecx);
                        add edi, 4    \n      //      n ++;
                        add ecx, 4    \n      //      ecx += 4;
                                                //  }
 
                        jmp unstack   \n      //}
 
                    end_unstack:\n
 
                    sub edi, _st_head\n               // stack_size = 4 * n
                    mov _stack_size, edi\n            //
                    shr DWORD PTR _stack_size, 2\n    //stack_size >>= 2
 
                    non_implemented_yet:\n
                    pop ebx\n                         //
                    pop ecx\n                         //
                    pop edx\n                         // Get back stack data!
                    pop esi\n                         //
                    pop edi\n                         //
                    );
 
                std::cout <<  std::dec << "* Stack size: " << stack_size << std::endl;
 
                //Display the stack
                for(unsigned int i = 0; i < stack_size; i++)
                    std::cout << (void*)stacktrace[i] << std::endl;
        #endif