backtrace(3)               Library Functions Manual               backtrace(3)

NUME
       backtrace, backtrace_symbols, backtrace_symbols_fd - suport pentru
       auto-depanarea aplica<?>iei

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

SINOPSIS
       #include <execinfo.h>

       int backtrace(void *buffer[.size], int size);

       char **backtrace_symbols(void *const buffer[.size], int size);
       void backtrace_symbols_fd(void *const buffer[.size], int size, int fd);

DESCRIERE
       backtrace() returneaza un traseu de urmarire pentru programul apelant,
       in matricea indicata de buffer. Un traseu de urmarire reprezinta seria
       de apeluri de func<?>ii active in acel moment pentru program. Fiecare
       element din matricea indicata de buffer este de tip void * <?>i
       reprezinta adresa de returnare din cadrul stivei corespunzatoare.
       Argumentul size specifica numarul maxim de adrese care pot fi stocate
       in buffer. Daca traseul de urmarire este mai mare decat size, atunci
       sunt returnate adresele corespunzatoare celor mai recente apeluri de
       func<?>ie size; pentru a ob<?>ine traseul complet, asigura<?>i-va ca
       buffer <?>i size sunt suficient de mari.

       Avand in vedere setul de adrese returnate de backtrace() in buffer,
       backtrace_symbols() traduce adresele intr-o matrice de <?>iruri care
       descriu simbolic adresele. Argumentul size specifica numarul de adrese
       din buffer. Reprezentarea simbolica a fiecarei adrese consta in numele
       func<?>iei (daca acesta poate fi determinat), un decalaj hexazecimal in
       interiorul func<?>iei <?>i adresa reala de returnare (in hexazecimal).
       Adresa matricei de indicatori de <?>iruri este returnata ca rezultat al
       func<?>iei backtrace_symbols(). Aceasta matrice este alocata in memorie
       ,,malloc(3)" de backtrace_symbols() <?>i trebuie eliberata de catre
       apelant; (<?>irurile indicate de matricea de indicatori nu au nevoie
       <?>i nu trebuie sa fie eliberate).

       backtrace_symbols_fd() prime<?>te acelea<?>i argumente buffer <?>i size
       ca <?>i backtrace_symbols(), dar in loc sa returneze o matrice de
       <?>iruri catre apelant, scrie <?>irurile, cate unul pe linie, in
       descriptorul de fi<?>ier fd. backtrace_symbols_fd() nu apeleaza
       malloc(3) <?>i, prin urmare, poate fi utilizata in situa<?>ii in care
       aceasta din urma func<?>ie ar putea e<?>ua, dar a se vedea sec<?>iunea
       NOTE.

VALOAREA RETURNATA
       backtrace() returneaza numarul de adrese returnate in buffer, care nu
       este mai mare decat size. Daca valoarea returnata este mai mica decat
       size, atunci a fost stocat intregul traseu de urmarire; daca este egala
       cu size, atunci este posibil sa fi fost trunchiat, caz in care adresele
       celor mai vechi cadre din stiva nu sunt returnate.

       In caz de succes, backtrace_symbols() returneaza un indicator la
       matricea malloc(3) creata prin apel; in caz de eroare, se returneaza
       NULL.

ATRIBUTE
       Pentru o explica<?>ie a termenilor folosi<?>i in aceasta sec<?>iune, a
       se vedea attributes(7).

       +--------------------------------------+---------------------+---------+
       |Interfa<?>a                           | Atribut             | Valoare |
       +--------------------------------------+---------------------+---------+
       |backtrace(), backtrace_symbols(),     | Siguran<?>a firelor | MT-Safe |
       |backtrace_symbols_fd()                |                     |         |
       +--------------------------------------+---------------------+---------+
STANDARDE
       GNU.

ISTORIC
       glibc 2.1.

NOTE
       Aceste func<?>ii fac unele presupuneri cu privire la modul in care
       adresa de returnare a unei func<?>ii este stocata in stiva.
       Re<?>ine<?>i urmatoarele:

       o  Omiterea indicatorilor de cadre (a<?>a cum implica oricare dintre
          nivelurile de optimizare diferite de zero ale gcc(1)) poate duce la
          incalcarea acestor presupuneri.

       o  Func<?>iile inserate in linie ,,inlined" nu au cadre de stiva.

       o  Optimizarea apelului din coada ,,tail-call" face ca un cadru de
          stiva sa inlocuiasca un altul.

       o  backtrace() <?>i backtrace_symbols_fd() nu apeleaza explicit
          malloc(), dar fac parte din libgcc, care se incarca dinamic la prima
          utilizare. Incarcarea dinamica declan<?>eaza, de obicei, un apel la
          malloc(3). Daca ave<?>i nevoie ca anumite apeluri la aceste doua
          func<?>ii sa nu aloce memorie (in gestionarii de semnal, de
          exemplu), trebuie sa va asigura<?>i ca libgcc este incarcata in
          prealabil.

       Este posibil ca numele simbolurilor sa nu fie disponibile fara
       utilizarea unor op<?>iuni speciale ale editorului de legaturi. Pentru
       sistemele care utilizeaza editorul de legaturi GNU, este necesar sa se
       utilizeze op<?>iunea -rdynamic. Re<?>ine<?>i ca numele func<?>iilor
       ,,statice" nu sunt expuse <?>i nu vor fi disponibile in traseul de
       urmarire.

EXEMPLE
       Programul de mai jos demonstreaza utilizarea backtrace() <?>i
       backtrace_symbols(). Urmatoarea sesiune shell arata ce am putea vedea
       la rularea programului:

           $ cc -rdynamic prog.c -o prog
           $ ./prog 3
           backtrace() a returnat 8 adrese
           ./prog(myfunc3+0x5c) [0x80487f0]
           ./prog [0x8048871]
           ./prog(myfunc+0x21) [0x8048894]
           ./prog(myfunc+0x1a) [0x804888d]
           ./prog(myfunc+0x1a) [0x804888d]
           ./prog(main+0x65) [0x80488fb]
           /lib/libc.so.6(__libc_start_main+0xdc) [0xb7e38f9c]
           ./prog [0x8048711]

   Sursa programului
       #include <execinfo.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>

       #define BT_BUF_SIZE 100

       void
       myfunc3(void)
       {
           int nptrs;
           void *buffer[BT_BUF_SIZE];
           char **strings;

           nptrs = backtrace(buffer, BT_BUF_SIZE);
           printf("backtrace() a returnat %d adree\n", nptrs);

           /* Apelul backtrace_symbols_fd(buffer, nptrs, STDOUT_FILENO)
              ar produce o ie<?>ire similara cu cea de mai jos: */

           strings = backtrace_symbols(buffer, nptrs);
           if (strings == NULL) {
               perror("backtrace_symbols");
               exit(EXIT_FAILURE);
           }

           for (size_t j = 0; j < nptrs; j++)
               printf("%s\n", strings[j]);

           free(strings);
       }

       static void   /* ,,static" inseamna ca nu exporta simbolul... */
       myfunc2(void)
       {
           myfunc3();
       }

       void
       myfunc(int ncalls)
       {
           if (ncalls > 1)
               myfunc(ncalls - 1);
           else
               myfunc2();
       }

       int
       main(int argc, char *argv[])
       {
           if (argc != 2) {
               fprintf(stderr, "%s num-calls\n", argv[0]);
               exit(EXIT_FAILURE);
           }

           myfunc(atoi(argv[1]));
           exit(EXIT_SUCCESS);
       }

CONSULTA<?>I <?>I
       addr2line(1), gcc(1), gdb(1), ld(1), dlopen(3), malloc(3)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.8     2 mai 2024                      backtrace(3)