Bug avec mutex robuste

J’essaie d’utiliser des mutex robustes sur Linux pour protéger les ressources entre les processus et il semble que dans certaines situations, ils ne se comportent pas de manière “robuste”. Par “robuste”, je veux dire que pthread_mutex_lock devrait renvoyer EOWNERDEAD si le processus propriétaire du verrou est terminé.

Voici le scénario où cela ne fonctionne pas:

2 processus p1 et p2. p1 crée un mutex robuste et l’attend (après la saisie de l’utilisateur). p2 a 2 threads: le thread 1 mappe dans le mutex et l’acquiert. Le thread 2 (après que le thread 1 a acquis le mutex) se transforme également dans le même mutex et attend (depuis que le thread 1 le possède maintenant). Notez également que p1 commence à attendre sur le mutex après que p2-thread1 l’ait déjà acquis.

Maintenant, si on termine p2, p1 ne se débloque jamais (ce qui signifie que pthread_mutex_lock ne retourne jamais) contrairement à la supposée “robustesse” où p1 devrait être débloqué avec l’erreur EOWNERDEAD.

• En C, quelle est la taille du tampon stdout?
• Comment obtenir l’adresse physique des données associées à partir d’une page de structure?
• Impossible d’utiliser pread sur un descripteur de fichier pour un périphérique vfio pci
• gdb: conditionnellement à la fonction break si la fonction caller n’est pas égale à certaine valeur
• Comment comstackr curl avec le dernier openssl

Voici le code:

p1.cpp:

#include  #include  #include  #include  #include  #include  #include  #include  struct MyMtx { pthread_mutex_t m; }; int main(int argc, char **argv) { int r; pthread_mutexattr_t ma; pthread_mutexattr_init(&ma); pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED); pthread_mutexattr_setrobust_np(&ma, PTHREAD_MUTEX_ROBUST_NP); int fd = shm_open("/test_mtx_p", O_RDWR|O_CREAT, 0666); ftruncate(fd, sizeof(MyMtx)); MyMtx *m = (MyMtx *)mmap(NULL, sizeof(MyMtx), PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0); //close (fd); pthread_mutex_init(&m->m, &ma); puts("Press Enter to lock mutex"); fgetc(stdin); puts("locking..."); r = pthread_mutex_lock(&m->m); printf("pthread_mutex_lock returned %d\n", r); puts("Press Enter to unlock"); fgetc(stdin); r = pthread_mutex_unlock(&m->m); printf("pthread_mutex_unlock returned %d\n", r); puts("Before pthread_mutex_destroy"); r = pthread_mutex_destroy(&m->m); printf("After pthread_mutex_destroy, r=%d\n", r); munmap(m, sizeof(MyMtx)); shm_unlink("/test_mtx_p"); return 0; } 

p2.cpp:

  #include  #include  #include  #include  #include  #include  #include  #include  struct MyMtx { pthread_mutex_t m; }; static void *threadFunc(void *arg) { int fd = shm_open("/test_mtx_p", O_RDWR|O_CREAT, 0666); ftruncate(fd, sizeof(MyMtx)); MyMtx *m = (MyMtx *)mmap(NULL, sizeof(MyMtx), PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0); sleep(2); //to let the first thread lock the mutex puts("Locking from another thread"); int r = 0; r = pthread_mutex_lock(&m->m); printf("locked from another thread r=%d\n", r); } int main(int argc, char **argv) { int r; int fd = shm_open("/test_mtx_p", O_RDWR|O_CREAT, 0666); ftruncate(fd, sizeof(MyMtx)); MyMtx *m = (MyMtx *)mmap(NULL, sizeof(MyMtx), PROT_READ | PROT_WRITE, MAP_SHARED,fd, 0); //close (fd); pthread_t tid; pthread_create(&tid, NULL, threadFunc, NULL); puts("locking"); r = pthread_mutex_lock(&m->m); printf("pthread_mutex_lock returned %d\n", r); puts("Press Enter to terminate"); fgetc(stdin); kill(getpid(), 9); return 0; } 

Tout d’abord, exécutez p1, puis exécutez p2 et attendez qu’il affiche “Verrouillage d’un autre thread”. Appuyez sur Entrée sur le shell de p1 pour verrouiller le mutex, puis appuyez sur Entrée sur le shell de p2 pour terminer p2, ou vous pouvez simplement le tuer d’une autre manière. Vous verrez que p1 imprime “locking …” et que pthread_mutex_lock ne retourne jamais.

Le problème ne se produit pas tout le temps, il semble que cela dépend du moment. Si vous laissez un peu de temps après que p1 commence à se bloquer et avant de terminer p2, cela fonctionne parfois et pthread_mutex_lock de p2 renvoie 130 (EOWNERDEAD). Mais si vous terminez p2 juste après ou peu de temps après que p1 commence à attendre sur le mutex, p1 ne sera jamais débloqué.

Quelqu’un d’autre a-t-il déjà rencontré le même problème?

• Débogage à distance .NET Core Linux Docker Container – “la source actuelle est différente de la version intégrée à .dll”
• Exécuter / invoquer le programme de l’espace utilisateur et obtenir son pid à partir d’un module du kernel
• Comment piéger les lectures et écritures de mémoire en utilisant sigsegv?
• Les stacks sont exécutables même avec `noexecstack`
• term.h: en-tête introuvable

 pthread_mutexattr_setprotocol(&ma, PTHREAD_PRIO_INHERIT); 

  Main: Call A A: Lock Call B Produce Unlock B: Lock Consume Unlock