pthread_mutexattr_setrobust(3)                        Library Functions Manual

NUME
       pthread_mutexattr_getrobust, pthread_mutexattr_setrobust - ob<?>ine
       <?>i define<?>te atributul de robuste<?>e al unui obiect cu atribute
       mutex

BIBLIOTECA
       Biblioteca de fire de execu<?>ie POSIX (libpthread, -lpthread)

SINOPSIS
       #include <pthread.h>

       int pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr,
                                       int *robustness);
       int pthread_mutexattr_setrobust(pthread_mutexattr_t *attr,
                                       int robustness);

   Cerin<?>e pentru macrocomenzi de testare a caracteristicilor pentru glibc
   (consulta<?>i feature_test_macros(7)):

       pthread_mutexattr_getrobust(), pthread_mutexattr_setrobust():
           _POSIX_C_SOURCE >= 200809L

DESCRIERE
       Func<?>ia pthread_mutexattr_getrobust() plaseaza in *robustness
       valoarea atributului de robuste<?>e al obiectului de atribute mutex la
       care se refera attr. Func<?>ia pthread_mutexattr_setrobust()
       stabile<?>te valoarea atributului robuste<?>e al obiectului atribute
       mutex la care face referire attr la valoarea specificata in
       *robustness.

       Atributul ,,robustness" specifica comportamentul mutex-ului atunci cand
       firul proprietar moare fara sa deblocheze mutex-ul. Urmatoarele valori
       sunt valabile pentru robustness:

       PTHREAD_MUTEX_STALLED
              Aceasta este valoarea implicita pentru un obiect cu atribute
              mutex.  Daca un mutex este ini<?>ializat cu atributul
              PTHREAD_MUTEX_STALLED <?>i proprietarul sau moare fara sa-l
              deblocheze, mutex-ul ramane blocat ulterior <?>i orice incercare
              viitoare de a apela pthread_mutex_lock(3) pe mutex se va bloca
              pe termen nelimitat.

       PTHREAD_MUTEX_ROBUST
              Daca un mutex este ini<?>ializat cu atributul
              PTHREAD_MUTEX_ROBUST <?>i proprietarul sau moare fara a-l
              debloca, orice incercare viitoare de a apela
              pthread_mutex_lock(3) pe acest mutex va reu<?>i <?>i va returna
              EOWNERDEAD pentru a indica faptul ca proprietarul ini<?>ial nu
              mai exista <?>i ca mutex-ul este intr-o stare inconsistenta. De
              obicei, dupa ce EOWNERDEAD este returnat, urmatorul proprietar
              ar trebui sa apeleze pthread_mutex_consistent(3) pe mutex-ul
              achizi<?>ionat pentru a-l face din nou consistent inainte de a-l
              utiliza in continuare.

              Daca urmatorul proprietar deblocheaza mutex-ul folosind
              pthread_mutex_unlock(3) inainte de a-l face consistent, mutex-ul
              va fi permanent inutilizabil <?>i orice incercare ulterioara de
              a-l bloca folosind pthread_mutex_lock(3) va e<?>ua cu eroarea
              ENOTRECOVERABLE. Singura opera<?>ie permisa pe un astfel de
              mutex este pthread_mutex_destroy(3).

              Daca urmatorul proprietar inceteaza activitatea inainte de a
              apela pthread_mutex_consistent(3), opera<?>iile ulterioare
              pthread_mutex_lock(3) asupra acestui mutex vor returna in
              continuare EOWNERDEAD.

       Re<?>ine<?>i ca argumentul attr din pthread_mutexattr_getrobust() <?>i
       pthread_mutexattr_setrobust() trebuie sa se refere la un obiect de
       atribute mutex care a fost ini<?>ializat de pthread_mutexattr_init(3),
       in caz contrar comportamentul este indefinit.

VALOAREA RETURNATA
       In caz de succes, aceste func<?>ii returneaza 0. In caz de eroare,
       acestea returneaza un numar pozitiv de eroare.

       In implementarea glibc, pthread_mutexattr_getrobust() returneaza
       intotdeauna zero.

ERORI-IE<?>IRE
       EINVAL O alta valoare decat PTHREAD_MUTEX_STALLED sau
              PTHREAD_MUTEX_ROBUST a fost trecuta la
              pthread_mutexattr_setrobust().

VERSIUNI
       In implementarea Linux, atunci cand se utilizeaza mutex-uri robuste
       partajate de proces, un fir in a<?>teptare prime<?>te <?>i notificarea
       EOWNERDEAD daca proprietarul unui mutex robust efectueaza un execve(2)
       fara a debloca mai intai mutex-ul. POSIX.1 nu specifica acest detaliu,
       dar acela<?>i comportament apare <?>i in cel pu<?>in alte implementari.

STANDARDE
       POSIX.1-2008.

ISTORIC
       glibc 2.12.  POSIX.1-2008.

       Inainte de adaugarea la POSIX a func<?>iilor
       pthread_mutexattr_getrobust() <?>i pthread_mutexattr_setrobust(), glibc
       a definit urmatoarele func<?>ii non-standard echivalente daca
       _GNU_SOURCE era definita:

       [[depreciat]
       int pthread_mutexattr_getrobust_np(const pthread_mutexattr_t *attr,
                                          int *robustness);
       [[depreciat]
       int pthread_mutexattr_setrobust_np(const pthread_mutexattr_t *attr,
                                          int robustness);

       In consecin<?>a, au fost definite <?>i constantele
       PTHREAD_MUTEX_STALLED_NP <?>i PTHREAD_MUTEX_ROBUST_NP.

       Aceste API-uri specifice GNU, care au aparut pentru prima data in glibc
       2.4, sunt in prezent invechite <?>i nu ar trebui utilizate in programe
       noi; incepand cu glibc 2.34 aceste API-uri sunt marcate ca fiind
       depreciate.

EXEMPLE
       Programul de mai jos demonstreaza utilizarea atributului ,,robustness"
       al unui obiect cu atribute mutex. In acest program, un fir care
       de<?>ine mutex-ul moare prematur fara sa deblocheze mutex-ul. Firul
       principal dobande<?>te ulterior mutex-ul cu succes <?>i prime<?>te
       eroarea EOWNERDEAD, dupa care face mutex-ul consistent.

       Urmatoarea sesiune shell arata ce vedem la rularea acestui program:

           $ ./a.out
           [proprietarul original ] Amplasarea blocarii...
           [proprietarul original] Blocat. Acum ies fara sa deblochez.
           [main] Se incearca blocarea mutex-ului robust.
           [main] pthread_mutex_lock() a returnat EOWNERDEAD
           [main] Acum se face mutex-ul consistent
           [main] Mutex-ul este acum consistent; se deblocheaza

   Sursa programului
       #include <errno.h>
       #include <pthread.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>

       #define handle_error_en(en, msg) \
               do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

       static pthread_mutex_t mtx;

       static void *
       original_owner_thread(void *ptr)
       {
           printf("[proprietarul original ] Amplasarea blocarii...\n");
           pthread_mutex_lock(&mtx);
           printf("[proprietarul original] Blocat. Acum ies fara sa deblochez.\n");
           pthread_exit(NULL);
       }

       int
       main(void)
       {
           pthread_t thr;
           pthread_mutexattr_t attr;
           int s;

           pthread_mutexattr_init(&attr);

           pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);

           pthread_mutex_init(&mtx, &attr);

           pthread_create(&thr, NULL, original_owner_thread, NULL);

           sleep(2);

           /* ,,original_owner_thread" ar trebui sa fi ie<?>it pana acum.  */

           printf("[main] Se incearca blocarea mutex-ului robust.\n");
           s = pthread_mutex_lock(&mtx);
           if (s == EOWNERDEAD) {
               printf("[main] pthread_mutex_lock() a returnat EOWNERDEAD\n");
               printf("[main] Acum se face mutex-ul consistent\n");
               s = pthread_mutex_consistent(&mtx);
               if (s != 0)
                   handle_error_en(s, "pthread_mutex_consistent");
               printf("[main] Mutex-ul este acum consistent; se deblocheaza\n");
               s = pthread_mutex_unlock(&mtx);
               if (s != 0)
                   handle_error_en(s, "pthread_mutex_unlock");

               exit(EXIT_SUCCESS);
           } else if (s == 0) {
               printf("[main] pthread_mutex_lock() a reu<?>it in mod nea<?>teptat\n");
               exit(EXIT_FAILURE);
           } else {
               printf("[main] pthread_mutex_lock() a e<?>uat in mod nea<?>teptat[main]\n");
               handle_error_en(s, "pthread_mutex_lock");
           }
       }

CONSULTA<?>I <?>I
       get_robust_list(2), set_robust_list(2), pthread_mutex_consistent(3),
       pthread_mutex_init(3), pthread_mutex_lock(3), pthreads(7)

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.12   23 iulie 2024  pthread_mutexattr_setrobust(3)