piste-jp
commented
6 years ago First of all, thank you for your interests about this project.
I understand what you are saying is
- 3 threads, thread A, B and C, are spawned from the main thread
- Thread A initializes the mutex
- Thread B takes the mutex
- Thread C tries to release the mutex (But this release is failed)
Is this correct?
From POSIX point of view, unlock against a mutex taken by another thread is "undefined". But I think Linux and OSX allows to unlock a mutex by different thread when the mutex is created by pthread_mutex_init(lock, NULL), default attribute.
I don't know the FreeBSD behavior well. So I tried to confirm the problem by following tiny code but I cannot recreated on FreeBSD 11.1. The mutex was released successfully.
Am I missing something? It is very helpful if you provide a pseudo code or tiny test code.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <stdbool.h>
#include <pthread.h>
bool keep_alive = true;
bool locked = false;
static void *init_thread(void *arg)
{
int ret;
pthread_mutex_t *lock = (pthread_mutex_t *)arg;
ret = pthread_mutex_init(lock, NULL);
if (ret < 0)
printf("Failed to init the lock(%d)\n", errno);
else
printf("The lock was initialized\n");
while (keep_alive)
sleep(3);
return NULL;
}
static void *lock_thread(void *arg)
{
int ret;
pthread_mutex_t *lock = (pthread_mutex_t *)arg;
while (keep_alive) {
if (!locked) {
ret = pthread_mutex_lock(lock);
if (ret < 0)
printf("Failed to take the lock(%d)\n", errno);
else
printf("The lock was took\n");
locked = true;
}
sleep(3);
}
return NULL;
}
static void *unlock_thread(void *arg)
{
int ret;
pthread_mutex_t *lock = (pthread_mutex_t *)arg;
while (keep_alive) {
if (locked) {
ret = pthread_mutex_unlock(lock);
if (ret < 0)
printf("Failed to release the lock(%d)\n", errno);
else
printf("The lock was released\n");
locked = false;
}
sleep(3);
}
return NULL;
}
int main(int argc, char** argv)
{
int ret = 0;
pthread_mutex_t lock;
pthread_t ti, tl, tu;
ret = pthread_create(&ti, NULL, init_thread, &lock);
if (ret < 0) {
printf("Failed to create a thread (%d)\n", errno);
return 1;
}
sleep(3);
ret = pthread_create(&tl, NULL, lock_thread, &lock);
if (ret < 0) {
printf("Failed to create a thread (%d)\n", errno);
return 1;
}
ret = pthread_create(&tu, NULL, unlock_thread, &lock);
if (ret < 0) {
printf("Failed to create a thread (%d)\n", errno);
return 1;
}
sleep(60);
keep_alive = false;
ret = pthread_join(ti, NULL);
if (ret < 0) {
printf("Failed to join the thread (%d)\n", errno);
return 1;
} else
printf("Thread joined\n");
ret = pthread_join(tl, NULL);
if (ret < 0) {
printf("Failed to join the thread (%d)\n", errno);
return 1;
} else
printf("Thread joined\n");
ret = pthread_join(tu, NULL);
if (ret < 0) {
printf("Failed to join the thread (%d)\n", errno);
return 1;
} else
printf("Thread joined\n");
pthread_mutex_destroy(&lock);
return 0;
}
linnemannr
Summary
The MRSW lock uses a single reader mutex that is locked by the first reader thread to acquire the read lock and released by the last thread to release the read lock. If the first acquiring and last releasing threads are not the same threads, the mutex will be left locked by the first thread and never unlocked. The next attempt to acquire the read lock will deadlock the calling thread since it will try to lock the mutex, which is still locked.
Description
Example:
Environment
How to recreate
This will not show up in the FUSE driver, since it is inherently single threaded. You will need to write a test program that links to libltfs and spawns threads that hold the reader lock on a volume in overlapping rather than nested windows. You could guarantee the timing by coordinating the threads with condvars.
I've gotten around this with a local delta by replacing the innards of the mrsw implementation with pthread_rwlock_t for our FreeBSD build, but that is not a portable solution.