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.9.1                   15 iunie 2024                                        mcheck(3)