mcheck(3)                  Library Functions Manual                  mcheck(3)

NUME
       mcheck, mcheck_check_all, mcheck_pedantic, mprobe - verifica
       consisten<?>a gramezii

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

SINOPSIS
       #include <mcheck.h>

       int mcheck(typeof(void (enum mcheck_status mstatus)) *f);
       int mcheck_pedantic(
                  typeof(void (enum mcheck_status mstatus)) *f);
       void mcheck_check_all(void);

       enum mcheck_status mprobe(void *ptr);

DESCRIERE
       Func<?>ia mcheck() instaleaza un set de carlige de depanare pentru
       familia de func<?>ii de alocare a memoriei malloc(3). Aceste carlige
       determina efectuarea anumitor verificari de consisten<?>a asupra starii
       gramezii. Verificarile pot detecta erori ale aplica<?>iei, cum ar fi
       eliberarea unui bloc de memorie de mai multe ori sau coruperea
       structurilor de date de eviden<?>a care preced imediat un bloc de
       memorie alocat.

       Pentru a fi eficienta, func<?>ia mcheck() trebuie sa fie apelata
       inainte de primul apel la malloc(3) sau la o func<?>ie conexa. In
       cazurile in care acest lucru este dificil de asigurat, legarea
       programului cu -lmcheck insereaza un apel implicit la mcheck() (cu un
       argument NULL) inainte de primul apel la o func<?>ie de alocare a
       memoriei.

       Func<?>ia mcheck_pedantic() este similara cu mcheck(), dar efectueaza
       verificari asupra tuturor blocurilor alocate ori de cate ori este
       apelata una dintre func<?>iile de alocare a memoriei. Acest lucru poate
       fi foarte lent!

       Func<?>ia mcheck_check_check_all() determina o verificare imediata a
       tuturor blocurilor alocate. Acest apel este eficient numai daca
       mcheck() este apelata mai inainte.

       In cazul in care sistemul detecteaza o inconsisten<?>a in gramada,
       func<?>ia furnizata de apelant, indicata de f, este invocata cu un
       singur argument, mstatus, care indica ce tip de inconsisten<?>a a fost
       detectata. Daca f este NULL, o func<?>ie implicita afi<?>eaza un mesaj
       de eroare la stderr <?>i apeleaza abort(3).

       Func<?>ia mprobe() efectueaza o verificare a consisten<?>ei blocului de
       memorie alocat indicat de ptr. Func<?>ia mcheck() trebuie apelata in
       prealabil (in caz contrar, mprobe() returneaza MCHCHECK_DISABLED).

       Urmatoarea lista descrie valorile returnate de mprobe() sau pasatee ca
       argument mstatus atunci cand este invocata f:

       MCHECK_DISABLED (doar mprobe())
              mcheck() nu a fost apelata inainte de a fi apelata prima
              func<?>ie de alocare a memoriei. Verificarea consisten<?>ei nu
              este posibila.

       MCHECK_OK (doar mprobe())
              Nu s-a detectat nicio inconsecven<?>a.

       MCHECK_HEAD
              Memoria anterioara unui bloc alocat a fost alterata.

       MCHECK_TAIL
              Memoria care a urmat unui bloc alocat a fost alterata.

       MCHECK_FREE
              Un bloc de memorie a fost eliberat de doua ori.

VALOAREA RETURNATA
       mcheck() <?>i mcheck_pedantic() returneaza 0 in caz de succes, sau -1
       in caz de eroare.

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

       +---------------------------+---------------------+--------------------+
       |Interfa<?>a                | Atribut             | Valoare            |
       +---------------------------+---------------------+--------------------+
       |mcheck(),                  | Siguran<?>a firelor | MT-Unsafe          |
       |mcheck_pedantic(),         |                     | race:mcheck        |
       |mcheck_check_all(),        |                     | const:malloc_hooks |
       |mprobe()                   |                     |                    |
       +---------------------------+---------------------+--------------------+
STANDARDE
       GNU.

ISTORIC
       mcheck_pedantic()
       mcheck_check_all()
              glibc 2.2.

       mcheck()
       mprobe()
              glibc 2.0.

NOTE
       Legarea unui program cu -lmcheck <?>i utilizarea variabilei de mediu
       MALLOC_CHECK_ (descrisa in mallopt(3)) determina detectarea acelora<?>i
       tipuri de erori. Insa, utilizarea MALLOC_CHECK_ nu necesita relegarea
       aplica<?>iei.

EXEMPLE
       Programul de mai jos apeleaza mcheck() cu un argument NULL <?>i apoi
       elibereaza acela<?>i bloc de memorie de doua ori. Urmatoarea sesiune
       shell demonstreaza ce se intampla la rularea programului:

           $ ./a.out
           Pe cale sa se elibereze

           Pe cale sa se elibereze a doua oara
           bloc eliberat de doua ori
           Opera<?>ie abandonata (memorie descarcata)

   Sursa programului
       #include <mcheck.h>
       #include <stdio.h>
       #include <stdlib.h>

       int
       main(void)
       {
           char *p;

           if (mcheck(NULL) != 0) {
               fprintf(stderr, "mcheck() a e<?>uat\n");

               exit(EXIT_FAILURE);
           }

           p = malloc(1000);

           fprintf(stderr, "Pe cale sa se elibereze\n");
           free(p);
           fprintf(stderr, "\nPe cale sa se elibereze a doua oara\n");
           free(p);

           exit(EXIT_SUCCESS);
       }

CONSULTA<?>I <?>I
       malloc(3), mallopt(3), mtrace(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.15   5 iunie 2025                        mcheck(3)