NUME

       mcheck, mcheck_check_all, mcheck_pedantic, mprobe - verifică consistența grămezii

BIBLIOTECA

       Biblioteca C standard (libc, -lc)

SINOPSIS

       #include <mcheck.h>

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

       enum mcheck_status mprobe(void *ptr);

DESCRIERE

       Funcția mcheck() instalează un set de cârlige de depanare pentru familia de funcții de alocare a memoriei
       malloc(3).   Aceste  cârlige  determină  efectuarea  anumitor  verificări  de  consistență  asupra stării
       grămezii. Verificările 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ță care preced imediat un bloc de memorie alocat.

       Pentru a fi eficientă, funcția mcheck() trebuie să fie apelată înainte de primul apel la malloc(3) sau la
       o funcție conexă. În cazurile în care acest lucru  este  dificil  de  asigurat,  legarea  programului  cu
       -lmcheck inserează un apel implicit la mcheck() (cu un argument NULL) înainte de primul apel la o funcție
       de alocare a memoriei.

       Funcția  mcheck_pedantic() este similară cu mcheck(), dar efectuează verificări asupra tuturor blocurilor
       alocate ori de câte ori este apelată una dintre funcțiile de alocare a memoriei.  Acest  lucru  poate  fi
       foarte lent!

       Funcția mcheck_check_check_all() determină o verificare imediată a tuturor blocurilor alocate. Acest apel
       este eficient numai dacă mcheck() este apelată mai înainte.

       În  cazul  în care sistemul detectează o inconsistență în grămadă, funcția furnizată de apelant, indicată
       de abortfunc, este invocată cu un singur argument, mstatus, care indică ce tip de  inconsistență  a  fost
       detectată.  Dacă  abortfunc  este  NULL,  o  funcție  implicită  afișează un mesaj de eroare la stderr și
       apelează abort(3).

       Funcția mprobe() efectuează o verificare a consistenței  blocului  de  memorie  alocat  indicat  de  ptr.
       Funcția mcheck() trebuie apelată în prealabil (în caz contrar, mprobe() returnează MCHCHECK_DISABLED).

       Următoarea  listă  descrie  valorile  returnate de mprobe() sau transmise ca argument mstatus atunci când
       este invocată abortfunc:

       MCHECK_DISABLED (doar mprobe())
              mcheck() nu a fost apelată  înainte  de  a  fi  apelată  prima  funcție  de  alocare  a  memoriei.
              Verificarea consistenței nu este posibilă.

       MCHECK_OK (doar mprobe())
              Nu s-a detectat nicio inconsecvență.

       MCHECK_HEAD
              Memoria anterioară unui bloc alocat a fost alterată.

       MCHECK_TAIL
              Memoria care a urmat unui bloc alocat a fost alterată.

       MCHECK_FREE
              Un bloc de memorie a fost eliberat de două ori.

VALOAREA RETURNATĂ

       mcheck() și mcheck_pedantic() returnează 0 în caz de succes, sau -1 în caz de eroare.

ATRIBUTE

       Pentru o explicație a termenilor folosiți în această secțiune, a se vedea attributes(7).
       ┌───────────────────────────────────────────────────────────┬───────────────────┬───────────────────────┐
       │ Interfață                                                 │ Atribut           │ Valoare               │
       ├───────────────────────────────────────────────────────────┼───────────────────┼───────────────────────┤
       │ mcheck(), mcheck_pedantic(), mcheck_check_all(), mprobe() │ Siguranța firelor │ MT-Unsafe race:mcheck │
       │                                                           │                   │ const:malloc_hooks    │
       └───────────────────────────────────────────────────────────┴───────────────────┴───────────────────────┘

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_ (descrisă în mallopt(3))
       determină  detectarea  acelorași  tipuri  de  erori. Însă, utilizarea MALLOC_CHECK_ nu necesită relegarea
       aplicației.

EXEMPLE

       Programul de mai jos apelează mcheck() cu un argument NULL și apoi eliberează același bloc de memorie  de
       două ori. Următoarea sesiune shell demonstrează ce se întâmplă la rularea programului:

           $ ./a.out
           Pe cale să se elibereze

           Pe cale să se elibereze a doua oară
           bloc eliberat de două ori
           Operație abandonată (memorie descărcată)

   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 să se elibereze\n");
           free(p);
           fprintf(stderr, "\nPe cale să se elibereze a doua oară\n");
           free(p);

           exit(EXIT_SUCCESS);
       }

CONSULTAȚI ȘI

       malloc(3), mallopt(3), mtrace(3)

TRADUCERE

       Traducerea    în   limba   română   a   acestui   manual   a   fost   făcută   de   Remus-Gabriel   Chelu
       <remusgabriel.chelu@disroot.org>

       Această traducere este  documentație  gratuită;  citiți  Licența publică generală GNU Versiunea 3  sau  o
       versiune   ulterioară   cu  privire  la  condiții  privind  drepturile  de  autor.   NU  se  asumă  NICIO
       RESPONSABILITATE.

       Dacă găsiți erori în traducerea acestui manual, vă rugăm să  trimiteți  un  e-mail  la  translation-team-
       ro@lists.sourceforge.net.

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